Tömbök használata Linux Shell Scriptingben – 8. rész

Nem tudunk elképzelni egy programozási nyelvet a tömbök fogalma nélkül. Nem számít, hogyan valósítják meg ezeket a különböző nyelveken. Ehelyett a tömbök segítenek bennünket abban, hogy egy szimbolikus név alatt összevonjuk a hasonló vagy eltérő adatokat.

Mivel a shell szkriptek miatt aggódunk, ez a cikk segít néhány olyan shell szkripttel való játékban, amelyek a tömbök ezen koncepcióját használják.

Tömb inicializálása és használata

A bash újabb verzióival támogatja az egydimenziós tömböket. Egy tömb kifejezetten deklarálható a beépített declare shell-el.

declare -a var  

De nem szükséges a tömbváltozókat a fentiek szerint deklarálni. Az egyes elemeket közvetlenül beilleszthetjük a tömbbe az alábbiak szerint.

var[XX]=<value>

ahol az „XX” a tömb indexét jelöli. A tömbelemek hivatkozásának megszüntetéséhez használja a göndör zárójeles szintaxist, azaz.

${var[XX]}

Megjegyzés: A tömbindexelés mindig 0-val kezdődik.

Egy másik kényelmes módja a teljes tömb inicializálásának a zárójelpár használata az alábbiak szerint.

var=( element1 element2 element3 . . . elementN )

Van még egy módja annak, hogy értékeket rendeljünk a tömbökhöz. Az inicializálásnak ez a módja a korábban ismertetett módszer egy alkategóriája.

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

A végrehajtási idő alatt is beolvashatunk/rendelhetünk értékeket a tömbhöz a beépített read shell használatával.

read -a array

Most, amikor végrehajtja a fenti utasítást egy szkripten belül, vár némi bevitelre. A tömbelemeket szóközzel elválasztva kell megadnunk (és nem kocsivissza). Az értékek megadása után nyomja meg az entert a befejezéshez.

A tömb elemeinek áthaladásához használhatjuk a for ciklust is.

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

A következő szkript összefoglalja ennek a szakasznak a tartalmát.

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

Különféle műveletek tömbökön

A szabványos karakterlánc-műveletek közül sok működik tömbökön. Tekintse meg a következő példaszkriptet, amely néhány műveletet valósít meg tömbökön (beleértve a karakterlánc-műveleteket is).

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

Az alábbiakban látható a fenti szkript végrehajtása során előállított kimenet.

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

Szerintem nincs jelentősége annak, hogy a fenti szkriptet részletesen elmagyarázzuk, mivel az magától értetődő. Ha szükséges, ebből a sorozatból egy részt kizárólag a húrmanipulációknak szentelek.

Parancshelyettesítés tömbökkel

A parancshelyettesítés egy parancs vagy több parancs kimenetét egy másik kontextushoz rendeli. Ebben a tömbök kontextusában beilleszthetjük a parancsok kimenetét a tömbök egyedi elemeiként. A szintaxis a következő.

array=( $(command) )

Alapértelmezés szerint a parancs kimenetének szóközökkel elválasztott tartalma különálló elemként tömbbe kerül. A következő szkript egy könyvtár tartalmát sorolja fel, amelyek 755 engedéllyel rendelkező fájlok.

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

Kétdimenziós tömbök szimulálása

Könnyen ábrázolhatunk egy 2-dimenziós mátrixot egy 1-dimenziós tömb segítségével. A sor fő sorrendjében a mátrix minden sorában az ábrázolási elemeket a rendszer fokozatosan tömbindexekben tárolja, szekvenciálisan. Egy mXn mátrixhoz ugyanennek a képlete a következőképpen írható fel.

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

Nézzen meg egy másik minta szkriptet 2 mátrix hozzáadásához és a kapott mátrix kinyomtatásához.

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

Annak ellenére, hogy a tömbök shell-szkripteken belüli megvalósításának vannak korlátai, ez néhány esetben hasznossá válik, különösen, ha parancshelyettesítéssel kezeljük. Adminisztratív szempontból a tömbök koncepciója megnyitotta az utat számos háttérszkript fejlesztéséhez a GNU/Linux rendszerekben.