# Perl - Variablen

### Skalare Variablen

Zu einer "richtigen" Programmiersprache gehören natürlich Variablen, die mit Werten besetzt werden können. Zunächst einmal sollen nur "skalare" Variablen betrachtet werden. Dies sind Zahlen und Zeichenketten (Strings). Im Unterschied zu vielen anderen Sprachen sehen die Variablen für Zahlen und Zeichen in Perl gleich aus: sie beginnen alle mit einem `$` gefolgt von einer Kombination aus Buchstaben und Ziffern.

    #!/usr/local/bin/perl -w

    $ausgabe = "Just another Perl hacker\n";
    $i = 123;
    $x = 1e-26;

    print "$ausgabe\n";
    print "$i\n";
    print "$x\n";

    Just another Perl hacker

    123
    1e-26

In diesem Beispiel enthält die Variable `$ausgabe` den Wert Just another Perl hacker\n, die Variable `$i` den Wert 123 und `$x` den Wert 1e-26.

Im Unterschied zu den meisten anderen Sprachen müssen Variablen in Perl nicht zu Beginn eines Programms definiert werden. Auch für Zeichenketten muß kein Speicherplatz reserviert werden, ihre Länge ist in Perl nur durch die Größe des Hauptspeichers begrenzt.

Zahlen sind in Perl grundsätzlich Gleitkommazahlen, d.h, es gibt keine Ganzzahlen. Die Genauigkeit entspricht dem Zahlentyp double in C (meist 8 Bytes).

Ob eine Variable als Zahl oder Zeichenkette interpretiert wird, hängt von der Umgebung - dem Kontext - ab, in dem sie auftritt.

    #!/usr/local/bin/perl -w

    $a = 1;
    $b = 4;
    $c = $a + $b;
    $d = $a . $b;
    print "$c\n";
    print "$d\n";

    5
    14

Im obigen Beispiel ist "`+`" der normale Operator zur Addition zweier Zahlen und "`.`" der Verkettungsoperator, um zwei Strings zu einem zu verbinden.

### Arrays

Eine Variable, die ein Array in Perl darstellt, ist durch das Zeichen "`@`" gekennzeichnet. Da skalare Variablen und Arrays unabhängig voneinander verwaltet werden, darf es in einem Programm durchaus eine Zahl `$ALF` und ein Array `@ALF` geben.

Arrays sind grundsätzlich eindimensional (Vektoren) und enthalten als Elemente skalare Größen. Wie bei Zeichenketten muß auch bei Arrays keine Speicherplatzreservierung vorgenommen werden und Arrays können im Laufe eines Programms praktisch beliebige Größen annehmen. Versucht man, auf ein nicht definiertes oder gesetztes Element zuzugreifen, so erhält man eine "0" im Zahlenkontext bzw. einen Leerstring "" im Zeichenkettenkontext zurück (intern besitzt die Variable den Wert "undef").

Die Elemente eines Arrays können im wesentlichen auf zwei Arten mit Werten besetzt werden :

- `@vector = (4,6,"ein String",25);`

  Hier bekommen die ersten vier Elemente von `@vector` die entsprechenden Werte.

- `$vector[7] = 42;`

  Bei der Zuweisung über einen Index ist hier das Dollar-Zeichen `$` zu beachten, da "vector[7]" eine skalare Variable und kein Array darstellt ! Die Indizierung der Arrays beginnt normalerweise bei 0 (Dies kann durch Änderung der reservierten Variablen `$[` beeinflußt werden - z.B. `$[=1` - , kann aber unter Perl 5 zu Problemen führen, da dort diese Zuweisung nur innerhalb eines Files gilt). In diesem Beispiel müssen übrigens die Inhalte `$vector[0]` bis `$vector[6]` überhaupt nicht besetzt werden.

Die Länge eines Arrays kann bestimmt werden, indem man die Array-Variable in einem skalaren Kontext verwendet; den Index des letzten Elements erhält man durch Voranstellen von "`$#`" vor den Arraynamen.

    #!/usr/local/bin/perl -w

    @vector = (4,6,"ein String",25);
    $laenge = @vector;                    # skalarer Kontext !
    print "Laenge = $laenge\n";
    print "Letzter Index = $#vector\n";
    print "\$vector[1] = $vector[1]\n";

    $vector[7] = 42;
    $laenge = @vector;
    print "Laenge = $laenge\n";
    print "Letzter Index = $#vector\n";

    Laenge = 4
    Letzter Index = 3
    $vector[1] = 6
    Laenge = 8
    Letzter Index = 7

Aus einem Array kann auch ein Ausschnitt ("slice") genommen werden, indem der entprechende Indexbereich angegeben wird.

    #!/usr/local/bin/perl -w

    @vector = (2,4,6,8,10,12);
    @slice = @vector;                  # (2,4,6,8,10,12)
    @slice = @vector[2,3,4];           # (6,8,10)
    @slice = @vector[2,4];             # (6,10)
    @slice = @vector[3..5];            # (8,10,12)

Ein spezielles Array ist `@ARGV`. Es enthält die Parameter/Optionen, die dem Skript beim Aufruf mit übergeben werden. Beispiel:

    #!/usr/local/bin/perl -w

    foreach $i (@ARGV) { print $i."\n" }               # foreach

ACHTUNG : Im Gegenteil zur Programmiersprache C liefert `$ARGV[0]` den ersten Parameter und nicht den Namen des Programms (Dieser Filename befindet sich in Perl in der Variablen `$0`) !

### Assoziative Arrays

Kennzeichen eines assoziativen Arrays ("hash") ist die Paarung von jeweils zwei Elementen in der Form "Schlüssel-Wert". Gekennzeichnet wird ein assoziatives Array durch ein Prozentzeichen "`%`" vor dem Variablennamen.

    #!/usr/local/bin/perl -w

    %alter = ("Sabine","27","Klaus","35","Ralf","22");
    print "$alter{Sabine}\n";
    print "$alter{Klaus}\n";
    print "$alter{Ralf}\n";
    foreach $key (keys(%alter))                  # foreach
    {
       print "$key\n"                  # (hier ";" nicht unbedingt noetig)
    }

    27
    35
    22
    Klaus
    Sabine
    Ralf

Hier wird auf die Werte der Schlüssel in `%alter` durch `$alter{...}` zugegriffen (man beachte auch hier das Dollar-Zeichen). Eine Liste aller Schlüssel in einem assoziatien Array erhält man durch die Funktion `keys()`; analog kann man eine Liste aller Werte durch `values()` bekommen. Die Reihenfolge der Elemente ist dabei willkürlich und muß keineswegs mit der in der Definition übereinstimmen (obige Ausgabe ergab sich unter MacPerl).

Man kann die Elemente eines assoziativen Arrays mit Hilfe der Funktion `each()` auch paarweise jeweils in ein zweielementiges Array lesen.

    #!/usr/local/bin/perl -w

    %h = ("Auto" => 1,"Haus" => 2,"Baum" => 3);

    while(@a = each(%h)) {
      print "$a[0] ($a[1])\n";
    }

    Haus (2)
    Auto (1)
    Baum (3)

Die Reihenfolge ist auch hier (scheinbar) willkürlich - sie hängt von der internen Speicherung der Daten ab.

In diesem Beispiel wurde anstelle von Kommata ein Pfeil-Symbol ("`=>`") verwendet. Dieses Symbol ist einem Komma vollkommen gleichwertig und wird bei assoziativen Arrays gerne der Übersichtlichkeit halber verwendet, um die Schlüssel-Wert-Paarungen zu verdeutlichen.

Unter UNIX kann auf die Umgebungsvariablen (environment) über das assoziative Array `%ENV` zugegriffen werden. Beispiel:

    #!/usr/local/bin/perl -w

    print $ENV{'LOGNAME'}."\n";
    print $ENV{'DISPLAY'}."\n";

Autor: Eike Grote | Letzte Änderung: 03.11.2004