Kontakt aufnehmen
Wir stellen ein: PHP-Entwickler (m/w/d) Key Account Manager (m/w/d)

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

Wie im Beispiel zu erkennen, gibt es für o.g. Zweck zwei Funktionen: 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
Zahlen und Zeichenketten werden in Perl in einfachen Variablen, den so genannten Skalaren, gespeichert. Ein Skalar wird bei seiner Deklaration stets durch ein Dollarzeichen ($) 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

oder:

$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

Durch Einfügen beliebig vieler Unterstriche können große Ganzzahlen strukturell übersichtlich notiert werden:

$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)
Beide Notationen werden unterschiedlich vom Perl-Interpreter bewertet:

$String1 = "Der 1. String";

print 'Ich bin einfacher String namens: $String1'; #Ausgabe1
print "Ich bin einfacher String namens: $String1"; #Ausgabe2

Bei der Ausgabe1 wird nach dem Doppelpunkt "$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 () maskiert werden:

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

Innerhalb eines Strings können beliebig viele Steuerzeichen vorkommen. Folgende sind bekannt:

"       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)

Sollen in einer Zeichenkette auch Zeichenfolgen vorkommen, welche denen der Steuerzeichen entsprechen, aber deren Funktion nicht bewirken sollen, so müssen diese ebenfalls mit einem Backslash () maskiert werden. Letzterer kann natürlich auch in Strings vorkommen. Er muss wiederum nur mit einem Backslash maskiert werden (also so: ).

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

Beispiele:

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

Der Zugriff auf den Wert eines einzelnen Arrayelements erfolgt mittels des Indexschlüssels im skalaren (also mit vorangestelltem $ 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

Bewertet man die Arrayvariable in einem skalaren Kontext, so erhält man die Länge des entsprechenden Arrays:

$LaengeArray = @EinArray;
#Länge d. Arrays @EinArray in $LaengeArray gespeichert

Darüber hinaus kann man den Index des letzten Arrayelements über die reservierte Variable $# 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

Den Beginn der Indizierung eines Arrays kann man mit der vordefinierten Variable $[ (standardwert 0) beeinflussen:

@Array = (0,1,2,3,4);
$[ = 1;
print $Array[3]; #Gibt 2 aus

In diesem Beispiel wird der erste Index des Arrays auf 1 gesetzt. Das hat zur Folge, dass als Wert von $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

Stellt man sich die letzte Anweisung und das Array @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

Die Reihenfolge der Elemente eines Hashes hängt jedoch von der internen Speicherung ab, was das Vorhandensein der Wert/Schlüssel-Paarung begründet. Es gibt daher keine Möglichkeit, die Hashelemente mittels eines Indexschlüssels anzusprechen, so dass die jeweiligen Werte mittels des an diese gekoppelten Schlüssel angesprochen (also damit assoziiert) werden müssen. Dies erfolgt im skalaren Kontext (also mit $ 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

Bei der Vergabe von Schlüsselnamen sind die allgemeinen Regeln für Bezeichnernamen (siehe: Besondere Hinweise zur Syntax) zu beachten.
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

Die Anzahl der Hashpaare lässt sich nicht über die Bewertung des entsprechenden Hashes im skalaren Kontext ermitteln. In Anbetracht des oben erläuterten Sachverhalts muss dies aber offensichtlich durch die skalare Bewertung der entsprechend erzeugten Arrays mit zum Hash gehörigen Schlüsseln/Werten möglich sein:

$LaengeHash = keys(%Land);
#oder:
$LaengeHash = values(%Land);

Hashes zählen zu den bedeutungsvollsten Variablen in Perl. Beispielsweise werden die CGI-Umgebungsvariablen in derartiger Struktur gespeichert.

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 der keys()-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 () vor den Namen des referenzierten Objekts erzeugt werden. Die allgemeine Form:

$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

Des Weiteren ist das spezielle Array @_ 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

Außerdem von großer Wichtigkeit ist das Array @ARGV, welches diejenigen Parameter enthält, mit dem das betreffende CGI-Skript aufgerufen wurde:

foreach (@ARGV) {
  print $_ , "<br>n";
}

Als eines der wichtigsten vordefinierten Hashes in Perl ist das %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.

Weiterlesen: ⯈ Operatoren

Über uns

Stefan Wienströer

Wir entwickeln Webanwendungen mit viel Leidenschaft. Unser Wissen geben wir dabei gerne weiter. Mehr über a coding project

Karriere bei a coding project - Wir freuen uns auf dich!

Alle unsere Stellen sind Remote oder an unseren Standorten in Münster und Wuppertal verfügbar:

// Warum Du Dich für uns entscheiden solltest

  • Regelmäßig neue Projekte, die Du von Grund an mit planen und aufbauen kannst
  • Arbeit in einem wachsenden IT-Unternehmen
  • So viel Home-Office wie Du möchtest - Und einen Arbeitsplatz in unserem Büro in Münster
  • Wöchentliche Vorträge: Jeden Freitag hält ein Mitarbeiter einen Vortrag über ein Fachthema seiner Wahl
Karriere

Cookie-Einstellungen

Helfen Sie dabei, uns noch besser zu machen. Wir nutzen Cookies und ähnliche Technologien, um die Website auf Ihre Bedürfnisse anzupassen. Zur Datenschutzerklärung

Auswahl speichern