Arbeiten mit Arrays in Linux Shell Scripting – Teil 8

Wir können uns eine Programmiersprache ohne das Konzept von Arrays nicht vorstellen. Es spielt keine Rolle, wie sie in verschiedenen Sprachen implementiert werden. Stattdessen helfen uns Arrays dabei, ähnliche oder unterschiedliche Daten unter einem symbolischen Namen zu konsolidieren.

Da wir uns mit Shell-Skripten beschäftigen, hilft Ihnen dieser Artikel dabei, mit einigen Shell-Skripten herumzuspielen, die dieses Array-Konzept nutzen.

Array-Initialisierung und -Nutzung

Mit neueren Versionen von Bash werden eindimensionale Arrays unterstützt. Ein Array kann explizit durch die in der Shell integrierte Funktion declare deklariert werden.

declare -a var  

Es ist jedoch nicht erforderlich, Array-Variablen wie oben zu deklarieren. Wir können einzelne Elemente wie folgt direkt in ein Array einfügen.

var[XX]=<value>

wobei „XX“ den Array-Index bezeichnet. Um Array-Elemente zu dereferenzieren, verwenden Sie die Syntax mit geschweiften Klammern, d. h.

${var[XX]}

Hinweis: Die Array-Indizierung beginnt immer mit 0.

Eine weitere praktische Möglichkeit, ein gesamtes Array zu initialisieren, ist die Verwendung des Klammerpaars, wie unten gezeigt.

var=( element1 element2 element3 . . . elementN )

Es gibt noch eine weitere Möglichkeit, Arrays Werte zuzuweisen. Diese Art der Initialisierung ist eine Unterkategorie der zuvor erläuterten Methode.

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

Mit der integrierten read-Shell können wir auch während der Ausführungszeit Werte zum Array lesen/zuordnen.

read -a array

Wenn nun die obige Anweisung in einem Skript ausgeführt wird, wartet es auf eine Eingabe. Wir müssen die Array-Elemente durch Leerzeichen (und nicht durch Wagenrücklauf) getrennt bereitstellen. Nachdem Sie die Werte eingegeben haben, drücken Sie zum Beenden die Eingabetaste.

Um die Array-Elemente zu durchlaufen, können wir auch eine for-Schleife verwenden.

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

Das folgende Skript fasst den Inhalt dieses speziellen Abschnitts zusammen.

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

Verschiedene Operationen auf Arrays

Viele der Standard-String-Operationen funktionieren auf Arrays. Schauen Sie sich das folgende Beispielskript an, das einige Operationen für Arrays implementiert (einschließlich String-Operationen).

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

Es folgt die Ausgabe, die bei der Ausführung des obigen Skripts erzeugt wird.

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

Ich denke, dass es keinen Sinn macht, das obige Skript im Detail zu erklären, da es selbsterklärend ist. Bei Bedarf werde ich einen Teil dieser Serie ausschließlich den String-Manipulationen widmen.

Befehlsersetzung mit Arrays

Die Befehlsersetzung ordnet die Ausgabe eines Befehls oder mehrerer Befehle einem anderen Kontext zu. Hier können wir in diesem Kontext von Arrays die Ausgabe von Befehlen als einzelne Elemente von Arrays einfügen. Die Syntax ist wie folgt.

array=( $(command) )

Standardmäßig werden die durch Leerzeichen getrennten Inhalte in der Ausgabe des Befehls als einzelne Elemente in das Array eingefügt. Das folgende Skript listet den Inhalt eines Verzeichnisses auf, bei dem es sich um Dateien mit 755-Berechtigungen handelt.

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

Simulation zweidimensionaler Arrays

Wir können eine zweidimensionale Matrix leicht mithilfe eines eindimensionalen Arrays darstellen. In der Zeilenhauptordnung-Darstellung werden Elemente in jeder Zeile einer Matrix nacheinander und nacheinander in Array-Indizes gespeichert. Für eine mXn-Matrix kann die Formel dafür geschrieben werden als.

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

Sehen Sie sich ein weiteres Beispielskript zum Hinzufügen von zwei Matrizen und zum Drucken der resultierenden Matrix an.

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

Obwohl es Einschränkungen für die Implementierung von Arrays innerhalb von Shell-Skripten gibt, ist sie in einigen wenigen Situationen nützlich, insbesondere wenn wir mit der Befehlsersetzung arbeiten. Aus administrativer Sicht ebnete das Konzept der Arrays den Weg für die Entwicklung vieler Hintergrundskripte in GNU/Linux-Systemen.