Webseiten programmieren und gestalten

# Variablen und Operatoren

The computer should be doing the hard work. That's what it's paid to do, after all. The fact that it takes a little hard work from the programmer to make the computer do hard work should not be a consideration when the payoff is big.
– Larry Wall

# Skalare

In jeder Programmiersprache können Sie in einer Variable eine Zahl, eine Zeichenkette, einen Wahrheitswert oder eine Mehrzahl dieser Datentypen (Arrays) speichern. In Perl gibt es jedoch einen kleinen, aber feinen Unterschied, denn Variablen werden nochmals in kleinere Gruppen unterteilt. Variablen, die eine Zahl oder eine Zeichenkette speichern können, werden in Perl als Skalare bezeichnet. Zusätzlich gibt es noch die Untergruppe Arrays und Hashes. Um diese einzelnen Untergruppen unterscheiden zu können, wird dem Skalarbezeichner ein Dollarzeichen $ vorangestellt.

Während Sie in JavaScript Variablen mit dem Schlüsselwort var definiert haben, werden Skalare in Perl mit der Anweisung my im Perl-Script bekannt gemacht.

my $skalar;  
my $skalar = wert;

Sie können dabei entweder nur einen Skalar definieren oder ihm gleichzeitig mit dem =-Operator einen Wert zuweisen.

#!/usr/bin/perl -w
use CGI qw(:standard);
my $name = "Max Mustermann";
my $stadt = "Musterstadt";
my $plz = 99000;
my $alter = 75;
print header();
print "<html><head><title>Listing 2.1</title></head>";
print "<body>";
print "<h4>$name</h4>";
print "<h4>$plz $stadt</h4>";
print "<h4>$alter Jahre alt</h4>";
print "</body></html>";

Listing 2.1: Perl-Script, in dem vier Skalare definiert werden und einen Wert zugewiesen bekommen, der im Browser im HTML-Format ausgegeben wird

In Listing 2.1 werden insgesamt vier Skalare definiert: $name, $stadt, $plz und $alter. Diesen Skalaren wird zusätzlich ein Wert zugewiesen: zweimal eine Zeichenkette und zweimal ein Zahlenwert. Anschließend werden diese Skalare mit der print-Anweisung im Browser ausgegeben.

Die Regeln zum Bezeichnen von Skalaren sind folgende:

  • Das erste Zeichen eines Skalarbezeichners muss das Dollarzeichen $ sein.
  • Der Bezeichner darf keine Leerzeichen enthalten.
  • Außerdem dürfen keine deutschen Umlaute »ä, ö, ü« und kein »ß« vorkommen. Lediglich die Buchstaben von A-Z, a-z und der Unterstrich »_« sind erlaubt.
  • Bei den Bezeichnern wird zwischen Groß- und Kleinschreibung unterschieden. $NAME bezeichnet also nicht den gleichen Skalar wie $name oder $Name.

Im Zusammenhang mit der Interpreter-Option w ist folgender Hinweis zu beachten: Wenn Sie einen Skalar mit der my-Anweisung definieren und dabei keinen Wert zuweisen, führt dies bei Verwendung der w-Option unter Umständen zu einem Fehler, da dies kein sauberer Programmierstil ist.

Im Unterschied zu JavaScript müssen Sie nicht extra die Zeichenkette beenden und den +-Operator verwenden, um einen Skalar im Zusammenhang mit einer festen Zeichenkette auszugeben. Wenn Sie doppelte Anführungszeichen bei einer print-Anweisung verwenden, können Sie einen Skalarbezeichner immer innerhalb der Anführungszeichen notieren, um diesen auszugeben. Diese Möglichkeit wird auch »Auflösen« genannt. Dies ist bei einfachen Anführungszeichen jedoch nicht möglich.

print "Hallo $name!";  
  # Variante mit doppelten Anführungszeichen  
print 'Hallo '.$name.'!';  
  # Variante mit einfachen Anführungszeichen

# Arrays

Arrays werden in Perl zumeist als Listen bezeichnet. Dies macht durchaus Sinn. In anderen Programmiersprachen ist ein Array beispielsweise eine »Zusammenfassung« von Variablen des gleichen Typs. Es gibt z. B. ein Array, das nur aus Zeichenketten oder nur aus Zahlenwerten besteht. Arrays in Perl können jedoch aus unterschiedlichen Datentypen bestehen, also sowohl aus Zeichenketten als auch aus Zahlenwerten. Der Begriff »Liste« ist daher passender, weil Sie alle Werte zu einem bestimmten Thema in einer Liste speichern können, z. B. die spezifischen Daten einer Person wie den Namen und den Wohnort jeweils als Zeichenketten, die Postleitzahl und das Alter oder Geburtsjahr jeweils als Zahlenwerte.

Um Listen von Skalaren unterscheiden zu können, wird dem Listenbezeichner ein Klammeraffe @ vorangestellt, gefolgt vom eigentlichen Namen. Für den Namen gelten dabei die gleichen Regeln wie für das Bezeichnen von Skalaren. Und auch die Definition einer Liste erfolgt mit der Anweisung my. Die einzelnen Werte der Liste werden dabei in runden Klammern, durch Kommata getrennt, notiert und mit dem =-Operator zugewiesen.

my @liste;  
my @liste = (wert1, wert2, wert3,...,wertN);

Sehen Sie sich dazu ein kleines Beispiel an:

#!/usr/bin/perl -w
use CGI qw(:standard);
my @person = ("Max Mustermann",99000,"Musterstadt",75);
print header();
print "<html><head><title>Listing 2.2</title></head>";
print "<body>";
print "<pre>@person</pre>";
print "</body></html>";

Listing 2.2: Perl-Script, in dem eine Liste definiert und mit Werten gefüllt wird

In Listing 2.2 wird zuerst die Liste @person definiert. Bei der Definition werden ihr vier Werte zugewiesen, sowohl Zeichenketten als auch Zahlenwerte. Mit der print-Anweisung wird dann der gesamte Inhalt der Liste im Browser ausgegeben.

Wussten Sie, dass Programmierer schreibfaul sind? Denn genau aus diesem Grund gibt es eine besondere Syntax, um z. B. eine Liste zu erzeugen, die die Zahlen von 1 bis 100 enthält. Denn anstatt alle Zahlen einzeln in die Liste einzutragen, können Sie einfach einen Zahlenbereich angeben.

my @zahlen = (1..100);

Mit dieser Schreibweise wird eine Liste mit dem Bezeichner @zahlen erzeugt und mit den Zahlenwerten von 1 bis 100 gefüllt. Diese Schreibweise können Sie auch verwenden, um eine Liste mit den Buchstaben von A bis Z zu definieren.

my @grossbuchstaben = ("A".."Z");

Auch eine Kombination ist möglich. Dabei müssen die einzelnen Wertebereiche durch Kommata getrennt werden.

my @buchstaben = ("A".."Z","a".."z");

Die Liste @buchstaben enthält nun 52 Elemente, nämlich die Buchstaben von A bis Z und von a bis z. Und auch die folgende Kombination ist erlaubt.

my @buchstabenUndZahlen = ("A".."Z",1..100);

Diese Liste verfügt über 126 Elemente: die Buchstaben von A bis Z und die Zahlen von 1 bis 100.

# Zugriff auf einzelne Elemente

Bisher haben Sie sich nur damit beschäftigt, eine Liste mit mehreren Elementen zu erzeugen und diese vollständig im Browser auszugeben. Es gibt jedoch auch die Möglichkeit, auf einzelne Elemente einer Liste zuzugreifen.

Gehen Sie einmal davon aus, dass Sie eine Liste mit dem Bezeichner @person definiert haben und diese Liste vier Werte enthält.

my @person = ("Larry Wall","verheiratet","4 Kinder","Vater von Perl");

Um nun die Elemente der Listen einzeln ausgeben zu können, greifen Sie nicht direkt auf die Liste zu, sondern müssen den Umweg über einen Skalar gehen, dem Sie einen Index übergeben. Dieser Index muss in eckigen Klammern hinter dem Skalarbezeichner notiert werden. Der Skalarbezeichner entsteht aus dem Bezeichner der Liste, statt eines Klammeraffen @ wird jedoch ein Dollarzeichen $ notiert.

print "<h1>$person[0]</h1>";

Mit dieser Anweisung greifen Sie auf ein Element der Liste @person zu. Da bei Listen die Zählung mit 0 beginnt, besitzt das erste Element der Liste den Index 0, das zweite Element den Index 1, das dritte den Index 2 usw. Im Browser würde die Anweisung also

Larry Wall

ausgeben. Auf das zweite Element der Liste können Sie dann über den Skalar $person[1], auf das dritte Element über $person[2] und auf das vierte Element über $person[3] zugreifen. Im folgenden Listing wird die Liste @person definiert, und die einzelnen Elemente werden dann getrennt ausgegeben.

#!/usr/bin/perl -w
use CGI qw(:standard);
my @person = ("Larry Wall","verheiratet","4 Kinder","Vater von Perl");
print header();
print "<html><head><title>Listing 2.3</title></head>";
print "<body>";
print "<h1>$person[0]</h1>";
print "<h4>ist $person[1], hat $person[2] und ist der $person[3].</h4>";
print "</body></html>";

Listing 2.3: Perl-Script mit einer definierten Liste, auf deren Elemente einzeln zugegriffen wird

Mit einer speziellen Syntax können Sie auf das letzte Element einer Liste zugreifen. Um z. B. auf das letzte Element der Liste @person zuzugreifen, ohne zu wissen, welchen Index dieses Element besitzt, können Sie die spezielle Syntax $person[$#person] verwenden. Dies gilt natürlich auch für Listen mit einem anderen Bezeichner.

# Hashes

Eine spezielle Form von Listen bzw. Arrays sind Hashes. Diese werden in anderen Programmiersprachen auch als assoziative Arrays bezeichnet. Bei Listen werden die einzelnen Elemente über eine Indexnummer angesprochen, während bei Hashes die Elemente über einen Namen angesprochen werden. Ein Element eines Hashs wird also mit einem Namen assoziiert, der auch als Schlüssel bezeichnet wird.

Das Prozentzeichen % zu Beginn des Bezeichners definiert die Variable als Hash. Anschließend folgt der individuelle Bezeichner, der ebenfalls den Namensregeln unterliegt, wie schon Skalare und Listen.

my %person = (Name => "Max Mustermann", Ort => "Musterstadt", PLZ => 99000, Alter => 75);

Diese Anweisung definiert den Hash %person und definiert gleichzeitig vier Elemente, die durch Kommata getrennt werden. Der Wert auf der linken Seite der Zeichenfolge => bezeichnet den Schlüssel des Elements, und der Wert auf der rechten Seite der Zeichenfolge ist der entsprechende Wert des Elements. Insgesamt werden also die folgenden vier Wertepaare definiert:

  • Ein Element mit dem Schlüssel Name und dem Wert "Max Mustermann".
  • Ein Element mit dem Schlüssel Ort und dem Wert "Musterstadt".
  • Ein Element mit dem Schlüssel PLZ und dem Wert 99000.
  • Ein Element mit dem Schlüssel Alter und dem Wert 75.

Während Sie jedoch bei Listen mit einer Anweisung wie

print "<pre>@liste</pre>";

alle Elemente einer Liste auf einfache Art und Weise ausgeben konnten, müssen Sie bei Hashes einen etwas anderen Weg beschreiten. Die Syntax zum Ausgeben aller Werte eines Hashs sieht wie folgt aus:

print "<pre>",%hash,"</pre>";

Dabei werden jedoch sowohl die Schlüssel als auch die Werte ausgegeben.

# Zugriff auf einzelne Elemente

Wie schon bei Listen greifen Sie auf die einzelnen Elemente eines Hashs über einen Skalar zu. Dabei entspricht der Bezeichner des Skalars dem Bezeichner des Hashs (anstelle eines %-Zeichens wird jedoch ein $-Zeichen notiert). Die Syntax sieht aber ein wenig anders aus. Der Schlüssel des Elements wird dabei in einfachen Anführungsstrichen innerhalb von geschweiften Klammern notiert und an den Skalarbezeichner angehängt.

$hash{'schlüssel'};

Diese Schreibweise kann auch verkürzt werden. Bedingung ist jedoch, dass der Schlüsselname des Elements den Namensregeln unterliegt (keine Sonderzeichen und Umlaute usw.). In diesem Fall dürfen Sie die Anführungsstriche auch weglassen.

$hash{schluessel};

Beachten Sie jedoch, dass bei den Schlüsseln zwischen Groß- und Kleinschreibung unterschieden wird – ganz genauso wie bei der Bezeichnung von Skalaren, Listen und Hashes.

Der Zugriff auf die einzelnen Elemente des Beispiel-Hashs %person wird in Listing 2.4 dargestellt.

#!/usr/bin/perl -w
use CGI qw(:standard);
my %person = (Name => "Max Mustermann", Ort => "Musterstadt", PLZ => 99000, Alter => 75);
print header();
print "<html><head><title>Listing 2.4</title></head>";
print "<body>";
print "<h1>$person{Name}</h1>";
print "<h4>wohnt in $person{PLZ} $person{Ort} und ist $person{Alter} Jahre alt.</h4>";
print "</body></html>";

Listing 2.4: Ausgabe der einzelnen Elemente eines Hashs

Summa summarum sind Hashes also übersichtlicher in der Verwendung, da Sie die Indexnummern der einzelnen Elemente nicht kennen müssen, sondern bequem über den Schlüssel auf ein Element zugreifen können.

# Unbekannte Schlüssel ermitteln

Sollten Sie einmal in die Situation kommen, einen Hash verwenden zu müssen, bei dem Ihnen die Schlüssel unbekannt sind, können Sie mit der Funktion keys diese Schlüssel in einer Liste speichern. Die Syntax für diese Funktion lautet:

@liste = keys(%hash);

Alle Schlüsselnamen des Hashs werden dann in der angegebenen Liste gespeichert.

#!/usr/bin/perl -w
use CGI qw(:standard);
my %person = (Name => "Max Mustermann", Ort => "Musterstadt", PLZ => 99000, Alter => 75);
my @personKeys = keys(%person);
print header();
print "<html><head><title>Listing 2.5</title></head>";
print "<body>";
print "<pre>@personKeys</pre>";
print "</body></html>";

Listing 2.5: Ermitteln und Ausgeben der Schlüsselnamen eines Hashs

Zuerst wird in Listing 2.5 der Hash %person definiert und anschließend die Liste @personKeys, in der die Schlüsselnamen des Hashs %person gespeichert werden. Diese Schlüsselnamen werden dann im Browser ausgegeben.

Die Funktion values funktioniert exakt wie die keys-Funktion, nur dass diese Funktion die Werte und nicht die Schlüssel zurückgibt. Dabei muss der Rückgabewert ebenfalls wieder einer Liste zugewiesen werden.

# Vordefinierte Variablen

In Perl gibt es eine Vielzahl vordefinierter Variablen, die die unterschiedlichsten Daten enthalten. So können Sie den Namen des laufenden Perl-Programms oder die Interpreter-Version ermitteln. In der folgenden Tabelle sind die wichtigsten Variablen aufgelistet.

Variable Beschreibung Beispiel
$\ Enthält eine Zeichenkette, die an jede Ausgabe mit print angehängt wird. $\ = »ENDE«; print »Hallo!«;
$0 Enthält den Namen des laufenden Perl-Programms. print $0;
$] Enthält die Versionsnummer des aufrufenden Perl-Interpreters. print $];
$^O Enthält den Namen des Betriebssystems. print $^O;
$^T Enthält das Datum und die Uhrzeit, an dem das Perl-Programm gestartet wurde. Der Wert entpricht den vergangenen Sekunden seit dem 1.1.1970 um 0:00 Uhr. print $^T;
$^W Wahr, wenn die Interpreter-Option w gesetzt wurde. Unwahr, wenn die Option nicht gesetzt wurde. print $^W;
$^X Enthält den Dateinamen des aufrufenden Perl-Interpreters. print $^X;
%ENV Enthält die vom Webserver übergebenen Umgebungvariablen. print keys(%ENV);

Tabelle 3.1: Die wichtigsten vordefinierten Variablen in Perl

Auf weitere vordefinierte Variablen werde ich an gegebener Stelle noch genauer eingehen.

# Operatoren

Wie in jeder Programmiersprache gibt es auch in Perl Operatoren, um Werte zu addieren, zu multiplizieren, zu verbinden oder zu vergleichen.

# Zuweisungsoperator

Der Zuweisungsoperator in Perl ist das Gleichheitszeichen =. Mit diesem Operator können Sie einem Skalar entweder einen Zahlenwert oder eine Zeichenkette zuweisen.

my $string = "NCC-1701-E";  
my $integer = 1701;

# Berechnungsoperatoren

Die Grundrechenarten Addition, Subtraktion, Multiplikation und Division werden auf die gleiche Art und Weise durchgeführt wie in JavaScript.

$addi = 1 +  2;         # Addition, Ergebnis = 3  
$sub = 2 -  1;          # Subtraktion, Ergebnis = 1  
$multi = 2 *  5;        # Multiplikation, Ergebnis = 10  
$div = 10 /  5;         # Division, Ergebnis = 2

Natürlich ist auch eine Verkettung verschiedener Berechnungsoperatoren möglich. Durch das Setzen von runden Klammerpaaren können Sie innerhalb eines Terms gewissen Rechenoperationen eine höhere Priorität zuordnen, da komplexe Terme nach der Punkt-vor-Strich-Rechnung durchgeführt werden.

$ergebnis = 10 + 20 / 4;        # $ergebnis = 15  
$ergebnis = 20 * 5 – 50;        # $ergebnis = 50  
$ergebnis = (10 + 20) / 3;      # $ergebnis = 10  
$ergebnis = 20 * (5 – 50);      # $ergebnis = -900

Zusätzlich zu den vier Grundrechenoperatoren gibt es noch den Modulo- und den Potenzoperator. Bei einer Modulo-Rechnung wird bei einer Division der ganzzahlige Rest zurückgegeben. Der Operator für die Modulo-Rechnung ist %.

$ergebnis = 13 %  5;             # $ergebnis = 3

Der Potenzoperator ist **. Dabei wird das Ergebnis aus dem Wert links vom Operator hoch dem Wert rechts vom Operator ermittelt.

$ergebnis = 6 **  5;             # $ergebis = 7776

Um die Übersicht zu erhöhen und außerdem Schreibarbeit zu sparen, können Sie bestimmte Rechenoperation abkürzen. Möchten Sie den Wert von $x z. B. um den Wert 1 erhöhen, können Sie anstelle von

$x = $x + 1;

auch

$x++;

schreiben. Das Gegenteil – einen Wert um 1 zu verringern – erreichen Sie durch die Schreibweise:

$x--;

Zusätzlich zu diesen beiden Schreibweisen gibt es noch weitere. Sie können Sie immer dann verwenden, wenn Sie den Wert einer Variablen verändern und das Ergebnis wieder in der gleichen Variablen speichern möchten. In der folgenden Tabelle finden Sie eine Übersicht über diese Abkürzungen.

Langform Kurzform Erklärung
$x = $x + 15; $x += 15; $x um 15 erhöhen
$x = $x – 15; $x -= 15; $x um 15 verringern
$x = $x × 2; $x *= 2; $x mit 2 multiplizieren
$x = $x / 2; $x /= 2; $x durch 2 dividieren
$x = $x % 3; $x %= 3; ganzzahliger Rest von $x durch 3
$x = $x ** 3; $x **= 3; $x hoch 3

Tabelle 3.2: Verkürzte Schreibweisen für Berechnungen

# Vergleichsoperatoren

Bei Vergleichen zwischen Werten müssen Sie zwischen dem Vergleich von Zahlenwerten und dem Vergleich von Zeichenketten unterscheiden, da unterschiedliche Vergleichsoperatoren angewendet werden müssen.

Sie können Zahlenwerte daraufhin vergleichen, ob sie gleich, ungleich, größer, kleiner, größer gleich oder kleiner gleich sind. Das Ergebnis eines solchen Vergleichs ist immer wahr oder unwahr.

Vergleich Operator Beispiel Ergebnis
Sind die Werte gleich? == 1 == 1 Wahr
Sind die Werte gleich? == 1 == 2 Unwahr
Sind die Werte ungleich? != 1 != 2 Wahr
Sind die Werte ungleich? != 1 != 1 Unwahr
Ist der linke Wert größer? > 10 > 5 Wahr
Ist der linke Wert größer? > 5 > 10 Unwahr
Ist der linke Wert kleiner? < 1 < 5 Wahr
Ist der linke Wert kleiner? < 5 < 1 Unwahr
Ist der linke Wert größer-gleich? >= 10 >= 5 Wahr
Ist der linke Wert größer-gleich? >= 10 >= 10 Wahr
Ist der linke Wert größer-gleich? >= 5 >= 10 Unwahr
Ist der linke Wert kleiner-gleich? <= 5 <= 10 Wahr
Ist der linke Wert kleiner-gleich? <= 5 <= 5 Wahr
Ist der linke Wert kleiner-gleich? <= 5 <= 2 Unwahr

Tabelle 3.3: Operatoren zum Vergleichen von Zahlenwerten

Auch Zeichenketten können Sie dahingehend vergleichen, ob sie gleich, ungleich, kleiner, größer, kleiner gleich oder größer gleich sind. Dabei werden Größer- und Kleiner-Vergleiche bei Zeichenketten so durchgeführt, dass den einzelnen Buchstaben ein Zahlenwert in der Reihenfolge des Alphabets zugewiesen wird. A entspräche dann dem Wert 1 und Z dem Wert 26. Somit ist also der Buchstabe Z größer als der Buchstabe A. Die Buchstaben von a bis z bekommen die Werte von 27 bis 52. Dabei entspricht a dem Wert 27 und z dem Wert 52.

Vergleich Operator Beispiel Ergebnis
Sind die Werte gleich? eq "A" eq "A" wahr
Sind die Werte gleich? eq "A" eq "Z" Unwahr
Sind die Werte ungleich? ne "A" ne "Z" Wahr
Sind die Werte ungleich? ne "A" ne "A" Unwahr
Ist der linke Wert größer? gt "Z" gt "A" Wahr
Ist der linke Wert größer? gt "A" gt "Z" Unwahr
Ist der linke Wert kleiner? lt "A" lt "Z" Wahr
Ist der linke Wert kleiner? lt "Z" lt "A" Unwahr
Ist der linke Wert größer-gleich? ge "Z" ge "A" Wahr
Ist der linke Wert größer-gleich? ge "Z" ge "Z" Wahr
Ist der linke Wert größer-gleich? ge "A" ge "Z" Unwahr
Ist der linke Wert kleiner-gleich? le "A" le "Z" Wahr
Ist der linke Wert kleiner-gleich? le "A" le "A" Wahr
Ist der linke Wert kleiner-gleich? le "Z" le "A" Unwahr

Tabelle 3.4: Operatoren zum Vergleichen von Zeichenketten

# Logische Operatoren

Das Spektrum an logischen Operatoren in Perl ist im Vergleich zu JavaScript relativ groß. Es sind sowohl UND/ODER-Bedingungen als auch ENTWEDER/ODER-Bedingungen möglich. Außerdem haben Sie die Möglichkeit, verschiedene Schreibweisen anzuwenden.

Für UND-Bedingungen können Sie den Operator && oder and verwenden. Für ODER-Bedingungen stehen die Operatoren || und or zur Verfügung:

if($x = 1 && $y = 2)  
  # wenn $x = 1 und $y = 2  
if($x = 1 and $y = 2)  
  # wenn $x = 1 und $y = 2  
if($x = 1 || $y = 2)  
  # wenn $x = 1 oder $y = 2  
if($x = 1 or $y = 2)  
  # wenn $x = 1 oder $y = 2

Für ENTWEDER/ODER-Bedingungen können Sie den ^-Operator oder den xor-Operator verwenden:

if($x = 1 ^ $y = 2)  
  # wenn entweder $x = 1 oder $y = 2  
if($x = 1 xor $y = 2)  
  # wenn entweder $x = 1 oder $y = 2

Bei ENTWEDER/ODER-Bedingungen darf nur eine der beiden Bedingungen erfüllt sein. Also muss entweder $x = 1 sein oder $y = 2 sein. Hat $x den Wert 1 und $y den Wert 2, gilt die Bedingung als nicht erfüllt.

Außerdem können Sie mit den Operatoren ! und not eine Bedingung umkehren. Das heißt, Sie überprüfen anstelle von »wahr« auf »unwahr« und umgekehrt.

if(!($x == 1))  
  # wenn $x nicht gleich 1, äquivalent $x != 1  
if(not($x = 1))  
  # wenn $x nicht gleich 1, äquivalent $x != 1

# Zeichenkettenoperator

In eigentlichen Sinne gibt es nur zwei Zeichenkettenoperatoren: einen zum Verknüpfen von Zeichenketten und einen weiteren, um eine bestimmte Zeichenfolge zu wiederholen. Mit dem .-Operator können Sie zwei Zeichenketten miteinander verbinden.

my $name = "Max "."Mustermann";  
print $name;  
  # Ausgabe: Max Mustermann

Dabei ist jedoch auch wieder eine kürzere Schreibweise möglich, wenn Sie mehrere Zeichenketten an eine andere anhängen möchten.

my $name = "Max";  
$name .= " ";  
$name .= "Mustermann";  
print $name;  
  # Ausgabe: Max Mustermann

Mit dem x-Operator können Sie eine Zeichenfolge wiederholen.

my $text = "A"x10;  
print $text;  
  # Ausgabe: AAAAAAAAAA  
my $text = "Aha"x3;  
print $text;  
  # Ausgabe: AhaAhaAha

Dabei wird nach der zu wiederholenden Zeichenfolge der x-Operator notiert und als Zahl dahinter angegeben, wie oft die vorherige Zeichenfolge wiederholt werden soll.

# Zusammenfassung

  • Variablen in Perl unterteilen sich in die Gruppen Skalare, Listen und Hashes.
  • Skalare können Zahlenwerte und Zeichenketten speichern und werden durch das Dollarzeichen $ identifiziert.
  • Listen entsprechen Arrays, wobei diese nicht auf einen Datentyp festgelegt sind. Identifiziert werden Sie durch den Klammeraffen @.
  • Hashes sind assoziative Arrays, die durch das Prozentzeichen % identifiziert werden.
  • Perl verfügt über eine Reihe vordefinierter Variablen.
  • Es gibt verschiedene Operatoren, die sich in die Gruppen Zuweisungsoperatoren, Berechnungsoperatoren, Vergleichsoperatoren, logische Operatoren und Zeichenkettenoperatoren unterteilen.

# Fragen und Übungen

  1. Mit welchen vier Operatoren können die Grundrechenarten durchgeführt werden?
  2. Worin bestehen die Unterschiede zwischen den Operatoren and, or und xor?
  3. Welche alternativen Schreibweisen existieren für die drei logischen Operatoren and, or und xor?
  4. Mit welcher Anweisung können Sie alle Schlüsselnamen des %ENV-Hashs ermitteln?
  5. Schreiben Sie ein vollständiges Perl-Programm, das alle Werte des %ENV-Hashs im Browser ausgibt.
  6. Welche Regeln müssen Sie bei der Bezeichnung von Skalaren, Listen und Hashes einhalten?
  7. Mit welchem Schlüsselwort müssen Sie Variablen definieren?

← Subroutinen →