Delo z nizi v Linux Shell Scripting - 8. del

Programskega jezika si ne moremo predstavljati brez koncepta nizov. Ni pomembno, kako se izvajajo med različnimi jeziki. Namesto tega nam nizi pomagajo pri združevanju podobnih ali drugačnih podatkov pod enim simboličnim imenom.

Ker nas tukaj skrbi skript lupine, vam bo ta članek pomagal pri igranju z nekaterimi lupinskimi skripti, ki uporabljajo ta koncept nizov.

Inicializacija in uporaba matrike

Z novejšimi različicami bash podpira enodimenzionalne nize. Niz lahko izrecno deklarira ukaz z vgrajeno lupino.

declare -a var  

Vendar ni treba navesti spremenljivk matrike, kot je navedeno zgoraj. Posamezne elemente lahko v matriko vstavimo neposredno, kot sledi.

var[XX]=<value>

kjer 'XX' pomeni indeks matrike. Za razporejanje elementov matrike uporabite sintakso kodrastih oklepajev, tj.

${var[XX]}

Opomba: Indeksiranje matrike se vedno začne z 0.

Drug priročen način inicializacije celotnega polja je uporaba para oklepajev, kot je prikazano spodaj.

var=( element1 element2 element3 . . . elementN )

Obstaja še en način dodeljevanja vrednosti nizom. Ta način inicializacije je podkategorija predhodno razložene metode.

array=( [XX]=<value> [XX]=<value> . . . )

V času izvajanja lahko tudi beremo/dodeljujemo vrednosti v matriko z branje v lupino.

read -a array

Zdaj po izvedbi zgornje izjave znotraj skripta počaka na nekaj vnosa. Navesti moramo matrične elemente, ločene s presledkom (in ne vrnitvijo nosilca). Po vnosu vrednosti pritisnite enter, da končate.

Za prehod skozi elemente polja lahko uporabimo tudi for loop.

for i in “${array[@]}”
do
	#access each element as $i. . .
done 

Naslednji skript povzema vsebino tega poglavja.

#!/bin/bash 

array1[0]=one 
array1[1]=1 
echo ${array1[0]} 
echo ${array1[1]} 

array2=( one two three ) 
echo ${array2[0]} 
echo ${array2[2]} 

array3=( [9]=nine [11]=11 ) 
echo ${array3[9]} 
echo ${array3[11]} 

read -a array4 
for i in "${array4[@]}" 
do 
	echo $i 
done 

exit 0

Številne standardne operacije nizov delujejo na nizih. Oglejte si naslednji vzorčni skript, ki izvaja nekatere operacije nad nizi (vključno z nizovnimi operacijami).

#!/bin/bash 

array=( apple bat cat dog elephant frog ) 

#print first element 
echo ${array[0]} 
echo ${array:0} 

#display all elements 
echo ${array[@]} 
echo ${array[@]:0} 

#display all elements except first one 
echo ${array[@]:1} 

#display elements in a range 
echo ${array[@]:1:4} 

#length of first element 
echo ${#array[0]} 
echo ${#array} 

#number of elements 
echo ${#array[*]} 
echo ${#array[@]} 

#replacing substring 
echo ${array[@]//a/A} 

exit 0

Sledi rezultat, ki je nastal pri izvajanju zgornjega skripta.

apple 
apple 
apple bat cat dog elephant frog 
apple bat cat dog elephant frog 
bat cat dog elephant frog 
bat cat dog elephant 
5 
5 
6 
6 
Apple bAt cAt dog elephAnt frog

Menim, da pri podrobni razlagi zgornjega scenarija ni nobenega pomena, saj je sam po sebi razumljiv. Po potrebi bom en del v tej seriji posvetil izključno manipulacijam z vrvicami.

Nadomeščanje ukazov dodeli izhod ukaza ali več ukazov v drug kontekst. Tu v tem kontekstu nizov lahko vstavimo izhod ukazov kot posamezne elemente nizov. Sintaksa je naslednja.

array=( $(command) )

Vsebina v izhodu ukaza, ločena s presledki, je privzeto vključena v matriko kot posamezni elementi. Naslednji skript vsebuje vsebino imenika, to so datoteke s 755 dovoljenji.

#!/bin/bash 

ERR=27 
EXT=0 

if [ $# -ne 1 ]; then 
	echo "Usage: $0 <path>" 
	exit $ERR 
fi 

if [ ! -d $1 ]; then 
	echo "Directory $1 doesn't exists" 
	exit $ERR 
fi 

temp=( $(find $1 -maxdepth 1 -type f) ) 

for i in "${temp[@]}" 
do 
	perm=$(ls -l $i) 
	if [ `expr ${perm:0:10} : "-rwxr-xr-x"` -eq 10 ]; then 
		echo ${i##*/} 
	fi 
done 

exit $EXT

Dvodimenzionalno matriko lahko enostavno predstavimo z uporabo enodimenzionalnega polja. V vrstici velikega vrstnega reda se elementi predstavitve v vsaki vrstici matrike zaporedno shranijo v indekse matrike. Za matriko mXn lahko formulo za isto napišemo kot.

matrix[i][j]=array[n*i+j]

Oglejte si še en vzorčni skript za dodajanje 2 matric in tiskanje nastale matrice.

#!/bin/bash 

read -p "Enter the matrix order [mxn] : " t 
m=${t:0:1} 
n=${t:2:1} 

echo "Enter the elements for first matrix" 
for i in `seq 0 $(($m-1))` 
do 
	for j in `seq 0 $(($n-1))` 
	do 
		read x[$(($n*$i+$j))] 
	done 
done 

echo "Enter the elements for second matrix" 
for i in `seq 0 $(($m-1))` 
do 
	for j in `seq 0 $(($n-1))` 
	do 
		read y[$(($n*$i+$j))] 
		z[$(($n*$i+$j))]=$((${x[$(($n*$i+$j))]}+${y[$(($n*$i+$j))]})) 
	done 
done 

echo "Matrix after addition is" 
for i in `seq 0 $(($m-1))` 
do 
	for j in `seq 0 $(($n-1))` 
	do 
		echo -ne "${z[$(($n*$i+$j))]}\t" 
	done 
	echo -e "\n" 
done 

exit 0 

Čeprav obstajajo omejitve za izvajanje nizov znotraj skriptov lupine, je to koristno v peščici situacij, zlasti kadar ravnamo z zamenjavo ukazov. Z upravnega vidika je koncept nizov odprl pot razvoju številnih skriptov v ozadju v sistemih GNU/Linux.