# Variablen

- Skalare Variablen
- Arrays
- Hashes

## Skalare Variablen

Zu einer "richtigen" Programmiersprache gehören natürlich Variablen, die mit Werten besetzt werden können. Zunächst einmal sollen nur einfache "skalare" Variablen betrachtet werden: 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 ihrem Namen (Identifizierer). Der Name darf mit einem Buchstaben oder Unterstrich ("`_`") beginnen, gefolgt von im Prinzip beliebig vielen Buchstaben, Unterstrichen oder Ziffern.

Hinweis: Man sollte keine Variablen namens "`$a`" oder "`$b`" verwenden, da diese beim Sortieroperator `sort` eine besondere Bedeutung haben.

Um einer Variablen einen Wert zuzuweisen wird der Operator "`=`" verwendet.

`#!/usr/local/bin/perl -w $ausgabe = "Just another Perl hacker\n"; $i = 123; $x = 1e-5; print "$ausgabe\n"; print "$i\n"; print "$x\n";`

`Just another Perl hacker 123 1e-05`

Hier enthält die Variable `$ausgabe` den Wert "`Just another Perl hacker\n`", die Variable `$i` den Wert 123 und `$x` den Wert der Gleitkommazahl 1e-05.

Im Unterschied zu den meisten anderen Sprachen müssen Variablen in Perl nicht zu Beginn eines Programms deklariert werden. Um Fehler zu vermeiden, empfiehlt es sich aber grundsätzlich jede Variable zu deklarieren. Damit man keine Variable übersieht, setzt man "`use strict;`" an den Anfang des Programms. In den meisten Fällen ist eine Deklaration mittels "`my`" die richtige Wahl. Details zur Variablendeklaration finden sich im Abschnitt Variablen und Symboltabellen.

Auch für Zeichenketten muß kein Speicherplatz reserviert werden, ihre Länge ist in Perl im wesentlichen durch die Größe des Arbeitsspeichers begrenzt. Zahlen werden in Perl meistens als Gleitkommazahlen behandelt.

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 use strict; my $x = 1; my $y = 4; my $c = $x + $y; my $d = $x . $y; 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.

Ein besonderer "Wert" einer Variablen ist undef, der dann auftritt, wenn einer Variablen entweder überhaupt kein Wert oder explizit `undef` zugewiesen wird.

`#!/usr/local/bin/perl -w use strict; my $w; print "Initialisierung: ($w)\n"; $w = 'Hallo'; print "String: ($w)\n"; $w = ''; print "Leerstring: ($w)\n"; $w = undef; print "undef: ($w)\n";`

`Use of uninitialized value in concatenation (.) or string at ./test.pl line 6. Initialisierung: () String: (Hallo) Leerstring: () Use of uninitialized value in concatenation (.) or string at ./test.pl line 12. undef: ()`

Hinweis: `undef` ist zu unterscheiden von etwa "0" als numerischem Wert oder einem Leerstring; letztere sind im Sinne von Perl sehr wohl definiert!

Mit Hilfe der Funktion `defined()` kann man herausfinden, ob eine Variable einen definierten Wert hat oder nicht. Je nachdem ist der Rückgabewert "1" oder ein Leerstring.

`#!/usr/local/bin/perl -w use strict; my $w; print "a) ",defined($w),"\n"; $w = 25; print "b) ",defined($w),"\n";`

`a) b) 1`

[Seitenanfang]

## 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 gestetztes Element zuzugreifen, so bekommt man einen undefinierten Wert (undef) zurück.

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

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

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

- `$vektor[7] = 42;`

  Bei der Zuweisung über einen Index ist hier das Dollar-Zeichen `$` zu beachten, da "`vektor[7]`" eine skalare Variable und kein Array darstellt! Die Indizierung der Arrays beginnt bei 0 (Eine Änderung dieses Verhaltens über die spezielle Variable `$[` ist nicht zu empfehlen!). In diesem Beispiel müssen übrigens die Inhalte `$vektor[0]` bis `$vektor[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 use strict; my @vektor = (4,6,"ein String",25); my $laenge = @vektor; # skalarer Kontext ! print "Länge = $laenge\n"; print "Letzter Index = $#vektor\n"; print "\$vektor[1] = $vektor[1]\n"; $vektor[7] = 42; $laenge = @vektor; print "Länge = $laenge\n"; print "Letzter Index = $#vektor\n";`

`Länge = 4 Letzter Index = 3 $vektor[1] = 6 Länge = 8 Letzter Index = 7`

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

`#!/usr/local/bin/perl -w use strict; my @vektor = (2,4,6,8,10,12); my @slice = @vektor; # (2,4,6,8,10,12) @slice = @vektor[2,3,4]; # (6,8,10) @slice = @vektor[2,4]; # (6,10)`

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 print "@ARGV\n";`

Achtung: Im Gegensatz 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`)!

[Seitenanfang]

## Hashes

Kennzeichen eines Hashes (früher auch als "assoziatives Array" bezeichnet) ist die Paarung von jeweils zwei Elementen in der Form "Schlüssel-Wert". Gekennzeichnet wird ein Hash durch ein Prozentzeichen "`%`" vor dem Variablennamen.

`#!/usr/local/bin/perl -w use strict; my %alter = ("Sabine","27","Klaus","35","Ralf","22"); print "$alter{Sabine}\n"; print "$alter{Klaus}\n"; print "$alter{Ralf}\n"; my @schluessel = keys(%alter); my @werte = values(%alter); print "\@schluessel = @schluessel\n"; print "\@werte = @werte\n";`

`27 35 22 @schluessel = Ralf Sabine Klaus @werte = 22 27 35`

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 Hash erhält man durch die Funktion `keys()`, eine Liste aller Werte durch `values()`. Die Reihenfolge der Elemente ist dabei scheinbar willkürlich (sie hängt von der sog. Hash-Funktion ab, die Perl intern verwendet) und muß keineswegs mit der in der Definition übereinstimmen.

Man kann die Elemente eines Hashes mit Hilfe der Funktion `each()` auch paarweise jeweils in ein zweielementiges Array lesen. Bei jedem Aufruf wird dabei das nächste Paar zurückgegeben.

`#!/usr/local/bin/perl -w use strict; my %h = ("Auto" => 1, "Haus" => 2, "Baum" => 3); print each(%h),"\n"; print each(%h),"\n"; print each(%h),"\n";`

`Haus2 Baum3 Auto1`

Auch hier ist die Reihenfolge (scheinbar) zufällig.

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

Auf Umgebungsvariablen (environment) kann über den speziellen Hash `%ENV` zugegriffen werden.

`#!/usr/local/bin/perl -w print $ENV{'LOGNAME'}."\n"; print $ENV{'DISPLAY'}."\n";`

[Seitenanfang]

Autor: Eike Grote | Version: 2.05 (24.1.2012)