Arrays

Arrays

Wir haben bisher skalare Daten kennengelernt. In Perl gibt es die Möglichkeit, mehrere skalare Daten (Zahlen oder Strings) in Form einer geordneten Liste zusammenfassen - sowas nennt man dann Array. No fear - it's easy!

Aussehen eines Arrays

Wie schon gesagt ein Array ist eine Liste von Werten. Die Anzahl der Werte eines Arrays fängt bei 0 (leeres Array - ein Array ohne Werte) an und kann beliebig groß werden. Die Darstellung eines Arrays im Programmcode geschieht mit Hilfe von runden Klammern. Die einzelnen Werte (falls mehr als einer existiert) werden durch Kommas getrennt.

(777,1234,333) # Array mit drei Zahlen
("bla",4711)    # Array mit einem String und einer Zahl
()              # ein leeres Array
($a, 17, $a*$a) # Array mit Variable, Zahl und Term
(3..7)          # 3, 4, 5, 6 ,7

Und das fällt auf:

In einem Array können Strings und Zahlen gemischt stehen.
Es werden sogar Variablen und Terme akzeptiert.
Es gibt einen Operator, um Arrays zu konstruieren (Listenkonstruktor): ... Dieser Operator erzeugt alle Werte zwischen dem erste und dem letzten Wert! Achtung: Ist der letzte Wert kleiner als der erste wird ein leeres Array erzeugt.

Das ist auch möglich:

$a=-100;
$b=100;
print ($a..$b); # print(-100..100);
# ergibt: -100-99-98 ... -10123456 ... 9899100

Die Grenzen für den Listenkonstruktor können auch Variablen sein.
Der print-Befehl kann Arrays verarbeiten! Dabei werden die Elemente einfach hintereinander ausgegeben!

Arrayvariablen

Analog zu den skalaren Daten und Variablen können Arrays auch Variablen zugeordnet werden. Die skalaren Variablen werden mit einem $ eingeleitet - bei Arrayvariablen ist das ein @. Für die Namensgebung eines Arrays gelten die gleichen Regeln wie für Variablen: Buchstaben, Ziffern und _ sind erlaubt; das erste Zeichen nach dem @ muss ein Buchstabe sein.

@Studenten # Array mit Namen Studenten

Bemerkung: $wert und @wert dürfen gleichzeitig benutzt werden - Perl unterscheidet gleiche Namen für unterschiedliche Variablentypen.

Der Zuweisungsoperator für Arrays

Der Zuweisungsoperator = weist einer Arrayvariablen ein Array zu.

@werte=(12,14..17); # @werte enthält (12,14,15,16,17)
@values=@werte;      # @values enthält (12,14,15,16,17)
@mischen=("abc",11,@werte,18);
  # @mischen beinhaltet ("abc",11,12,14,15,16,17,18)
@eins=77;            # @eins ist itentisch mit (77)
@eins=(76,@eins,78); # @eins enthält (76,77,78)
$l=@eins;            # enthält die Länge des Arrays
  # ABER:
$i=(12,34,56);       # enthält letztes Element; $i==56

Man kann einer Arrayvariablen den Inhalt einer anderen Arrayvariablen zuweisen.
Es ist sogar mischen von skalaren Variablen und Arrays erlaubt. Dabei wird ein Array nicht als Array eingefügt, sondern die Elemente des Arrays.
Ordnet man einer Arrayvariablen einen skalaren Wert zu, so wird dieser skalare Wert als einelementiges Array interpretiert.
Umgekehrt wird einer skalaren Variablen die Länge des Arrays zugeordnet!
Wird keine Arrayvariable angegeben, sondern ein Array selbst, so wird das letzte Element des Arrays übergeben.

Bemerkungen:
Perl unterscheidet die verschiedenen Zuweisungsoperatoren für skalare Variablen und Arrayvariablen, indem es auf dem Variablentyp auf der linken Seite schaut!
Ein Array kann kein Array als Element beinhalten!

Besteht ein Array aus lauter Variablen, so kann dieses Array auch als Arrayvariable betrachtet werden:

($a, $b, $c)=(1,2,3); # $a==1, $b==2, $c==3
($d,@e)=(1,2,3,4,5);   # $d==1, @e==(2,3,4,5)
($f,@gierig,$h)=(1,2,3,4);
  # $f==1, @gierig==(2,3,4), $h==undef
($i,$j)=@gierig;       # $i==2, $j==3

Perl ist habgierig (später sehen wir mehr davon) und expandiert deshalb @gierig so weit wie es geht.
Steht beim Zuweisungsoperator links ein Array aus Variablen, so wird soweit aufgefüllt wie es möglich ist.

Noch was Interessantes:

@a=(@b=(1,2,3,4')); # @a und @b haben den Inhalt (1,2,3,4)
@a=@b=(1,2,3,4); # bewirkt dasselbe

Das Ergebnis einer Arrayzuweisung ist wieder ein Array und zwar das, was wirklich zugewiesen wurde.

Der Zugriffsoperator für Arrays

Der Zugriffsoperator [] ermöglicht es uns, auf einzelne Elemente eines Arrays zuzugreifen. Dabei wird innerhalb der Klammern eine ganze Zahl beginnend von 0 angegeben. Die angegebene Zahl gibt dann die Stelle an, auf die wir zugreifen:

@math=(3.1415,2.7182,1.4142);
$wurzelZwei=$math[2]; # $wurzelZwei enthält
  # den Inhalt des dritten Elements von @math

$wurzelDrei=1.7321;
$math[3]=$wurzelDrei; # ordnet dem vierten Element
  # von @math den Inhalt von $wurzelDrei zu
$math[4]=12;
$math[4]++; # erhöhe Inhalt von $math[4] um 1

($math[0],$math[2])=($math[2],$math[0]);
  # vertausche erstes und drittes Element

Was ist wichtig:

Beim Zugriff auf einzelne Elemente eines Arrays wird statt @ das Zeichen $ verwendet.
Perl fängt bei 0 das zählen an; d. h., auf das erste Element wird mit dem Index 0 zugegriffen.
Ein mit dem [] angesprochenes Element verhält sich wie eine normale Variable: Also man kann auslesen, hineinschreiben, etc.

Der Zugriffsoperator kann aber noch mehr: Er kann auch auf mehrere Element (Ausschnitt eines Arrays) zugreifen:

@math=(3.1415,2.7182,1.4142);
@math[0,2]=@math[2,0];
# vertausche erstes und drittes Element

Bei einem Ausschnitt eines Arrays wird wieder das @-Zeichen benutzt; da man einen Teil eines Arrays behandelt und das ist ja wieder ein Array - auch wenn es einelementig ist!

Bemerkung: In den Zugriffsoperator darf sogar eine Arrayvariable eingesetzt werden (vgl. Übung 2).

Noch etwas spezielles: Mit $# erhält man den Indexwert des letzten Elements.

@math=(3.1415,2.7182,1.4142);
$i=$#math; # $i==2
$w=$math[$#math]; # $w==1.4142

Hinzufügen und Löschen von Arrayelementen

Mit Hilfe der Operatoren push() und unshift() bzw. pop() und shift() können von einem Array Werte hinzugefügt bzw. gelöscht werden.

@persons=("emil","fritz");
push(@persons,"hans","tom"); # anfügen am Ende
  # Inhalt: ("emil","fritz","hans","tom")
unshift(@persons,"agathe"); # anfügen am Anfang
  # Inhalt: ("agathe","emil","fritz","hans","tom")

pop(@persons); # löschen am Ende
$p1=pop(@persons); -"- und $p1=="hans"
  # Inhalt: ("agathe","emil","fritz")
  # analog funktioniert der shift()-Operator

Bei jedem der Operatoren wird als erstes die Arrayvariable angegeben.
pop() bzw. shift() liefern als Rückgabe den gelöschten Wert.

Einlesen von <STDIN>

Unter Perl geht alles schneller zu programmieren: Auch das Einlesen eines Arrays von der Standardeingabe:

@zeilen=<STDIN>
chomp(@zeilen);

Es wird zeilenweise von der Standardeingabe gelesen und in das Array @zeilen geschrieben - inkl. "\n".
Den chomp()- bzw. chop()-Operator kann man auch auf ein ganzes Array anwenden! Es wird dann aus jedem Element das letzte Zeichen entfernt.
Der Abbruch geschieht dann, falls undef eingegeben wird. Dieses wird unter DOS mit <Strg>-z und <RETURN> bzw. <Strg>-y und <RETURN> erzeugt. Unter UNIX geschieht das mit <Ctrl>-d (<Strg> entspricht <Ctrl>).

weitere Operatoren

Es gibt noch weitere Operatoren, die auf arrays angewendet werden können. Hier sind noch einige kurz erwähnt:

Operator	Beschreibung	Beispiel
sort()	Eingabe: Array; Ausgabe: ein neues Array mit den sortierten Werten des eingegebenen Arrays	@sorted=sort(@unsorted);
reverse()	dreht die Reienfolge der Elemente im Array um	@sorted=sort(@unsorted); @revSort=reverse(@sorted);
chop()	löscht aus jedem Element des Arrays den letzten Eintrag	chop(@eingaben);
print()	gibt die Elemente eines Arrays aus	print @Studenten; print "@Studenten";

Bemerkung: Der sort-Operator sortiert ein Array immer auf Stringbasis - auch wenn ein reines Zahlenarray vorliegt! Um Perl dazu zu bringen muss man im sagen, dass es Zahlen sortieren soll:

@zahlen=(1,5,4,20,3);
@sortiert=sort(@zahlen);
print "@sortiert\n\n";

@sortiert=sort{$a<=>$b}(@zahlen);
print "@sortiert\n";

liefert:

1 20 3 4 5

1 3 4 5 20

Bemerkung: Den Ursprung von {$a <=> $b} gibt's später!

das Array @ARGV

Man kann einem Perlprogramm Parameter übergeben! Diese gibt man einfach nach dem Programmnamen getrennt durch ein Leerzeichen ein:

perl finde.pl test.txt perl/temp

Es wird das Perlprogramm finde.pl aufgerufen.
Übergeben werden die Parameter test.txt und perl/temp.

Perl speichert die Übergabeparameter in dem Array @ARGV. Man kann im Programm selbst auf dieses Array ganz normal zugreifen. Es zu verändern, ist aber nicht ratsam:

print "Sie haben folgende Parameter übergegeben:\n@ARGV";

Als Ausgabe haben wir:

Sie haben folgende Parameter übergegeben:
test.txt perl/temp

Bemerkung: Es gibt noch mehr zu Arrays zu sagen - vor allem noch irgendwelche Spezialfälle: Dazu sollte man - wenn man interessiert ist - bei www.perl.com vorbeischauen.

Perl, Lehrstuhl Mathe II, Uni Bayreuth