Dieses Handbuch führt dich in die Welt der Bash-Arrays ein und zeigt dir, wie du indizierte und assoziative Arrays definierst und effizient damit arbeitest.
In Bash ist es möglich, Arrays zu erstellen, die als Container für eine Sammlung von Elementen dienen. Bash-Arrays sind eindimensionale Strukturen. Im Vergleich zu Sprachen wie C oder C++, in denen Arrays aus Elementen des gleichen Datentyps bestehen, erlauben Bash-Arrays die Speicherung von Integern und Strings innerhalb desselben Arrays, je nach Bedarf.
In dieser Anleitung wirst du lernen, wie man ein Bash-Array deklariert und auf dessen Elemente zugreift. Wir zeigen dir, wie du die Elemente eines Arrays iterieren und neue Elemente hinzufügen kannst. Abschließend werden wir uns mit assoziativen Arrays in Bash befassen.
Legen wir los!
⚙ Bereit zum Mitprogrammieren? Hier sind die Voraussetzungen:
Die Deklaration eines Bash-Arrays
In diesem Abschnitt lernst du die Syntax kennen, um ein Bash-Array zu definieren, inklusive praktischer Codebeispiele.
Syntax der Array-Deklaration
Ein Array in Bash lässt sich mit folgender Syntax erstellen:
$ arrayName=(element1 element2 ... elementN) # arrayName ist der Name des Arrays # element1 bis elementN sind die N Elemente im Array
In dieser Syntax steht `arrayName` für den Namen des Arrays, das die N Elemente von `element1` bis `elementN` enthält.
Die Array-Elemente werden innerhalb von runden Klammern `()` platziert und durch Leerzeichen voneinander getrennt. Beachte, dass wie bei allen Bash-Variablen vor oder nach dem Zuweisungsoperator `=` kein Leerzeichen stehen darf.
📑 In vielen anderen Programmiersprachen werden Array-Elemente oder Elemente ähnlicher Kollektionen durch Kommas getrennt. In Bash wird jedoch das Leerzeichen als Trennzeichen verwendet.
In Bash werden Arrays, deren Elemente über ihren Index identifiziert werden, als indizierte Arrays bezeichnet.
Indizierte Arrays in Bash deklarieren
Wir erstellen ein Array namens `preise` mit Zahlenwerten.
$ preise=(24 27 18 30 15)
Wie bereits in der Syntax beschrieben, werden die Zahlen im Array `preise` durch Leerzeichen getrennt und in Klammern eingeschlossen, wobei vor und nach dem Zuweisungsoperator `=` keine Leerzeichen stehen.
In Bash kann der Befehl `echo` genutzt werden, um den Wert einer Variable auszugeben. Die Verwendung von `$variableName` gibt den Wert von `variableName` aus. Wenn du jedoch versuchst, nur den Namen des Arrays zu verwenden, wird nur das erste Element angezeigt.
$ echo $preise 24
Bash-Arrays beginnen mit der Nullindizierung. Das erste Element hat den Index 0, das zweite den Index 1, und so weiter. Auch negative Indizierung ist möglich; das letzte Element hat den Index -1.
Was passiert, wenn du versuchst, auf ein Element über einen bestimmten Index zuzugreifen und dieses auszugeben? Lass uns versuchen, das Element mit dem Index 1 auszugeben.
$ echo $preise[1] 24[1]
Warum ist die Ausgabe `24[1]`? 🤔 Das liegt daran, dass Bash `$preise` durch `24`, das erste Element des Arrays, ersetzt und `[1]` als Text ausgibt.
Um das Element an einem spezifischen Index auszugeben, nutze die Parametererweiterung in der Form `${preise[index]}`.
$ echo ${preise[1]}
# 27
$ echo ${preise[2]}
# 18
Um alle Elemente des Arrays auszugeben, verwende `@` anstelle eines spezifischen Index.
$ echo ${preise[@]}
24 27 18 30 15
Als Nächstes erstellen wir ein Array mit Zeichenketten. Durch Ausführen des folgenden Befehls wird ein indiziertes Array erstellt:
$ declare -a fruechte
Die Option `-a` definiert ein indiziertes Array. Nun kannst du das Array Element für Element befüllen, indem du das jeweilige Element an einem bestimmten Index deklarierst, wie unten gezeigt:
$ fruechte[0]="kirsche" $ fruechte[1]="beere" $ fruechte[2]="apfel" $ fruechte[3]="birne" $ fruechte[4]="melone" $ fruechte[5]="orange"
Um nun alle Elemente des Arrays auszugeben, verwende `${fruechte[@]}`.
$ echo ${fruechte[@]}
kirsche beere apfel birne melone orange
Zugriff auf Elemente eines Bash-Arrays
Auf die Elemente eines Arrays kann auf folgende Arten zugegriffen werden:
- Iteriere durch das Array und greife direkt auf jedes Element zu.
- Iteriere über die Indizes und greife auf die Elemente über deren Indizes zu.
Direkter Zugriff auf Elemente durch Iteration
Wenn du bereits in Python programmiert hast, kennst du die for-Schleife mit folgender Syntax:
for element in liste:
print(element)
Lass uns nun das Bash-Äquivalent der obigen for-Schleife schreiben.
Wir wissen, dass `${preise[@]}` alle Elemente des Arrays `preise` ausgibt. Und `${preise[@]}` gibt uns die Werte aller Elemente.
Die for-Schleife in Bash ähnelt der in Python, aber die Anweisungen im Schleifenkörper müssen wie gezeigt mit `do` und `done` eingeschlossen werden:
$ for preis in ${preise[@]}
> do
> echo $preis
> done
Da wir den Befehl `echo` verwenden und den Wert der Variablen `preis` ausgeben, erhalten wir die folgende Ausgabe:
# Ausgabe 24 27 18 30 15
Zugriff über den Array-Index
Eine andere Möglichkeit, durch Arrays zu iterieren, ist die Verwendung des Index der Elemente. Dies ähnelt der `for`-Schleife in Python, die die Funktion `range()` verwendet:
for i in range(len(liste)):
print(i)
Um eine Liste der zu iterierenden Indizes zu erhalten, kannst du in der Parametererweiterung ein Ausrufezeichen `!` vor dem Arraynamen setzen. Dies gibt dir eine Liste aller gültigen Indizes für das Array zurück:
$ echo ${!preise[@]}
0 1 2 3 4
Das Array `preise` hat 5 Elemente, also beginnt der Index bei 0 und geht bis 4.
Nun können wir die Liste der Indizes durchlaufen und auf die Elemente an jedem Index zugreifen. Für den Index `i` ist `${preise[i]}` das Element am Index `i`.
$ for i in ${!preise[@]}
> do
> echo ${preise[i]}
> done
Die obige Schleife gibt alle Elemente im Array aus.
# Ausgabe 24 27 18 30 15
💬 Hier führen wir nach dem Zugriff auf jedes Element eine einfache Operation durch, um seinen Wert auszugeben. Im Allgemeinen können wir jede beliebige Operation mit den Elementen durchführen.
Elemente an ein Bash-Array anhängen
Unser Array `preise` hat fünf Elemente (an den Indizes 0, 1, 2, 3 und 4). Wenn du am Ende des Arrays ein neues Element beim Index 5 hinzufügen möchtest, kannst du das wie folgt tun:
$ preise[5]=21
Wir sehen, dass `21` am Ende des `preise`-Arrays hinzugefügt wurde.
$ echo ${preise[@]}
24 27 18 30 15 21
Es ist jedoch bequemer, ein Element am Ende des Arrays anzuhängen, ohne sich den Index des zuletzt hinzugefügten Elements oder die Anzahl der Elemente im Array merken zu müssen.
Du kannst `arrayName+=(element(e))` verwenden, um ein oder mehrere Elemente an ein Array anzuhängen:
$ preise+=(10)
Wenn wir nun das Array `preise` ausgeben, sehen wir, dass `10` am Ende des Arrays angehängt wurde.
$ echo ${preise[@]}
24 27 18 30 15 21 10
Als Nächstes werden wir lernen, wie man assoziative Arrays in Bash deklariert.
Assoziative Arrays in Bash
Wenn du eine Beziehung in Form von Schlüssel-Wert-Paaren definieren möchtest, kannst du ein assoziatives Array verwenden. Assoziative Arrays lassen sich mit der folgenden allgemeinen Syntax deklarieren. Beachte, dass wir hier die Option `-A` anstelle von `-a` verwenden.
$ declare -A fruechte_preise
Du kannst dem assoziativen Array Elemente hinzufügen, indem du den Schlüssel und den entsprechenden Wert angibst. Hier haben wir die Namen der Früchte als Schlüssel und die Zahlen aus dem Array `preise` als Werte verwendet.
$ fruechte_preise[kirsche]=24 $ fruechte_preise[beere]=27 $ fruechte_preise[apfel]=18 $ fruechte_preise[birne]=30 $ fruechte_preise[melone]=15 $ fruechte_preise[orange]=21
Wie greifen wir nun auf Elemente eines assoziativen Arrays zu?
So wie du in einem Python-Dictionary den Wert über den entsprechenden Schlüssel findest, kannst du auch in assoziativen Arrays auf die Werte über die Schlüssel zugreifen.
$ echo ${fruechte_preise[beere]}
# 27
Wir sehen, dass `${fruechte_preise[@]}` die Werte ausgibt und `${!fruechte_preise[@]}` die Schlüssel.
$ echo ${fruechte_preise[@]}
# Ausgabe: 18 27 21 24 30 15
$ echo ${!fruechte_preise[@]}
# Ausgabe: apfel beere orange kirsche birne melone
Hinweis: Die Reihenfolge der Elemente entspricht nicht der Reihenfolge, in der sie hinzugefügt wurden. Dies liegt daran, dass assoziative Arrays im Gegensatz zu indizierten Arrays keine geordneten Sammlungen sind. Sie funktionieren vielmehr durch Zuordnung zwischen den Schlüsseln und Werten. Schlüssel sind für assoziative Arrays das, was Indizes für indizierte Arrays sind.
Du kannst auch durch das assoziative Array iterieren und auf die Schlüssel zugreifen:
$ for schluessel in ${!fruechte_preise[@]}
> do
> echo $schluessel
> done
# Ausgabe apfel beere orange kirsche birne melone
Die folgende Schleife zeigt dir, wie du auf die Werte zugreifen kannst.
$ for wert in ${fruechte_preise[@]}
> do
> echo $wert
> done
# Ausgabe 18 27 21 24 30 15
Es wird jedoch empfohlen `arrayName[key]=wert` zu verwenden, du kannst dies auch als Sequenz deklarieren:
declare -A arrayName arrayName=(schluessel1 wert1 schluessel2 wert2 ... schluesselN wertN)
Auf diese Weise leitet Bash das erste Element als ersten Schlüssel, das zweite Element als ersten Wert usw. ab.
Zusammenfassung
Ich hoffe, du verstehst jetzt, wie man Bash-Arrays erstellt und damit arbeitet. Hier ist eine kurze Zusammenfassung dessen, was du gelernt hast:
- Du kannst ein indiziertes Array in Bash mit der Syntax `arrayName=(elt1 elt2 elt3 … eltN)` deklarieren oder mit `declare -a arrayName` und dem Array Elemente hinzufügen.
- Um auf die Elemente zuzugreifen, kannst du `${arrayName[@]}` verwenden. Alternativ dazu erhältst du eine Liste aller gültigen Indizes über die Parametererweiterung `${!arrayName[@]}`.
- Abschließend hast du gelernt, wie man ein assoziatives Array deklariert, um Schlüssel-Wert-Paare in Bash zu speichern.
Als Nächstes solltest du dir die Anleitung für Schleifen in Bash ansehen.