orm@doc-tcpip.org

Erstellt: Februar 2005 - Letzte Modifikation: Dezember 2005

[ Main | Local ]


Perlprogrammierung

Spickzettel

/usr/bin/perl -w  ==> gibt Fehlermeldungen aus.
; Schließt Befehlszeilen ab.
, Trennt Elemente einer Liste, die in runden Klammern aufgezählt werden.
(xx,yy,zz) Beispiel einer Liste.
() enthält auch Konditionen in entsprechenden Statements wie if, unless, elseif, else
oder bei Schleifen wie for und while.
{} beinhalten die Befehlsblöcke wie Subroutinen, Konditionen, Schleifen. In so einem
Block werden keine Semikolen gesetzt...
<> Umleitung von Input und Output auf ein Filehandle, die Konsole, STDIN etc.
 nimmt Eingabe von der Konsole.

3, 6, ... Integer
5.45      Floating Point
9.8E-13   Exponent, 10 hoch bla
0x3DA45   Hex Darstellung
0677      Führende Null ==> Oktal Darstellung
0b0011101 Binärzahl

$var Skalarvariable
@array 
Eine Tabelle mit Skalaren bzw. Skalarvariablen
@gps = (garmin, magellan, lowrance, $eigenbau)
Will man auf einen Eintrag im Array (in der Tabelle)
referenzieren, so ist das eine Variable, wird also mit $ eingeleitet.
$i = $gps[3]
Zuordnung geht natürlich auch so ...
Man kann auch mit Listen zugreifen:
($i, $ii) = @gps würde die Elemente 0 und 1 zurückgeben.
Und man kann einen Array auch leer initialisieren:
@array=();

delete @array[2]   Löscht Element 2
exists @array      Gibt es den Array? False, wenn leer.
$x = pop @array    Das letzte Element vom Array nehmen
push @array, (bla, blu, ble)  Die Liste am Ende des Array anhängen
reverse @array     Array umdrehen
$x = shift @array  Das erste Element vom Array nehmen
split @array, Offset, Länge, (bla, blu, ble) Aus dem Array werden ab Offset Länge Elemnte entfernt 
und ersetzt durch die Liste.
unshift @array, Liste  Fügt die Elemente in der Liste an den Anfang des Array ein.

%hash
Bei einer gehashten Liste/Tabelle wird jedem Element ein Schlüssel zugeorndet,
unter dem man den in der Variable hinterlegten String abfragen kann:
$gps{gar}='Garmin';
Die Initialisierung kann als leerer Hash erfolgen:
%gar=();
oder als zuweisung von Element und Schlüssel:
%gar=(gar, garmin, mag, magellan, low, lowrance, eig, $eigenbau ); 
oder
%gar=(gar => garmin, mag => magellan , low => lowrance , eig => $eigenbau );
Man kann jetzt Variablen einen Wert zuweisen, den man über einen Schlüssel
referenziert:
$i = %gar{mag}; 


Zuweisung mit =  ==> $Trottel='Mr. DevNull'
Man kann auch mit einer Liste zuweisen:
($pers1, $pers2, $pers3) = (ich, du, er);

Die Interpretation von Arrays und Variablen erfolgt immer im Kontext
(skalarer oder listen Kontext):
$x = @array Interpretiert @array im skalaren Kontext, gibt also die Zahl der
Element aus.
($x) = @array Interpretiert im Listen-Kontext und gibt ein Element aus.

Rechnen:
$x += $y ==> $x = $x + $y
Analog: -, *, /, ** (Potenz), % (Modulo).
& (bitweises AND), | (bitweises OR), ^ (bitweises XOR)
Shift: $x wird um $y Bits nach links oder rechts verschoben:
$x >>= $y
Logisches AND bzw. OR:
$x &&= $y ==> $x = $x && $y
Analog ||
Beispiel:
$x = $y - 10 * $z
Invers: $x=($y)^(-1)

Man kann auch Strings aneinander hängen:
$x .= $y ==> $x = $x . $y
Oder beliebig wiederholen:
$x x=$y ==> String in x wird y mal wiederholt nach x geschrieben.
Operatoren sind dabei . und x.

Operatoren zum Rechnen:
+, -, *, /, ** (Potenz), % (Modulo), ++ (Autoinkrment), -- (Autodekrement),
Ansonsten normale Anwendung von Klammerregeln etc.

Operatoren, um Bits zu bearbeiten:
&, |, ^, >>, <<
&: Bitweise AND - aus der Kombination von:
0 0 ==> 0
1 1 ==> 1
0 1 ==> 0
1 0 ==> 0
|: Bitweise OR - aus der Kombination von:
0 0 ==> 0
1 1 ==> 1
0 1 ==> 1
1 0 ==> 1
^: Bitweise XOR - aus der Kombination von:
0 0 ==> 0
1 1 ==> 0
0 1 ==> 1
1 0 ==> 1

Mit << und >> kann man bitweise erhöhen und erniedrigen.

Operatoren zum testen von Files:
-e	Existiert das File?
-d	Ist es ein Verzeichnis?
-l	Ist es ein symbolischer Link?
-T	Ist das File ein TExtfile?
-B	Ist das File Binär?
-f	Ist es ein Textfile ohne Format?

-z	Hat das File genau 0 Byte?
-s	Ist es größer als 0 Byte?

-r	Ist das File lesbar?
-w	Ist das File schreibar?
-x	Ist das File ausführbar?

-o	Gehört das File dem eigenen User?
-t	Der Filehandle hängt an einem Terminal

-M	Zeit seit der letzten modifikation des Files
-A	Zeit seit letztem File-Zugriff
-C	Zeit seit letzter Inode Änderung

Logische Operatoren:
== (logisch identisch), true (ungleich Null, nicht leer), false (gleich Null,
leer), not (Ausführen, wenn die Kondition nicht erfüllt wird), and (Ausführen,
wenn zwei Bedingungen zutreffen), or (Ausführen, wenn eine von zwei Bedingungen
zutreffen), xor (Ausführen, wenn nur eine der beiden Bedingungen zutrifft), 
! (not, nicht), && (and), || (or), ^^ (xor).

Multiplikatoren:
Für alle Arten von Suchmustern oder Ersetzungen:
/g{4,8}/ ==> min. 4 mal das "g", höchstens 8 mal "g".
/g{4,}/ ==> min. 4 mal das "g", beliebige weitere.
/g{4}/ ==> genau 4 mal "g".

Z.b. /g.{3}e/ ==> "g" und "e" mit genau 3 Zeichen dazwischen.

"Klassische" Entsprechung:
* == {0,}
+ == {1,}
? == {0,1}

$_ ==> letzte aktive Variable

Einen Wert direkt auf eine Routine legen, ohne sie in einer Variable
zu Speichern: 
Geschieht mit "=~", hier ein Beispiel:

if ( =~ /^ja/i) {
    print "Dann los...";
}

if ($var =~ /^\var\/spool/) {
    ........
}

Der m-Operator erlaubt das nutzen mehrer Trennzeichen:
m#^/var/spool# 

$& ==> Das, was man sucht
$` ==> Das, was vor der Suchmuster steht
$´ ==> Das, was nach der Suchmuster steht

/ORM/, String gaargORMgurur ==> $& == ORM, $` == gaarg, $´ == gurur

$_ = "ich bin doof"
s/(\w+)/<$1>/g;
==>   



open (FH, $file) or die "File $file kann nicht geöffnet werden";
if (open (FH, $file)) {print "File $file geöffnet";}
else {print " File $file kann nicht geöffnet werden";}
@DATEN = ; Wie durch Zauberhand wird jede Zeile des Files in ein Arrayfeld geschrieben.
close FH; Das File wieder zumachen...
 ist die Tastatur, und muß auch nicht geschlossen werden.
$EINGABE = ; Erwartet eine Eingabe.
Setzt man <> (oder ), und ruft das Skript mit Filenamen auf, so werden diese Files
geöffnet und eingelesen.
@INHALT = <>;

Ausgaben mit print gehen per Default nach STDOUT.
print @WERTE; (Alle Einträge werden ohne Leerstelle aneineander geklatscht.
print "@WERTE"; (Alle einträge mit einem Leerzeichen aneinander gereiht).

Das kann man umleiten:
open (FH, ">$file"); Öffnet ein File zum Schreiben.
print FH "@WERTE";

Wie in C kann man printf (erwartet ein Format), sprintf (nur formatieren, nicht ausgeben).
format und write geben ganze Bildschirme aus.
 
STDERR Default Filedescriptor für Error meldungen.
Man kann Standard Error wie mit dem tee kommando zusätzlich in ein File schreiben:
open MEINERROR, ">&STDERR"; Dem tee Kommando entspricht >&.

chdir $x Wechselt in das Verzeichnis $x
chmod u+x (file1, file2, file3)
chown UID,GID, (file1, file2, file3)
close FH
closedir DH
opendir DH, $x 
print FH (liste) Schreibt die Lsite nach FH
printf FH Mein_format (Liste)
readdir DH  Listet alle Files im Direktory
rename alt,neu
seek FH, offset, wo    Der FH wird an der Position "offset" gesetzt. Mit "wo" kann man
deas beeinflußen: 0 setzt genau am Offset, mit 1 wird der offset zur aktuellen Position
zugezählt, mit 2 wird der offset vom Ende des Files gerechnet.
stat (FH oder File) Informationen zum File bzw. FH.
tell FH   Gibt die aktuelle Position im File
unlink (file1, file2) Löscht die Files
write FH   Ein formatiertes Ergebnis wird nach FH geschrieben. 


$x =~ /ORM/ wahr (True), wenn ORM im String vorkommt
Negation mit !=
$x =~ s/ORM/ARM/ Substitution
$x =~ tr/IBM/HAL/ Ersetzt alle I mit einem H, alle B mit einem A, alle M mit einem L...
Modifier:
s/ORM/ARM/g ==> global, alle Instanzen in einem String
s/ORM/ARM/i ==> case insensitiv
s/ORM$/ARM/m ==> m zeigt folgenden Zeilenumbruch an
s/ORM/ARM/x ==> Alle Leerzeichen ignorieren
s/ORM/ARM/o ==> nur einmal Ausführen (wenn Variablen im Muster stehen)
s/ORM/ARM/s ==> nur am Anfang der Zeile suchen

Programmsteuerung

while(Kondition){Anweisungen}

for(Initialisierung; Kondition; Reinitialisierung){Anweisungen}
for($i=13; $i; $i--) {print $x, " danach kommt:\n";}
for ($x=1; $x <= 1024; $x++)

for VARIABLE (Liste) {Anweisungen}
do {Anweisungen} while (Kondition)
do {Anweisungen} until (Kondition)

foreach VARIABLE (Liste) {Anweisungen}
foreach (@array) {print "$_\n";}

die (Fehlermeldung) Endet das Programm, und gibt Fehler aus)
exec Pfad/programm (Übergabewerte) Ruft ein externes Programm auf und beendet.
exit mein_rueckgabe Endet mit dem Return-Wert "mein_rueckgabe"
goto hier_her Springt zum Label "hier_her"
last          Springt in die nächsthörere Schleife (man kann einen Label angeben)
next          "              folgende
redo          Macht die Schleife nochmal, prüft die Kondition aber nicht.
my $Variablen Diese Variablen gelten nur in diesem Befehlsblock
return bla    Gibt bla zurück

sub meine_subroutine { Befehle }
system Pfad/Befehl (Argument) Ausführen des externen Programmes

undef $x     Man kann $x jetzt neu belegen.
use ein_modul

Strings
chomp $x  Entfernt Newline Characters von einem String.
chomp ($x $y)  von einer Liste von Strings.
chop $x   Entfernt letztes Zeichen von einem String
chop ($x $y) wie vor.

defined $x  Gibt es diese Variable? Wenn ja, true.
index $x, mein_text    Gibt die Position des Auftretens von mein_text an. 
rindex $x, mein_text   Gibt die Position des letzten Auftretens von mein_text an.
$x = pos $y Gibt die Position des ersten Zeichens nach einem gesuchten String aus
(Vorher mit /../)
(zählt ab 0... Will man den Start des Strings: - length($&) )
($& ist das, was man wirklich gesucht hat)
$x = join Gerät, (gar, magellan, lowrance) Schreibt die Elemente der Liste
getrennt durch meinen Text (Gerät).
$x = lc $y Wandelt in Kleinbuchstaben um.
(Nur das erste Zeichen in Kleinbuchstaben mit lcfirst)
$x = uc $y Wandelt in Grossbuchsatben um.
(Nur das erste Zeichen mit ucfirst)

$x = length $y Ermittelt die Anzahl der Zeichen im String $y und schreibt die Zahl nach $x.
reverse $x   Umdrehen des Strings in $x
 
split /Muster/, $x  Erzeugt eine Liste mit den Schnittstücken nach und vor "Muster"
@array = split /./, $x; Der Punkt ist "jedes Zeichen", der String wird also zerstückelt und in ein
Array gelegt.
Man kann so z.B. ein File im CSV Format zerlegen - hier werden die Felder durch Kommas getrennt:
@array = split (/,/, $line);
Kommen in der Eingabe doppelte Kommas vor, so wird ein leeres Feld in den Array geschrieben. Wenn das
nicht gewünscht ist, so muß man alle Kommas erfassen:
@array = split (/,+/, $line);
Per Standard wird immer $_, also die letzte aktuelle Variable, zerlegt - und zwar mit Leerzeichen als 
Trenner:
split (/ /, $x) Splittet nach jedem Leerzeichen.
split (/ +/, $x) Splittet nach jeder Folge von Leerzeichen.
split (/\s+/, $_) Splittet nach jeder Folge von Leerzeichen in der letzten aktuellen Variable - die 
Standard-Einstellung.

Mit join dreht man split wieder um; man gibt an, mit welchem Trenner man gerne trennen möchte:
$ausgabe = join(";", @eingabe);

sprintf MEIN_FORMAT, (gar, magellan, lowrance) In MEIN_FORMAT habe ich eine Formatierung definiert, 
und der Sting wird jetzt entsprechend formatiert und übergeben.

substr $x, Offset, Länge, Ersatz Geht an die Position Offset, nimmt einen String der Länge Länge und ersetzt
ihn mit Ersatz.

truncate $x, length  Kürzt auf die angegebene Länge

Mathematik
$x = cos $y
Analog: sin, sqrt, log,  exp (e hoch $y), int (Ganzzahliger Anteil), srand (Random Number Seed),
 rand (Zufallszahl zwischen 1 und $b), hex (hex => dez), oct (oct => dez)

Spezielle Funktionen
gmtime Zeitausgabe von GMT
localtime Zeitausgabe der Lokalen Zeit
 
Man kann Modul-Files einbinden. Diese enthalten Funktionen. Haben die Endung .pm
Mit "use" liest man die Module ein.
Mit "use lib 'pfad/file';" legt man den Ordner für die Module fest.
Kommt direkt nach der Perl-Anweisung.

Subroutinen:
sub Meine_sub {Befehle}
Aufruf:
Meine_sub (argumente, argumente)
Die Argumente werden in die spezielle Variable @_ geschrieben.

Man kann so Argumente in Variabeln packen, die nur in der Sub-Routine
gelten:
my($var, $var2) = @_

Will man nicht immer den my Befehl benutzten, muß "use strict;" gesetzt werden.

return $erbegnis;

Man kann einer Subroutine Arrays übergeben:
meine_sub (\@array1, \@array2);
Diese übergibt man dann lokalen Variablen:
my($x; $y) = @_
Ansprechend eines solchen Arrays ist ein wenig speziell:
$var = @$x;   Damit die Subroutine merkt, daß es ein Array ist...
(Für skalare Variabeln $$x, für Hashes #$x)
Wenn man Variabeln referenziert, dann werden diese Verändert...
Daher kopien anfertigen:
my(@x_kopie) = @$x;

Beispiele:

Mit while (<>) liest man das ganze File ein, als einen String.
Mit $/ kann man ein Trennzeichen definieren, und an dieser 
Stelle wird der String zerlegt. Hier wird weitergesprungen, wenn 
keine Zahl mit einem Prozentzeichen im String gefunden wird.
Dann wird nicht der String, sondern das gematched Muster ausgegeben
(das macht $&, die Variable für das gesuchte Muster).
!/usr/bin/perl
$ausgabe = "";
$/ = ".\n";
while (<>) {
next if !m/[0-9]*%/;
$ausgabe = $&;
print "Das kommt raus: $ausgabe \n";
}
Eine Variante:
#!/usr/bin/perl
$ausgabe = "";
$/ = ".\n";
while (<>) {
if ($input = m/[0-9]*%/) {
$ausgabe = $&;
#$ausgabe =~ m/[0-9]*%/;
print "Das kommt raus: $ausgabe \n";
}
}


Ein File Einlesen, und eine Reihe Veränderungen daran durchführen;
z.B. um es für HTML vorzubereiten oder ähnliches:
undef $/;
$text = <>;
# & ==> &
$text =~ s/&/&/g;
# < ==> <
$text =~ s/ ==> >
$text =~ s/>/>/g;
# Alle Leerzeilen in Absätze verwandeln.
$text =~ s/^\s*$/

/mg; print $text;


[ Main | Local ]

[ Allgemein | UNIX | AIX | TCP-IP | TCP | ROUTING | DNS | NTP | NFS | FreeBSD | Linux | SMTP | Tracing | GPS ]

Copyright 2001-2014 by Orm Hager - Es gilt die GPL
Feedback bitte an: Orm Hager (orm@doc-tcpip.org )