Ein Leitfaden für Bash-Arrays

In dieser Anleitung zu Bash-Arrays erfahren Sie, wie Sie indizierte und assoziative Arrays in der Bash deklarieren und damit arbeiten.

In der Bash können Sie Arrays erstellen, um eine Sammlung von Elementen zu speichern. Bash-Arrays sind eindimensionale Sammlungen. In Programmiersprachen wie C und C sind Arrays Sammlungen von Elementen desselben Datentyps. In der Bash können Sie jedoch je nach Anwendungsfall ganze Zahlen und Zeichenketten im selben Array speichern.

In diesem Lernprogramm lernen Sie, wie Sie ein Bash-Array deklarieren und auf seine Elemente zugreifen. Dann lernen Sie, wie Sie eine Schleife durch die Elemente eines Arrays ziehen und Elemente an ein Array anhängen. Schließlich lernen Sie noch etwas über assoziative Arrays in der Bash.

Fangen wir an!

⚙ Haben Sie Interesse, mitzukodieren? Hier sind die Voraussetzungen:

• Wenn Sie mit einem Mac oder einem Linux-Rechner arbeiten, können Sie Ihr Terminal öffnen und mitcodieren.
• Wenn Sie auf einem Windows-Rechner arbeiten, installieren Sie bitte Git Bash oder das Windows Subsystem für Linux (WSL2).

Wie man ein Bash-Array deklariert

In diesem Abschnitt lernen Sie die Syntax zur Deklaration eines Bash-Arrays und Codebeispiele kennen.

Syntax der Bash-Array-Deklaration

Sie können ein Array in der Bash mit der folgenden Syntax deklarieren:

$ arrayName=(elt1 elt2 ... eltN)

# arrayName ist der Name des Arrays
# elt1 bis eltN sind die N Elemente des Arrays

In der obigen Syntax bezeichnet arrayName den Namen des Arrays, das N Elemente elt1 ...eltN enthält.

Die Elemente eines Arrays werden zwischen der öffnenden und der schließenden Klammer () eingeschlossen. Beachten Sie auch, dass die Elemente des Arrays durch ein Leerzeichen getrennt sind. Wie bei jeder Bash-Variablen sollte vor oder nach dem Zuweisungsoperator = keine Leerzeichen stehen.

📑 In den meisten anderen Programmiersprachen trennen Sie die Elemente eines Arrays oder ähnlicher Sammlungen durch Kommas. Aber in der Bash ist das Leerzeichen das Trennzeichen.

In Bash werden solche Arrays, in denen die Elemente durch ihren Index identifiziert werden, als indizierte Arrays bezeichnet.

Indizierte Arrays in der Bash deklarieren

Lassen Sie uns Preise, ein Array mit Zahlen, erstellen.

$ preise=(24 27 18 30 15)

Wie in der Syntax erwähnt, werden die Zahlen im Array Preise durch ein Leerzeichen getrennt, in Klammern eingeschlossen und ohne Leerzeichen vor und nach dem = Zuweisungsoperator.

In der Bash können Sie den Befehl echo verwenden, um den Wert einer Variablen auszudrucken. Die Verwendung von $variableName gibt den Wert von variableName aus. Sie sehen jedoch, dass bei Verwendung des Namens des Arrays nur das erste Element ausgegeben wird.

$ echo $Preise
24

Bash-Arrays folgen der Null-Indexierung. Das erste Element steht also bei Index 0, das zweite Element bei Index 1 und so weiter. Sie können auch eine negative Indexierung verwenden; der Index des letzten Array-Elements ist -1.

Was passiert, wenn Sie versuchen, auf das Element mit einem bestimmten Index zuzugreifen und es auszudrucken? Versuchen wir, das Element bei Index 1 auszudrucken.

$ echo $Preise<x><x><x><x><x>[1]</x></x></x></x></x>
24<x><x><x><x><x>[1]</x></x></x></x></x>

Warum ist die Ausgabe 24[1]? 🤔 Das liegt daran, dass die Bash $prices durch 24, das erste Element des Arrays, ersetzt und [1] wird als solches gedruckt.

Um das Element an einen bestimmten Index auszudrucken, können Sie die Parametererweiterung der Form ${prices[index]} verwenden.

$ echo ${Preise<x><x><x><x><x>[1]</x></x></x></x></x>}
# 27
$ echo ${Preise<x>[2]</x>}
# 18

Um alle Elemente des Arrays auszudrucken, können Sie @ anstelle eines bestimmten Indexes angeben.

$ echo ${Preise[@]}
24 27 18 30 15

Als Nächstes wollen wir ein Array mit Strings erstellen. Wenn Sie den folgenden Befehl ausführen, wird ein indiziertes Array erstellt:

$ declare -a fruits

Würfel-Option -a erzeugt ein indiziertes Array. Sie können das Array nun Element für Element auffüllen, indem Sie das Element mit einem bestimmten Index deklarieren, wie unten gezeigt:

$ fruits[0]="Kirsche"
$ fruits<x><x><x><x><x>[1]</x></x></x></x></x>="Beere"
$ fruits<x>[2]</x>="Apfel"
$ fruits[3]="Birne"
$ fruits[4]="Melone"
$ fruits<x>[5]</x>="Orange"

Um nun alle Elemente des Arrays auszudrucken, können Sie ${fruits[@]} verwenden.

$ echo ${Früchte[@]}
Kirsche Beere Apfel Birne Melone Orange

Zugriff auf die Elemente eines Bash-Arrays

Sie können auf die Elemente des Arrays auf folgende Weise zugreifen:

• Schleife durch das Array und direkter Zugriff auf das Element
• Schleife durch die Menge der Indizes und Zugriff auf Elemente mit einem bestimmten Index

Schleife durch das Array und Zugriff auf Elemente

Wenn Sie in Python programmiert haben, werden Sie die für-Schleife mit der folgenden Syntax verwendet haben:

for elt in some_list:
 print(elt)

Lassen Sie uns nun das Bash-Äquivalent der obigen for-Schleife schreiben.

Wir wissen, dass {prices[@]} sich auf alle Elemente im Array prices ausdehnt. Und ${prices[@]} liefert uns die Werte aller Elemente.

Die for-Schleife der Bash ähnelt der for-Schleifensyntax von Python, aber die Anweisungen im Schleifenkörper sollten in do und done eingeschlossen werden, wie gezeigt:

$ for price in ${prices[@]}
> do
> echo $price
> done

Da wir den Befehl echo verwenden und den Wert der Variable price ausgeben, erhalten wir die folgende Ausgabe:

# output
24
27
18
30
15

Zugriff auf die Elemente über den Array-Index

Eine weitere Möglichkeit, Schleifen durch Arrays zu ziehen, ist die Verwendung des Index der Elemente. Dies ähnelt dem for-Schleifenkonstrukt in Python, wenn Sie die Funktion range() verwenden:

for i in range(len(some_list)):
 print(i)

Um eine Liste von Indizes für die Schleife zu erhalten, können Sie ein Ausrufezeichen (!) vor den Array-Namen in der Parametererweiterung setzen. Dadurch erhalten Sie eine Liste alle gültigen Indizes für das Array, wie gezeigt:

$ echo ${!Preise[@]}
0 1 2 3 4

Das Array Preise enthält 5 Elemente, außerdem beginnt der Index bei 0 und geht bis 4.

Als Nächstes können wir eine Schleife durch die Liste der Indizes ziehen und auf das Element bei jedem Index zugreifen. Für den Index i ist ${Preise<x>[i]</x>} das Element am Index i.

$ for i in ${!Preise[@]}
> do
> echo ${Preise<x>[i]</x>}
> done

Die obige Schleife gibt alle Elemente des Arrays aus.

# output
24
27
18
30
15

💬 Hier führen wir nach dem Zugriff auf jedes Element eine einfache Bedienung durch, indem wir seinen Wert ausdrucken. Im Allgemeinen können wir jede gültige Verarbeitung auf den Elementen durchführen.

Anhängen von Elementen an ein Bash-Array

In dem Array Preise haben wir fünf Elemente (mit den Indizes 0,1,2,3 und 4). Wenn Sie ein Element an das Ende des Arrays bei Index 5 anhängen möchten, können Sie dies wie folgt tun:

$ preise<x>[5]</x>=21

Wir sehen, dass 21 an das Ende des Arrays Preise angehängt wurde.

$ echo ${Preise[@]}
24 27 18 30 15 21

Es ist jedoch bequemer, an das Ende des Arrays anzuhängen - ohne sich den Index des zuletzt hinzugefügten Elements oder die Anzahl der aktuell im Array befindlichen Elemente zu merken.

Sie können arrayName =(elements(s)) verwenden, um ein oder mehrere Elemente an ein Array anzuhängen, wie gezeigt:

$ Preise =(10)

Wenn wir nun das Array Preise ausdrucken, sehen wir, dass 10 an das Ende des Arrays angehängt wurde.

$ echo ${Preise[@]}
24 27 18 30 15 21 10

Als Nächstes wollen wir lernen, wie man assoziative Arrays in der Bash deklariert.

Assoziative Arrays in der Bash

Wenn Sie eine Beziehung in Form von Schlüssel-Wert-Paaren definieren möchten, können Sie ein assoziatives Array verwenden. Sie können ein assoziatives Array mit der folgenden allgemeinen Syntax deklarieren. Beachten Sie, dass wir die Option -A anstelle von -a verwenden.

$ declare -A fruits_prices

Sie können dem assoziativen Array Elemente hinzufügen, indem Sie den Schlüssel und den entsprechenden Wert angeben. Hier haben wir die Namen der Früchte als Schlüssel und die Zahlen aus dem Array Preise als Werte hinzugefügt.

$ fruits_prices[cherry]=24
$ fruits_prices<x>[berry]</x>=27
$ fruits_prices[apple]=18
$ fruits_prices[pear]=30
$ fruits_prices[melon]=15
$ fruits_prices[orange]=21

Wie greifen wir auch auf die Elemente in einem assoziativen Array zu?

Genauso wie Sie in einem Python-Wörterbuch den Wert über den entsprechenden Schlüssel nachschlagen, können Sie auf die Werte in einem assoziativen Array über die Schlüssel zugreifen.

$ echo ${fruits_prices<x>[berry]</x>}
# 27

Wir sehen, dass ${fruits_prices[@]} sich auf die Werte und ${!fruits_prices[@]} sich auf die Schlüssel ausdehnt.

$ echo ${fruits_prices[@]}
# Ausgabe: 18 27 21 24 30 15
$ echo ${!fruits_prices[@]}
# Ausgabe: apple berry orange cherry pear melon

Hinweis: Die Reihenfolge der Elemente ist nicht dieselbe wie die Reihenfolge, in der wir sie hinzugefügt haben. Das liegt daran, dass assoziative Arrays im Gegensatz zu indizierten Arrays keine geordneten Sammlungen sind. Vielmehr arbeiten sie mit der Assoziation zwischen den Schlüsseln und den Werten. Daher sind Schlüssel für assoziative Arrays das, was Indizes für indizierte Arrays sind.

Sie können das assoziative Array auch in einer Schleife durchlaufen und auf die Schlüssel zugreifen, wie gezeigt:

$ for key in ${!fruits_prices[@]}
> do
> echo $key
> done

# Ausgabe
apfel
beere
orange
kirsche
birne
melone

Die folgende Schleife zeigt, wie Sie auf die Werte zugreifen können.

$ for value in ${fruits_prices[@]}
> do
> echo $value
> done

# Ausgabe
18
27
21
24
30
15

Obwohl es empfohlen wird, arrayName[Schlüssel]=Wert zu verwenden, können Sie es auch als Sequenz wie folgt deklarieren:

declare -A arrayName
arrayName=(Schlüssel1 Wert1 Schlüssel2 Wert2 ... SchlüsselN WertN)

Auf diese Weise erkennt die Bash das erste Element als den ersten Schlüssel, das zweite Element als den ersten Wert und so weiter.

Resümee

Ich hoffe, Sie haben nun verstanden, wie man in der Bash Arrays erstellt und mit ihnen arbeitet. Hier ein kurzer Überblick über das, was Sie gelernt haben.

• Sie können ein indiziertes Array in der Bash mit der Syntax arrayName=(elt1 elt2 elt3 ... eltN) deklarieren oder declare -a arrayName ausführen und Elemente zu dem Array hinzufügen.
• Um auf die Elemente zuzugreifen, können Sie mit ${arrayName[@]} eine Schleife durchlaufen. Alternativ können Sie die Liste aller gültigen Indizes mit der Parametererweiterung ${!arrayName[@]} abrufen.
• Schließlich haben Sie auch gelernt, wie Sie ein assoziatives Array deklarieren, um Schlüssel-Wert-Paare in der Bash zu speichern.

Sehen Sie sich als nächstes das Tutorial an für Schleifen in der Bash an.