CGI: Variablen und Konstanten
Perl stellt ein vollständiges Repertoire an Variablentypen zur Verfügung, mithilfe derer sich sehr umfangreiche und variable Datenstrukturen erschaffen lassen. Darüber hinaus kann Perl diese Variablentypen in verschiedenen Kontexten bewerten, was dem Nutzer der Programmiersprache schnell die großen Vorzüge und Stärken von Perl offenbart.Gültigkeitsbereiche von Variablen (beschränken)
Man unterscheidet im Allgemeinen zwischen globalen und lokalen Variablen. Global heißt, dass der Wert einer Variablen egal welcher Art für das ganze Script, also auch in Subroutinen, gültig ist.In Perl gibt es jedoch Methoden, um den Gültigkeitsbereich einer Variablen lokal auf eine Subroutine oder einen Anweisungsblock zu beschränken.
Der Vorteil dabei ist, dass die Wertänderung einer lokalen Variablen keine Auswirkungen auf den Wert der eventuell vorhandenen gleichnamigen globalen Variable hat. Andersherum gilt gleiches, da der Wert einer lokalen Variable außerhalb der Subroutine oder des Anweisungsblocks, in der/dem sie deklariert wurde, nicht bekannt ist. So werden ungewollte Wertzuweisungen vermieden. Zur lokalen Gültigkeitsbeschränkung existieren in Perl zwei Funktionen:
$Zahl = 1; #globale Variable
$Zahl2 = 0; #globale Variable
&Sub1; #Aufruf der Subroutine Sub1
if($Zahl2 == 0)
{
local $Zahl = 3;
print $Zahl; #Gibt 3 aus
}
#----------------------------------
sub Sub1
{
my $Zahl = 2;
print $Zahl; #Gibt 2 aus
}
#----------------------------------
print $Zahl; #Gibt 1 aus
my und local. Beide machen anscheinend dasselbe: Sie beschränken die Gültigkeit der Variablen $Zahl auf die Subroutine bzw. den Anweisungsblock (bedingte Anweisung). Der Wert der globalen Variable $Zahl ist im Endeffekt zwar "unverändert", dennoch bleibt er nicht in beiden Fällen unberührt. Die Funktion local erzeugt nämlich keine echte lokale Variable, sondern nur eine globale Variable mit "lokalem Wert". Der Variablen $Zahl wird im Prinzip für die Dauer des Anweisungsblocks ein temporärer Wert zugewiesen. Man sollte daher bevorzugt auf die Funktion my zurückgreifen.
Variablentypen
In Perl unterscheidet man im Wesentlichen zwei Gruppen von Variablentypen; die einfachen und die zusammengesetzten, zu denen wiederum folgende gehören:- einfache Variablentypen: Skalare vom Typ Zahlen (integer [Ganzzahl] , floating-point [Gleitpunktzahl]) oder vom Typ string [Zeichenkette]
- zusammengesetzte Variablentypen: Array (Liste), Hash (assoziatives Array), Objekte
$) zu Beginn gekennzeichnet:
$Zahl = 12;
Die oben erwähnte Tatsache deutet jedoch zugleich auf eine große Stärke von Perl, nämlich der vielseitigen Bewertbarkeit von Skalaren in unterschiedlichen Kontexten, hin. Hier einige Beispiele:$String = "123"; #Skalar (Typ String)
$Zahl = $String + 2; #Bewertung von $String als Zahl (Integer)
print $Zahl; #Gibt 125 aus
$Zahl = 1357924; #Skalar (Typ Integer)
$Substring = substr($Zahl,2,3); #Bewertung von $Zahl als String
print $Substring; #Gibt "579" aus
Zahlen (integer und floating-point) - Konstante
Perl hat standardmäßig die Fähigkeit mit 32-Bit Gleitpunktzahlen oder Ganzzahlen zu operieren. Bei mathematischen Berechnungen werden jedoch alle Zahlen als Gleitkommazahlen behandelt.Bei Verwendung des
Math-Moduls können im Prinzip sogar beliebig große Zahlen verwendet werden. Auf sämtliche Zahlen, welche wie oben erwähnt in Skalaren gespeichert werden, lassen sich mittels der Operatoren alle Grundrechenarten und des Weiteren wichtige Funktionen (Wurzel, Logarithmus, Trigonometrie, etc.) ausführen. Dies wird jedoch später behandelt. Die Notation von Zahlen gespeichert in Skalaren sieht beispielhaft wie folgt aus:
$pos_Ganzzahl = 4; #Positive Ganzzahl
$neg_Ganzzahl = -4; #Negative Ganzzahl
$pos_Gleitzahl = 3.46574; #Positive Gleitpunktzahl
$neg_Gleitzahl = -3.46574; #Negative Gleitpunktzahl
$Zahl = 201_197_010
#Gleichbedeutend mit 201197010
Zeichenketten (strings) - Konstante
Strings werden ebenso wie Zahlen in Skalaren gespeichert, wobei ihre Länge vonseiten der Programmiersprache unbegrenzt ist - lediglich der verfügbare Speicherplatz des Systems begrenzt die Länge eines Strings.Es gibt zwei Möglichkeiten, einen String im Perl-Code zu notieren:
- single quoted (', einfacher Anführungsstrich)
- double quoted (", doppelter Anführungsstrich)
$String1 = "Der 1. String";
print 'Ich bin einfacher String namens: $String1'; #Ausgabe1
print "Ich bin einfacher String namens: $String1"; #Ausgabe2
$String1" ausgegeben, während bei Ausgabe2 an gleicher Stelle der Wert von $String1, also "Der 1. String", angezeigt wird. Bei Notation von Strings in doppelten Anführungsstrichen wird der String vom Perl-Interpreter also geparst, während er andernfalls nicht ausgewertet, d.h. nach Variablen durchsucht, wird.Soll innerhalb eines Strings ein Anführungszeichen vorkommen, so muss dieses mit einem Backslash (
print 'Ich bin einfacher String namens: '$String1'';
#Ausgabe1 - führt zu Fehler
print "Ich bin einfacher String namens: "$String1"";
#Ausgabe2 - führt zu Fehler
print 'Ich bin einfacher String namens: '$String1'';
#korrekte Ausgabe1
print "Ich bin einfacher String namens: "$String1"";
#korrekte Ausgabe2
" doppeltes Anführungszeichen
Backslash
n Zeilenvorschub (newline)
r Wagenrücklauf Return
t horizontaler Tabulator
f Seitenvorschub
v vertikaler Tabulator
b Backspace (Rückschritt)
a akustisches Signal
e Escape (Escape-Sequenzen)
Des Weiteren gibt es noch Sonderzeichen, welche die Groß- und Kleinschreibung innerhalb eines Strings beeinflussen können:
l #nachfolgender Buchstabe wird klein geschrieben
u #nachfolgender Buchstabe wird groß geschrieben
L #alle Buchstaben bis E werden klein geschrieben
U #alle Buchstaben bis E werden groß geschrieben
E #"Stopp" für L und U
print "LWort1"; #Gibt "wort1" aus
print "uwort2"; #Gibt "Wort2" aus
print "UWOrtELzusammenSETZUNGE";
#Gibt "WORTzusammensetzung" aus
Listen bzw. Arrays
Eine Array, der Variablentyp in Perl, in dem einfache Listen gespeichert werden können, ist grundsätzlich eine eindimensionale Variable (Vektor), welche durch ein@-Zeichen eingeleitet wird. Sie stellen dabei im Prinzip eine Aneinanderkettung skalarer Größen konstanten oder auch variablen Inhalts dar, deren Anzahl - und damit die Länge des Arrays - seitens der Programmiersprache unbegrenzt ist. Da in Perl Arrays, Hashes und skalare Variablen getrennt voneinander, d.h. in unterschiedlichen Namensräumen, behandelt werden, ist die gleiche Bezeichnung einer skalaren Variable und eines Arrays/Hashes möglich:
$EinString = "Hallo";
@EinArray = ("String",12,3,$EinString); #erzeugt ein Array
$EinArray = 1; #führt zu keinem Konflikt
@EinArray2; #erzeugt leeres Array
$ statt @) Kontext, wobei die Indizierung normalerweise mit 0 beginnt. Der Index selbst wird nach dem Arraynamen innerhalb von eckigen Klammern notiert. Beispiel:
print $EinArray[1];
#Gibt 12 (zweites Arrayelement: Index 1) aus
$EinArray[0] = "AndererString";
#Ändert den Wert des 1. Arrayelements
$LaengeArray = @EinArray;
#Länge d. Arrays @EinArray in $LaengeArray gespeichert
$# erfragen, in dem man sie dem Arraynamen voranstellt:
print $#EinArray;
#Gibt Index des letzten Elements von @EinArray aus
print $EinArray[$#EinArray];
#Gibt letztes Element von @EinArray aus
$[ (standardwert 0) beeinflussen:
@Array = (0,1,2,3,4);
$[ = 1;
print $Array[3]; #Gibt 2 aus
$Array[3] statt standardmäßig 3 nun der Wert 2 ausgegeben wird. Von der Manipulation dieser Variable sollte jedoch ab Perl 5 abgesehen werden, da dies - insbesondere bei Scripten mit mehreren Modulen - zu Problemen führt.Man kann auch Bereiche von Zahlen oder Buchstaben in Arrays unter Verwendung eines speziellen Operators erstellen:
@Array = (1..100); #Array mit Zahlen 1 bis 100
@Array = ("A".."Z"); #Array mit Buchstaben von A bis Z
Mehrdimensionale Arrays
Perl kennt für die Erzeugung mehrdimensionaler Arrays, also Listen, die nicht nur als Vektor, sondern als Matrix aufgefasst werden können, keine spezielle Methode, wie man es aus anderen Programmiersprachen kennt.Mithilfe von Verschachtelungen, d.h. Referenzen auf Listen selbst als Element eines übergeordneten Arrays, können jedoch Arrays beliebiger Dimensionalität erzeugt werden.
Möchte man beispielsweise eine Tabelle als Datenstruktur realisieren, so kann man durch einfache Verschachtelung bei Verwendung von Referenzen/Zeigern ein zweidimensionales Array kreieren, welches diesen Anforderungen gerecht wird:
@Buch1 = ("Autor1","Titel1","Verlag1");
@Buch2 = ("Autor2","Titel2","Verlag2");
@Buecher = (@Buch1,@Buch2);
print $Buecher[1]->[2];
#Gibt den Verlag des 2.Buches, also "Verlag2", aus
@Buecher bildlich als Tabelle vor, so würde man beim ersten Indexschlüssel ([1]) der Tabelle @Buecher in die zweite Zeile (Index beginnt mit 0!!!) der Tabelle und anschließend mit dem zweiten Indexschlüssel ([2]) in die dritte Spalte der Tabelle @Buecher gehen und den dort befindlichen Wert (hier: Verlag des 2. Buches: Verlag2) ausgeben lassen.Zu beachten ist in diesem Beispiel die Syntax im Array
@Buecher und die Reihenfolge der Initialisierung der Arrays. Es wurde ein Array @Buecher erstellt, das die Referenzen auf die Arrays @Buch1 und @Buch2 als Elemente enthält. Die Backslashes vor den Elementen sind deshalb von großer Bedeutung, da sie die Referenzen auf die Arrays signalisieren. Der Wert z.B. der Variablen $Buecher[0] wäre so lediglich die Speicheradresse von @Buch1 als Unterarray von @Buecher. Ließe man die Backslashes weg, so würden nur die Elemente von @Buch1 sowie @Buch2 dem Array @Buecher angehangen werden. Es entstünde demnach keine mehrdimensionale Datenstruktur. Des Weiteren ist es notwendig die Unterarrays vor dem übergeordneten Array zu deklarieren, da sonst die Referenz auf die Unterarrays aufgrund fehlender Speicheradresse nicht funktioniert.
Assoziative Arrays (Hashes)
Ein assoziatives Array (Hash) ist ebenfalls wie ein Array eine grundsätzlich eindimensionale Variable, welche durch ein Prozentzeichen (%) eingeleitet wird. Während in einem Array ein Wert pro Element gespeichert wird, besteht ein Element eines Hashes stets aus der Paarung eines Werts und eines dazu gehörigen Schlüssels. Wert und Schlüssel werden entweder wie einzelne Elemente eines Arrays durch ein einfaches Komma oder - zur besseren Darstellung der Wertpaare Wert/Schlüssel - durch die Zeichenfolge => (auch fat-comma genannt) getrennt. Die Länge eines Hashes ist ebenfalls lediglich durch den maximal verfügbaren Speicherplatz des Systems begrenzt.
$Einwohner = 314123;
#strukturell bessere Darstellung
%Land = (Name => "LName",
Hauptstadt => "HName",
Einwohner => $Einwohner);
#alternative Darstellung
%Land = ("Name","LName",
"Hauptstadt","HName",
"Einwohner",$Einwohner);
$Land = 1; #führt zu keinem Konflikt
%EinHash; #erzeugt leeren Hash
$ statt %), wobei der Schlüssel in geschweiften Klammern und Anführungsstrichen angehängt wird:
print $Land{'Einwohner'};
#Gibt Wert des Elements mit Schlüssel Einwohner aus
$Land{'Name'} = "AndererName";
#Ändert Wert des Elements mit Schlüssel Name
Ein Array mit den Schlüsseln eines Hashes erhält man, indem man die Funktion
keys() auf den Hash anwendet. Analog dazu lässt sich ein Array mit den Werten eines Hashes mittels der values-Funktion erzeugen:
@HashKeys = keys(%Land);
#erzeugt Array mit Hashschlüsseln
@HashValues = values(%Land);
#erzeugt Array mit Hashwerten
$LaengeHash = keys(%Land);
#oder:
$LaengeHash = values(%Land);
Mehrdimensionale Hashes
Perl kennt für die Erzeugung mehrdimensionaler Hashes ebenso wie für die Erzeugung derartiger Arrays keine speziell vordefinierte Methode. Dem Prinzip der Verschachtelung (siehe mehrdimensionale Arrays) folgend lassen sich auch hier mithilfe von Zeigern (diesmal) auf Hashes die gewünschten Strukturen erzeugen. Der Zugriff auf ein beliebiges Element des übergeordneten Hashes erfolgt hier über den Index des Arrays, das - erzeugt mit derkeys()-Funktion - die Schlüssel dieses Hashes enthält. Ein weiteres unkommentiertes Beispiel:
%Stadt1 = (Name => "SName1", EW => 100000);
%Stadt2 = (Name => "SName2", EW => 200);
%Staedte = (S1 => %Stadt1, S2 => %Stadt2);
@StaedteKeys = keys(%Staedte);
print $Staedte{$StaedteKeys[1]}->{"EW"};
#Gibt EW-Zahl der 2. Stadt (200) aus
Zeiger/Referenzen auf die einzelnen Variablentypen
Referenzen sind keine Innovation von Perl, sondern schon vorher und heute eigentlich in den meisten Programmiersprachen als ein mächtiges, weil wirkungsvolles, Konzept für einen sehr effizienten Programmierstil verankert. Sie sind im Wesentlichen Zeiger auf die Werte beispielsweise anderer Variablen und enthalten demnach selbst als Wert lediglich die Speicheradresse dieser zuvor deklarierten Variablen, Subroutinen, etc.Referenzen ragen heute durch ihre Notwendigkeit für die objektorientierte Programmierung und ihre Eignung zur Erzeugung komplexer Datenstrukturen hervor. Der letztgenannte Sachverhalt wurde in den Abschnitten mehrdimensionale Arrays und Hashes bereits verdeutlicht.
Referenzen sind unabhängig von dem Typ des Objekts, auf das sie "zeigen", stets skalare Größen und werden somit stets in der allgemeinen Form eines Skalars (
$name) notiert. Des Weiteren ist allen Referenzen gleich, dass sie durch Voranstellen eines Backslashs ($Referenz = referenziertes Objekt;
Die restliche Syntax hängt daher ausschließlich vom Typ des refenzierten Objekts ab, wobei sich höchst unterschiedliche Schreibweisen ergeben. Wohlmöglich erscheint sie dem Leihen zunächst etwas wirr. Sie orientiert sich jedoch an der Perl-üblichen Notationsweise der referenzierten Objekte. Im Folgenden soll dies aufgeschlüsselt erläutert werden, wobei stets die jeweilige Möglichkeit zur Dereferenzierung mitbetrachtet wird.Die Dereferenzierung ist die Methode, um von einer Referenz wieder zurück zur Referenzvariablen zu gelangen. Dies geschieht im Allgemeinen durch das Voranstellen des Symbols, das dem Typen des referenzierten Objekts entspricht, vor den Bezeichner der Referenz (z.B.
$$Referenz bei Skalaren), wobei man der besseren Übersicht wegen den Referenzbezeichner noch innerhalb geschweifter Klammern notieren kann.
Referenzen auf einfache Variablen (Skalare) erzeugen
Das Erzeugen einer Referenz auf einen Skalar erfolgt in der allgemeinen Form:$Referenz = $Skalar, also beispielsweise so:
$string = "Ich bin ein String";
$ref_string = $string;
#Erzeugt Referenz auf Skalar $string
print $ref_string;
#Gibt Speicherort von $string (z.B. SCALAR(0x168271c)) aus
##Dereferenzierung:
$deref_string = ${$ref_string}; #übersichtlichere Variante
#oder:
$deref_string = $$ref_string;
print $deref_string;
#Gibt Wert von $string aus
Referenzen auf Arrays erzeugen
Um eine Referenz auf ein Array zu erzeugen, muss folgende allgemeine Form berücksichtigt werden:$Referenz = @Array. Auf ein einzelnes Element des Arrays greift man mittels Zeiger allgemein so zu:
$Elementinhalt = $Referenz->[Elementindex], wobei - wie im folgenden Beispiel zu erkennen - auch andere Varianten dafür existieren. Die o.g. Form mit Verwendung des einfachen Pfeiloperators (->) sollte jedoch bevorzugt werden, da sie das größtmögliche Maß an Übersichtlichkeit bietet. Das Beispiel:
@array = ("Hallo",12,4);
$ref_array = @array;
#Erzeugt Referenz auf Array @array
print $ref_array;
#Gibt Speicherort von @array (z.B. ARRAY(0x168274c)) aus
##Zugriff auf ein Arrayelement
$ElementInhalt = $ref_array->[1]; #übersichtlichste Variante
#oder:
$ElementInhalt = ${$ref_array}[1];
#oder:
$ElementInhalt = $$ref_array[1];
print $ElementInhalt;
#Gibt Wert des 2. Arrayelements (12) aus
##Dereferenzierung:
@deref_array = @{$ref_array}; #übersichtlichere Variante
#oder:
@deref_array = @$ref_array;
print @deref_array; #Gibt Werte von @array aus
Referenzen auf Hashes erzeugen
Natürlich lassen sich auch Referenzen auf Hashes erzeugen. Dazu benutzt man die allgemeine Form:$Referenz = %Hash. Der Zugriff auf einen einzelnen Hashwert erfolgt auch bei Verwendung von Zeigern mittels des dazugehörigen Schlüssels in der Form: $Elementwert = $Referenz->{"Elementschlüssel"}. Diese Methode gilt dabei wieder als die übersichtlichste. Ein Beispiel:
%hash = (Name => "EName",ID => "EID");
$ref_hash = %hash;
#Erzeugt Referenz auf Hash %hash
print $ref_hash;
#Gibt Speicherort von %hash (z.B. HASH(0x1682728)) aus
##Zugriff auf einen Hashwert
$ElementInhalt = $ref_hash->{"Name"}; #übersichtlichste Variante
#oder:
$ElementInhalt = ${$ref_hash}{"Name"};
#oder:
$ElementInhalt = $$ref_hash{"Name"};
print $ElementInhalt;
#Gibt Wert des Hashelements mit Schlüssel Name (Ename) aus
##Dereferenzierung:
%deref_hash = %{$ref_hash}; #übersichtlichere Variante
#oder:
%deref_hash = %$ref_hash;
print %deref_hash;
#Gibt Schlüssel und Werte von %hash aus
Spezielle Variablen in Perl
Aufgrund der Fülle von speziell vordefinierten Variablen in Perl seien an dieser Stelle lediglich die wichtigsten und am häufigsten benutzten erwähnt. Derartige Variablen stellen beispielsweise Informationen zu aktuellen Perl-Einstellungen oder zum System des Clients bereit, wobei die Werte einiger auch änderbar sind.Einige enthalten auf Nicht-UNIX-Systemen keine oder fragliche Werte.
Die Variable $_
Als eine der wichtigsten dieser Variablen gilt$_. Sie ist prinzipiell eine sehr vielseitige Variable, welche in einer bestimmten Situation vollautomatisch einen speziellen Wert annimmt. Beispielsweise enthält sie in Schleifen (zum Beispiel mit foreach), in der keine andere Laufvariable deklariert ist, den jeweils aktuellen Wert der Schleife (siehe Beispiel 1). Im ersten Beispiel wird noch eine andere Einsatzmöglichkeit von $_ demonstriert. Bei Anwendung von regulären Ausdrücken auf Variablen liefert sie den jeweils aktuellen Wert für die Variable. Des Weiteren ist beim Aufruf einiger bestimmter, vordefinierter Perl-Funktionen die Übergabe eines Parameters nicht erforderlich, wenn der Wert von
$_ standardmäßig an diese Funktion übergeben wird (Beispiel 2).
#Beispiel 1
@array = ("String_1","String_2");
foreach (@array)
{
tr/_/ /;
#Ersetzt im akt. Element von @array "_" durch Leerzeichen
print $_;
#Gibt (veränderten) Wert des akt. Elements von @array aus
}
#Beispiel 2
$string = "String 1";
$_ = $string; #Weist $_ den Wert von $string zu
print; #Gibt Wert von $_ (= Wert von $string) aus
Weitere spezielle Variablen von Wichtigkeit
An dieser Stelle werden einige der vordefinierten Variablen erläutert, welche am häufigsten im Alltag verwendet werden.Zunächst wäre in diesem Zusammenhang die skalare Variable
$ zu nennen, deren Wert angibt, welche Zeichenfolge allen mit der Funktion print ausgegebenen Daten angehängt werden soll:
$ = "<br>n";
#Fügt jeweils ein "<br>" + einen Zeilenvorschub an
for($i=1; $i < 5; $i++)
{
print "Zeile $i"; #gibt z.B. Zeile 1<br>n aus
}
$ = ""; #Setzt Wert von $ zurück
@_ zu erwähnen, welche innerhalb einer Subroutine alle Parameter enthält, mit der sie aufgerufen wurde:
sub subroutine {
print $_[0];
#Gibt erstes Argument (= 1. Element von @_) aus
foreach(@_)
{
print $_; #Gibt alle Argumente aus
}
}
&subroutine("String1","String2","String3");
#Ruft subroutine auf
@ARGV, welches diejenigen Parameter enthält, mit dem das betreffende CGI-Skript aufgerufen wurde:
foreach (@ARGV) {
print $_ , "<br>n";
}
%ENV anzuführen. Es enthält - wie bereits im Verlauf erklärt - die CGI-Umgebungsvariablen, welche beim Aufruf des CGI-Skripts an dieses übergeben wurden. Weitere Informationen zu den Umgebungsvariablen entnehmen Sie bitte dem entsprechenden Abschnitt.
Du arbeitest in einer Agentur oder als Freelancer?
Dann wirf doch mal einen Blick auf unsere Software FeatValue.
Weiterlesen: ⯈ Operatoren
Über uns
Wir entwickeln Webanwendungen mit viel Leidenschaft. Unser Wissen geben wir dabei gerne weiter. Mehr über a coding project