|
Oft kommt man in die Situation mehrere Werte erfassen zu müssen, die man später noch auswerten oder auch manipulieren möchte. Man kann dazu sicher mehrere einzelne Variablen verwenden, aber im Bezug auf die Zuweisung, Manipulation und Abfrage der Werte ist diese Methode nicht komfortabel. In der Shell bietet sich dazu die Verwendung eines eindimensionalen Arrays an.
Abstrahiert kann man sich ein Array als eine Variable vorstellen, die aus mehreren Elementen besteht, wovon jedes Element wieder eine eigene Variable repräsentiert. Das Array in der Shell kann nur eindimensional sein. Aber dies reicht in den meisten Fällen völlig aus. Trotzdem soll der Vollständigkeit halber der Unterschied eines eindimensionalen und zweidimensionalen Arrays verdeutlicht werden:
eindimensional zweidimensional
index| 0 1 2 3 4 5 6 index| 0 1 2 3 4 5 6
-----+-------------- -----+--------------
O O O O O O O 0| O O O O O O O
1| O O O O O O O
2| O O O O O O O
3| O O O O O O O
Während beim eindimensionalen Array nur eine Zuordnung in einer Ebene möglich ist, bietet das zweidimensionale schon zwei Ebenen an. In anderen Programmiersprachen sind auch dreidimensionale oder sogar mehrdimensionale Arrays möglich.
Gemeinsam haben alle Arrayformen in der Regel, dass sie über Indizes angesprochen werden. Also alle Indexe die nötig sind, um genau ein Element anzusprechen. Sie sind vergleichbar mit dem Variablennamen. Die Indizes sind dabei aufsteigende (jedoch nicht zwingend fortlaufende!) natürliche Zahlen, beginnend mit dem Index 0 für das erste Element.
Die Zuweisung von Elementen verläuft ähnlich wie bei der einfachen Variablen. Um unter anderem bei nur einem Element zu einer Variablen differenzieren zu können, werden alle Elemente eines Arrays mit runden Klammern umschlossen:
variablenname=( element_1 element_2 element_3... element_n )
Zur Trennung der Elemente eines Arrays verwendet die Shell standardmäßig das Leerzeichen als IFS (Inter File Seperator). Beinhaltet ein Element mehrere Werte (beispielsweise zwei Wörter), dann ist das Element durch Hochkommas einzugrenzen. Die Bedeutung der beiden Varianten ( ' ) und ( " ) ist analog zu der von einfachen Variablen.
Möchte man ein Array ohne Inhalte initialisieren, also für den späteren Gebrauch bereitstellen, empfiehlt es sich das Array als solches für die Shell zu kennzeichnen:
Ist ein Array einmal initialisiert, kann man über den den Index gezielt auf das jeweilige Elemente und damit auf dessen Inhalt zugreifen. Des Weiteren bietet die Shell diverse Abfragen über den Zustand des Arrays.
Im Folgenden soll ein Array initialisiert und anschließend die Eigenschaften abgefragt werden:
myArray=(Heute lerne ich den Umgang 'mit Arrays')
Damit wurde das Array myArray mit fünf Elementen initialisiert. Das fünfte Element besteht aus zwei Wörtern und musste somit durch Hochkommas eingegrenzt werden. Ohne diese Kennzeichnung würde das Array sechs Elemente beinhalten. Der erweiterte Leerraum im letzten Element ist mit Absicht so gewählt worden, damit bei der Ausgabe der Unterschied zu den einfachen Leerzeichen ersichtlich wird.
Zur Abfrage der Parameter bietet die Shell nun mehrere Möglichkeiten, welche hier mit dem echo-Befehl ausgegeben werden sollen:
Heute lerne ich den Umgang mit Arrays
Dieses Konstrukt gibt offensichtlich den Inhalt aller Elemente eines Arrays aus. Soll nur der Inhalt eines einzigen Elements ausgegeben werden, dann ist das Sternchen ( * ) durch den entsprechenden Index zu ersetzen. Folglich würde beispielsweise die Ausgabe bei der Anwendung des Indexes 0 zur Ausgabe Heute führen.
Anmerkung: Bei der Ausgabe der Inhalte ist das Konstrukt in doppelte Hochkommas ( " ) zu setzen, da sonst die Leerräume im letzten Element nicht korrekt dargestellt werden. Warum dies so ist, kann ich nicht mit Sicherheit sagen. Vermutlich hängt dies aber mit dem echo-Befehl zusammen, was sich am Ende dieses Beitrags belegen lässt.
Hier wird die Anzahl der Elemente des Arrays ausgegeben. Dies wird auch als die Arraygröße bezeichnet. Alternativ könnte man sagen, dass dies die Anzahl der Indexe ist, da ja jedes Element einem Index zugewiesen ist.
Damit lassen sich alle vorhandenen Indexe eines Arrays erfragen. Daraus lässt sich sicherlich auch die Arraygröße ableiten, allerdings hat diese Information noch einen weiteren wichtigen Nutzen. Da die Indexe zwar aufsteigend (bspw. 0, 4, 5, 6, 9) sind, aber nicht fortlaufend (bspw. 0, 1, 2, 3, 4, 5) sein müssen, ist die Information welche Indexe verwendet werden natürlich sehr wichtig.
Anmerkung: Initialisiert man ein Array mit verschiedenen Elementen, dann wird der Index vom System selbstverständlich aufsteigend und fortlaufend erstellt. Ein nicht fortlaufender Index ist in der Regel nur durch eine manuelle Manipulation des Benutzers möglich.
Mit diesem Konstrukt und der Verwendung des Indexes (hier 5), wird die Größe des zugehörigen Elements erfasst. Folglich lautet das korrekte Ergebnis auch 12, wobei die Leerzeichen zwischen mit und Arrays auch erfasst werden.
Das waren schon alle wichtigen Möglichkeiten, um die Eigenschaften eines Arrays zu ermitteln. Nun wäre natürlich auch noch interessant, wie man die Inhalte wieder manipulieren kann. Dies wird nun mit verschiedenen Zusweisungen vollzogen:
myArray[100]='von Arrays,'
myArray[3]=das
myArray[5]=${myArray[100]}
myArray[4]=Manipulieren
myArray[100]='Prima!'
Mit dieser Manipulation wurden gleich mehrere Möglichkeiten zur direkten Manipulation von Arrays, beziehungsweise deren Elemente abgedeckt.
Als erstes wird ein neues Element mit dem Index 100 geschaffen, welches den Inhalt von Arrays, erhält...
index|0 |1 |2 |3 |4 |5 |100
-----+-----+-----+---+---+------+------------+------------
|Heute|lerne|ich|den|Umgang|mit Arrays|von Arrays,
Dies belegt die Aussage, dass die Indizies nicht fortlaufend sein müssen, was nun nochmal durch die Ausgabe der verwendeten Indexe überprüft wird...
Im nächsten Schritt folgt die Zuweisung des neuen Wertes das in das vierte Element (Index 3)...
index|0 |1 |2 |3 |4 |5 |100
-----+-----+-----+---+---+------+------------+------------
|Heute|lerne|ich|den|Umgang|mit Arrays|von Arrays,
^
das
Dann wird der Inhalt des Elements mit dem Index 100 in das Element mit dem Index 5 kopiert...
index|0 |1 |2 |3 |4 |5 |100
-----+-----+-----+---+---+------+------------+------------
|Heute|lerne|ich|das|Umgang|mit Arrays|von Arrays,
^ |
+-------------+
Darauf folgend wird dem fünften Element (Index 4) der Wert Manipulieren zugewiesen...
index|0 |1 |2 |3 |4 |5 |100
-----+-----+-----+---+---+------+-------------+------------
|Heute|lerne|ich|das|Umgang|von Arrays,|von Arrays,
^
Manipulieren
und abschließend das Element mit dem Index 100 mit dem Wert Prima! überschrieben...
index|0 |1 |2 |3 |4 |5 |100
-----+-----+-----+---+---+------------+-------------+------------
|Heute|lerne|ich|das|Manipulieren|von Arrays,|von Arrays,
^
Prima!
Schließlich soll der neue Inhalt des kompletten Arrays wieder ausgegeben werden:
Heute lerne ich das Manipulieren von Arrays, Prima!
Interessant ist das Verhalten beim Kopieren des Indexes 100 in den Index 5. Im Gegensatz zum echo-Befehl ist es hier nicht erforderlich, das Konstrukt in doppelte Hochkommas ( " ) zu setzen. Der erweiterte Leerraum wird trotzdem ordnungsgemäß kopiert. Allerdings wird hierdurch auch deutlich, dass es in der Shell immer wieder zu unvermuteten Verhaltensweisen kommen kann.
|
Shellprogrammierung 
