Perl-Umgebung

Auskunft und Änderung

Die meisten Programmiersprachen bieten Funktionen, die Informationen über die Umgebung liefern. Diese dienen als Grundlage für die Erstellung professioneller Programme, die unabhängig von der Umgebung laufen sollen.
PerlPerl Scripts für CGI und Systemverwaltung
%ENV Das Hash %ENV bietet alle verfügbaren Umgebungs-Variablen
@ARGV Commandline-Argumente im Array @ARGV
CGI-Argumente An das Programm übergebene Argumente (GET, POST)
Predefined Vordefinierte Perl-Variablen
System Betriebssystem und Pfad-Separator
Umgebungsvariable Umgebungs-Daten mit Perl erzeugen oder ändern
Module Erweiterung der Perl-Funktionalität mit spezialisierten Modulen
Links Ausgewählte Perl Environment Links Links
Verwandte Themen Perl-Arrays und Hashes, Perl @ Win-Registry, Umgebungs-Daten in C/C++, PHP und VBA

%ENV - Ein Hash aller verfügbaren Umgebungs-Variablen

Live-Ausgabe aller Elemente dieses Hash:
Oben das Live-Ergebnis aller am Webserver verfügbaren %ENV-Elemente in einem → HTML-Innenrahmen (iframe) dieser Webseite.

► Anzahl und Namen der verfügbaren %ENV-Elemente unterscheiden sich je nach Betriebssystem und Betriebsart. 		• Perl als → Konsolen Script-Programm liefert normalerweise alle verfügbaren Umgebungs-Variablen des Systems.

• Perl als → Webserver-Hilfsprogramm (CGI) liefert nur eine begrente Auswahl der System-Variablen, dafür zusätzlich einige Umgebungs-Variable des Webservers.
Das Script-Beispiel auf der rechten Seite gibt alle verfügbaren Elemente des Hash %ENV aus:
In einer foreach-Schleife werden alle Elemente des Hash %ENV in je einer eigenen Zeile ausgegeben.
foreach $k (keys(%ENV)) {
print"\$ENV{$k} = ".$ENV{$k}."\n";
}
Das Beispiel rechts zeigt, wie man einzelne $ENV-Elemente namentlich adressiert.
► Zur Absicherung wird vor Verwendung eines %ENV-Elements getestet, ob es überhaupt existiert. Falls nicht, sollte das Perl-Programm einen Standardwert (hier "Unbekannt") einsetzen.
if ( exists($ENV{'SCRIPT_NAME'}) ) {
$mynam = $ENV{'SCRIPT_NAME'};
}
else { $mynam='Unbekannt'; }
print "mynam = $mynam \n";
♣ Hinweis: Art und Anzahl der Elemente von %ENV hängen von der Art des Aufrufs ab: Ein Perl Script-Programm wird z.B. typisch manuell an einer Shell-Konsole aufgerufen, oder von einem Webserver, in letzterem Fall als CGI-Programm oder als Apache-Perl-Modul. In jedem Fall erhält man (am gleichen PC) andere Umgebungs-Variable ! • An einem → Apache Webserver kann man mit der Konfigurations-Anweisung PassEnv (Apache-Modul env ) Umgebungs-Variablen an die vom Webserver gestarteten Programme weitergeben, mit Anweisung SetEnv beliebige Umgebungs-Variable setzen.

Commandline - Argumente (Parameter)
Wenn Perl auf ihrem eigenen PC oder Server läuft, dann können sie das Interpreter-Programm auf der → Konsole (Shell, command.exe) starten. Die auf jedem System verfügbare Umgebungs-Variable path sollte den Pfad zum Perl-Interpreter enthalten (Konfiguration auf → Windows) !

Eine Auswahl wichtiger 'command switches':
Hilfe -h zeigt eine hilfreiche Liste von switches & options an.
Version -v zeigt die installierte Version an.
Konfiguration -V zeigt die Konfiguration an, die verwendeten libraries und patches, sowie alle Elemente von Array @INC (s.u.).
Ausführen (execute) -e führt ein nachfolgendes Perl-Miniprogramm aus. Achten sie auf die unterschiedliche Syntax des 'Programms' je nach Betriebssystem. 		Perl auf der Linux-Konsole (Shell)
# perl -h
# perl -v
# perl -V
# perl -e 'print "Hallo\n" '

Perl auf der Windows-Konsole:
C:\> perl -h
C:\> perl -v
C:\> perl -V
C:\> perl -e "print \"Hallo\n\" "
Um auf der Konsole ein Perl-Scriptprogramm auszuführen, geben sie lediglich den Namen der Script-Datei (hier test.pl) ein. Auf Windows kann es notwendig sein (je nach → Konfiguration), den Namen des Interpreter-Programms (perl) voranzustellen.
Bei Verwendung als → Konsolen-Script ist es möglich, Argumente an das Perl-Script zu übergeben.
Im Beispiel rechts wird jeweils das Script test.pl aufgerufen, zuerst ohne Argument, danach mit je 2 Argumenten "abc" und "123".
Sämtliche Argumente werden als Zeichenketten (Strings) an das Programm übergeben. 		Linux:
# test.pl
# test.pl abc 123

Windows:
C:\> perl test.pl
C:\> perl test.pl abc 123
Im vordefinierten Array @ARGV sind die übergebenen Argumente für das Programm verfügbar:
Mit $#ARGV erhält man den letzten Index des Arrays ( = Anzahl der Argumente -1 ). Anschliessend wird die Liste aller übergebenen Argumente ausgegeben.
Unterschied zur Programmiersprache C++: $ARGV[0] enthält bereits das erste Argument, nicht den Dateinamen. Dieser ist in der vordefinierten Variablen $0 (s.u.) enthalten.
♦ Details im Kapitel Arrays und dazu in der Original Perl-Referenz unter perlvar. 		Ausgabe der Argumente-Liste:
$na = $#ARGV + 1;
print "Anzahl Argumente = $na\n";
$i=0;
foreach $arg (@ARGV) {
print "\$ARGV[$i] = $arg\n";
$i++;
}
Diesen Code kann man verwenden, um ein Commandline-Argument an eine Variable (hier $wert ) zu übergeben. Falls das Argument nicht übergeben wurde, wird ein Standardwert (default) verwendet.
♣ Hinweis: Verwenden sie die Namen $a und $b nicht für eigene Variablen, sie sind für das Sortieren von → Arrays vordefiniert. 		Argument oder Standard-Wert verwenden:
$wert = $ARGV[0] || 'Standardwert';

Perl-Probleme auf Windows

Die → Installation von Perl auf Windows ist zwar einfach, die genaue Abstimmung des Betriebssystems erfordert jedoch einige Sorgfalt. Perl-Programme wie z.B. c:\test.pl müssen sich in der Kurzform starten lassen:
C:\> test abc 987
Im Programm selbst sind die Commandline-Argumente als Elemente des Array @ARGV verfügbar:
$ARGV[0]="abc"
$ARGV[1]="987"
Wenn die Kurzform nicht funktioniert, probieren sie die Lang-Version
C:\> c:\Programme\perl\bin\perl.exe c:\test.pl abc 987
mit vollständiger Angabe aller Pfade. Wenn nur die Langform funktioniert, oder wenn auch dort keine Argumente an das Perl-Programm übergeben werden, dann muss Windows besser abgestimmt werden.

♦ Details zur Installation und Konfiguration von Perl auf Windows

CGI - Argumente (Parameter)
Wenn ein Perl-Script dazu verwendet wird, eine dynamische Webseite (→ CGI) zu erzeugen, dann werden von der aufrufenden Webseite meist Argumente (Parameter) zur Steuerung des Scripts übergeben. Diese Argumente können unterschiedlich erzeugt werden, z.B. durch Absenden eines HTML-Formulars, durch Anklicken eines speziell formatierten Links oder frei programmiert mit Javascript. Die Argumente werden stets als Texte in der Form name=wert übergeben.
Für den Transport stehen die beiden Methoden GET und POST zur Verfügung.
♦ Details zu CGI-Programmen.
Beispiel für die Übergabe von Argumenten an ein Perl-Script:
Dieser HTML-Quelltext erzeugt auf der Webseite ein Formular mit 2 Eingabe-Feldern und einem Button 'Absenden'.
Beim Klicken von 'Absenden' wird das im action-Attribut genannte Programm aufgerufen (hier: demo.pl).

Die übergebenen Daten werden in Form eines speziell codierten QUERYSTRING übertragen. 		HTML-Formular:
<form name="form1" method="post" action="/cgi-bin/demo.pl">
<input type="text" name="txt"> Text<br />
<input type="text" name="zal"> Zahl<br />
<input type="submit" name="submit" value="Absenden">
</form>
Zur Decodierung der empfangenen Argumente wird am besten das Perl-Modul CGI verwendet. Der gezeigte Code arbeitet unabhängig von der Methode (GET, POST).
Mit new erzeugen sie eine neue CGI-Instanz, hier mit dem Namen $mycgi.
Mit der Methode param sind die übergebenen Argumente zugänglich. Alle Argumente werden als Text übergeben, sie werden z.B. durch Addition von 0 in eine Zahl umgewandelt.
Vergessen sie nicht, vor der Argument-Zuweisung einen Standardwert für die jeweilige Variable zu definieren - Dieser wird verwendet, wenn der entsprechende Parameter nicht übergeben wurde.
♦ Details in der Perl-Referenz unter Modules | CGI 		Perl - Decodierung der CGI-Parameter
use CGI;
my $mycgi = new CGI;

my $txt="";
$txt = $mycgi->param('txt');
print "txt = $txt<br />\n";

my $zal=0;
$zal = $mycgi->param('zal')+0;
print "zal = $zal<br />\n";
Alternativ kann man auch ohne das Perl-Modul CGI arbeiten:
Das Hash %ENV (s.o.) enthält sowohl die verwendete Methode als auch den Original codierten QUERY_STRING.
In diesem Fall muss man den QUERY_STRING selbst decodieren, um zu den übergebenen Variablen zu gelangen. Dieser Aufwand ist nur in Sonderfällen sinnvoll.
$met = $ENV{'REQUEST_METHOD'};
print "CGI-Methode=$met<br />\n";
$qs = $ENV{'QUERY_STRING'};
print "Querystring=$qs<br />\n";

Vordefinierte Perl-Variablen
Perl verwendet einige Variablen mit fix vordefinierten Namen. Die beiden Arrays @ARGV und @INC werden ↑ oben beschrieben, einige Variablen für Reguläre Ausdrücke mit dem Thema → RegExp.
Nachfolgend eine Auswahl weiterer vordefinierter Variabler mit deren Kurz- und Lang-Namen.
Die angeführten Variablen-Namen sind nicht in allen Versionen verfügbar. Insbesondere die LangNamen laufen aus.

$^T enthält die Zeit beim Start des Scripts als Unix-Timestamp. Zur Umwandlung in einen ISO-8601-String benötigen sie Modul POSIX
$^X enthält den Pfad zum Perl-Interpreter-Programm
$! enthält die letzte aufgetretene Fehlermeldung
$^] enthält die aktuelle Perl-Version als String
$^V enthält die aktuelle Perl-Version als 3-Byte BinärString.
$0 (Null) enthält (je nach Aufruf !) den Dateinamen des Programms oder seinen kompletten Pfad.
$. enthält die letzte Zeilen-Nr aus dem Input-Stream
(Zeilen-Nr des Perl-Scripts ist offenbar nicht verfügbar !)
$$ gibt die PID-Nr. des Programms zurück (→ Child-Prozesse)
Die Funktion getppid liefert die PID-Nr. des Parent-Programms (= meist der Shell-Konsole).

Live-Daten von Perl-Version und OS finden sie in der ↑ Liste oben.
$v = $^T;
print "BaseTime = \$^T = $v";
use POSIX;
$v = strftime("%Y-%m-%d %X",localtime($v));
print " = $v\n";
print "ExecutableName = \$^X = $^X \n";
print "InputLineNr = \$. = $. \n";
print "OS-Error = \$! = $! \n";
print "OS-Name = \$^O = $^O \n";
print "Perl-Version = \$^] = $^] \n";
print "Version (Linux) \$^V = ".unpack("H*",$^V)." \n";
print "Version (Windows) \$^V = $^V \n";
print "ProcessID = \$PID = \$\$ = $$ \n";
print "ProgramName = \$0 = $0 \n";
print 'ParentID = '.getppid()."\n";

User-ID-Nummern

Diese vordefinierten Variablen liefern die ID-Nummern des Programm-Users und seine Gruppe(n). Sie funktionieren auf Windows nicht.
• Die 'realen' Daten beziehen sich auf die Anmeldung (Login). Linux-User können mit den Konsolen-Befehl su oder sudo die Identität wechseln und verfügen dann über 'effektiv' andere Rechte (z.B. als Administrator root).
• Die Gruppen-ID liefert eine Liste mit den ID-Nummern aller Gruppen, welchen der User angehört.
• Mit Hilfe dieser Variablen kann man den Ablauf eines Programms an die Person oder an die Rechte des jeweiligen Users anpassen.
print "RealUserID = \$UID = \$\< = $<\n";
print "EffectiveUserID = \$EUID = \$\> = $>\n";
print "RealGroupID = $GID = \$( = $(\n";
print "EffectiveGroupID = \$EGID = \$) = $)\n";

User-Daten

• Die Perl-Funktionen getlogin, getpgrp, getpwnam, getpwuid, getpwent, getgrnam, getgrgid, getgrent, ... liefern eine ganze Reihe von Daten zu den ID-Nummen. Das reicht für harmlose Zwecke, ist jedoch für eine echte Identifikation nicht sicher genug.
Details im Original Perl-Manual.
Das damit erhaltene Passwort ist natürlich codiert. Allerdings ist ein Vergleich möglich: Man kann z.B. feststellen, ob ein User sein Anfangs-Passwort geändert hat. 		Funktion getpwuid liefert ein Array von User-Daten:
my @ua = getpwuid($<);
$name = $ua[0];
$passwd = $ua[1];
$uid = $ua[2];
$gid = $ua[3];
$quota = $ua[4];
$comment = $ua[5];
$gcos = $ua[6];
$dir = $ua[7];
$shell = $ua[8];
$expire = $ua[0];
Bei Verwendung von Perl-Scripts als Konsolen-Programme:
Die Optionen -h, -v und -V bieten einige wertvolle Information über die verwendete Perl-Version. 		Beispiele (Linux, Win):
# perl -v
C:\> c:\programme\perl\bin\perl -V
Weitere spezielle Variable:
$/ definiert das Trennzeichen für Eingabe-Strings (z.B. beim → Lesen von Text-Dateien).

$_ enthält stets das Ergebnis der letzten Wert-Zuweisung an eine Variable. Das macht solche Programme möglich:
for(1..3) {print "$_ ";} # 1 2 3

Das → Array @_ enthält alle Argumente, welche an ein sub (Unterprogramm) übergeben wurden. 		$# bezeichnet den letzten Index eines Arrays, z.B. $#z den letzten Index des Arrays @z. Das letzte Element dieses Arrays erhalten sie mit $z[-1].
► Vorsicht mit $a und $b
Variable mit diesen Namen lassen sich zwar erzeugen, sie sind jedoch für das → Sortieren von Arrays reserviert. Verwenden sie besser andere Namen.
♦ Details dazu in der Original Perl-Referenz unter perlvar

Script-Dateiname und Pfad:

Die vordefinierte Variable $0 (Dollar-Null) liefert den Pfad zur eigenen Script-Datei.
► Das Verhalten ist leider nicht einheitlich:
Wenn der aktuelle Pfad ( cwd current working directory) genau zum laufenden Script führt, dann wird der relative Pfad ausgegeben - Er besteht in diesem Falle nur aus dem Dateinamen, z.B. test.pl
► Eine Alternative bietet das Hash %ENV:
$ENV{'SCRIPT_FILENAME'} = absoluter Pfad zur Datei
(siehe Innenrahmen oben auf dieser Seite).
Wenn der aktuelle Pfad cwd nicht zum laufenden Script führt, dann wird der absolute Pfad ausgegeben, z.B. c:\test\test.pl
► Bei Verwendung an der (Shell)-Konsole ist meist auch das Element $ENV{'_'} definiert, welches ebenfalls den Pfad zum Script-Programm angibt.
Die Umgebungs-Variable $ENV{'PWD'} (Program working directory) gibt das aktuelle Arbeits-Verzeichnis an. Alle relativen Pfade beginnen dort. Auf Linux ist diese Variable immer verfügbar, auf Windows erst nach Anwendung von getcwd
Funktion getcwd aus dem → Modul Cwd gibt den aktuellen Pfad ( cwd current working directory) zurück:
use Cwd;
print 'cwd = '.getcwd()."\n";


• Die globale Konstante __PACKAGE__ gibt das aktuelle Modul an, im 'Hauptprogramm z.B. den Wert main

Zeilen-Nummer

Zum Debuggen ist es praktisch, die aktuelle Zeilen-Nummer des Script-Programms anzugeben. Dazu dienen die Perl-Funktionen warn (setzt das Programm fort) und die (beendet das Programm). Beide Funktionen geben den eingetragenen Text, die Datei und die Zeile aus. Der Text kann - wie bei der Funktion print beliebige Daten (Variable...) enthalten, sollte jedoch nicht mit \n enden.
$debug = 1;
# ...Debug Message
if($debug) {warn 'Trace';}
# ...Stop here
die 'Abbruch';

Hostname

Das Modul Sys bietet die Möglichkeit, den Namen des Host-PC 'auf jedem denkbaren Weg' zu ermitteln.
(siehe Innenrahmen oben auf dieser Seite). 		Anwendung:
use Sys::Hostname;
$hn = hostname;

Betriebssystem
Die vordefinierte Variable $^O (Großbuchstabe O) liefert das aktuelle Betriebssystem
Typische Werte: Linux oder MSWin32
Im Beispiel werden erkannte Daten in lin oder win umgewandelt.
$mysys = $^O;
if($mysys=~m/lin/i) {$mysys='lin';}
elsif($mysys=~m/mswin/i) {$mysys='win';}
Die Umgebungs-Variable PATH wird in allen gängigen Betriebssystemen unterstützt. Man kann sie mit → Regulären Ausdrücken analysieren - Allerdings gibt es keine Garantie, dass die folgenden Indizien immer zutreffen:
• Nur M$-Systeme enthalten den String "Windows" oder "WINDOWS" im PATH
• Nur M$-Systeme enthalten Backslash-\-Zeichen als Pfad-Trennzeichen, alle anderen Systeme das Standard-Zeichen /
• Nur M$-Systeme enthalten im PATH Volume-Buchstaben mit Doppelpunkten wie C: oder D: 		Umgebungs-Variable PATH
$test = $ENV{'PATH'};
print "$test\n";
if($test=~m/windows/i) {
print "Windows ?\n";
}
else {print "Linux ?\n";}
M$-Systeme enthalten immer die Umgebungs-Variable WINDIR
Sie enthält einen Pfad mit den gleichen typischen Indizien wie PATH. 		Existenz einer Umgebungs-Variablen WINDIR
if(exists($ENV{'WINDIR'})) {...}
else {...}
Perl bietet die Möglichkeit, Pfade in jedem Fall mit dem Standard-Trennzeichen / zu formulieren. Perl sorgt dafür, dass derartige Pfade auch auf Win-Systemen sinngemäß richtig angewendet werden !
Dadurch wird es erleichtert, System-unabhängige Script-Programme zu erstellen.
# Linux:
$path='/home/test/test.pl';
# Windows:
$path='c:/test/test.pl';

Erzeugung und Änderung von Umgebungs-Variablen
Mit Perl lassen sich die Umgebungs-Variablen des Betriebssystems ändern oder neue erzeugen.
Dazu werden Zugriffs-Rechte auf den eigenen PC benötigt, daher werden solche Programme nur als → Konsolen-Scripts verwendet. 		Das kann insbesondere für Windows sinnvoll sein, da dort viele wichtige Informationen in der Registry-Datenbank liegen, und diese für 'normale' Programme schwierig oder gar nicht erreichbar sind.
♦ Details dazu auf der Seite Perl @ Win-Registry

Perl-Module
Wie alle modernen Programmiersprachen ist Perl modular aufgebaut. Die Grund-Version enthält (nur) die allgemein verwendeten Teile der Sprache.

Zu Perl gibt es eine besonders große Menge spezialisierter Module. Die Module sind meist kostenfrei im Internet verfügbar und erweitern die Funktionalität von Perl.
♦ Details zu Perl-Modulen

Dokumentation

Eine Besonderheit ist die umfassende modulare Dokumentation.
Jedes Modul installiert auch seine eigene Dokumentation !

Perl Environment Links Ausgewählte Links zum Thema 'Perl-Umgebung'

Die kostenfreie Perl-Distribution von ActiveState enthält ein komplettes Manual in Form von Webseiten. Die Verwendung ist allerdings etwas gewöhnungs-bedürftig.
Soweit möglich, finden sie hier Hinweise auf das zutreffende Kapitel. 		Das komplette Manual der jeweils neuesten Perl-Version ist auch online bei ActiveState verfügbar. Einige Links dieser Seite führen dorthin - Die online-Adressen ändern sich jedoch gelegentlich ! - Wenn ein Link von dieser Seite nicht zum Ziel führt, dann öffnen sie das online-Manual und verzweigen sie selbst zum gewünschten Kapitel.

Zum Inhaltsverzeichnis Homepage von PS-Trainer   >   Entwicklung   >   Perl   >   Umgebung