Darbs ar masīviem Linux Shell skriptos - 8. daļa

Mēs nevaram iedomāties programmēšanas valodu bez masīvu jēdziena. Nav svarīgi, kā tie tiek ieviesti dažādās valodās. Tā vietā masīvi palīdz mums konsolidēt līdzīgus vai atšķirīgus datus ar vienu simbolisku nosaukumu.

Tā kā mums ir bažas par čaulas skriptiem, šis raksts palīdzēs jums spēlēt ar dažiem čaulas skriptiem, kas izmanto šo masīvu jēdzienu.

Masīva inicializēšana un izmantošana

Ar jaunākām bash versijām tas atbalsta viendimensiju masīvus. Masīvu var skaidri deklarēt iebūvētais čaulas deklarēt .

declare -a var  

Bet nav nepieciešams deklarēt masīva mainīgos, kā norādīts iepriekš. Mēs varam ievietot atsevišķus elementus masīvam tieši šādi.

var[XX]=<value>

kur ‘XX’ apzīmē masīva indeksu. Lai novirzītu masīva elementus, izmantojiet cirtainās iekavas sintaksi, t.i.

${var[XX]}

Piezīme: Masīvu indeksēšana vienmēr sākas ar 0.

Vēl viens ērts visa masīva inicializācijas veids ir iekavu pāra izmantošana, kā parādīts zemāk.

var=( element1 element2 element3 . . . elementN )

Ir vēl viens veids, kā piešķirt masīviem vērtības. Šis inicializācijas veids ir iepriekš izskaidrotās metodes apakškategorija.

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

Mēs varam arī nolasīt/piešķirt masīvam vērtības izpildes laikā, izmantojot lasīt iebūvēto čaulu.

read -a array

Tagad, izpildot iepriekš minēto paziņojumu skripta iekšpusē, tas gaida ievadi. Mums jānodrošina masīva elementi, kas atdalīti ar atstarpi (un nevis karietes atgriešanos). Pēc vērtību ievadīšanas nospiediet taustiņu Enter, lai pārtrauktu.

Lai šķērsotu masīva elementus, mēs varam izmantot arī cilpu.

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

Šis skripts apkopo šīs konkrētās sadaļas saturu.

#!/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

Daudzas standarta virkņu operācijas darbojas masīvos. Apskatiet šo skripta paraugu, kas īsteno dažas masīvu darbības (ieskaitot virknes operācijas).

#!/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

Tālāk ir produkcija, kas iegūta, izpildot iepriekš minēto skriptu.

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

Es domāju, ka nav nozīmes detalizēti izskaidrot iepriekš minēto skriptu, jo tas ir pats par sevi saprotams. Ja nepieciešams, vienu šīs sērijas daļu veltīšu tikai stīgu manipulācijām.

Komandas aizstāšana piešķir komandas vai vairāku komandu izvadi citā kontekstā. Šajā masīvu kontekstā mēs varam ievietot komandu izvadi kā atsevišķus masīvu elementus. Sintakse ir šāda.

array=( $(command) )

Pēc noklusējuma komandas izvades saturs, atdalīts ar atstarpēm, tiek pievienots masīvam kā atsevišķi elementi. Šajā skriptā ir uzskaitīts direktorija saturs, kas ir faili ar 755 atļaujām.

#!/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

Mēs varam viegli attēlot 2-dimensiju matricu, izmantojot 1-dimensiju masīvu. rindas galvenajā secībā reprezentācijas elementi katrā matricas rindā pakāpeniski tiek secīgi glabāti masīvu indeksos. MXn matricai formulu tam pašam var uzrakstīt kā.

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

Apskatiet citu skripta paraugu, lai pievienotu 2 matricas un izdrukātu iegūto matricu.

#!/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 

Kaut arī masīvu ieviešanai čaulas skriptu veidošanā ir ierobežojumi, tas kļūst noderīgs nedaudzās situācijās, it īpaši, ja mēs rīkojamies ar komandu aizstāšanu. Skatoties no administratīvā viedokļa, masīvu koncepcija pavēra ceļu daudzu fona skriptu izstrādei GNU/Linux sistēmās.