Die Programmiersprache Perl - Keepcoding

Die Programmiersprache Perl
Diese Zusammenfassung ist nicht für blutige Anfänger gedacht, sondern eher als eine Art Stütze für jene, die sich bereits
etwas mit Perl vertraut gemacht haben. Die wichtigsten Regeln und Befehle werden hier anhand kurzer Beispiele
erläutert. Dabei gilt es zu beachten, dass alle Schlüsselwörter und vordefinierten Funktionen fett geschrieben sind und
optionale Parameter in eckigen Klammern stehen. Ausserdem sind nur Statements mit einem Semikolon abgeschlossen,
die auch als solche einen Sinn ergeben (d.h. genau so im Quelltext vorkommen könnten).
Es gibt keine Garantie auf Vollständigkeit und Richtigkeit dieser Kurzzusammenfassung.
Grundlegendes

Perl (= Practical Extraction and Report Language) ist eine serverseitige Programmiersprache.

Hauptanwendungsgebiete: Serverprogrammierung, Textverarbeitung, elektronische Formulare (WWW) und
Verbindung zwischen System, Datenbank und Benutzer. Nicht geeignet für die Verarbeitung von Binärdaten oder
für besonders aufwändige Berechnungen.

Manual aufrufen über die Konsole (Linux): man perlfunc … resp. perldoc -f …

Die Shebang (meist erste Zeile in einem .pl-Dokument) legt unter Linux fest, wie die Datei ausgeführt resp. mit
welchem Programm die Datei gelesen / interpretiert werden soll:
#!/usr/sepp/bin/perl -w

Einige Linux / Unix Befehle:
chmod
perl –w name.pl
./name.pl
ls -lsa
setenv PATH ″new″

# Zugriffsrechte ändern (z.B. 777: Besitzer, Gruppe und Jeder hat Vollzugriff)
# interpretiert die Datei name.pl (Warnungen werden angezeigt)
# Datei name.pl wird ausgeführt (Shebang sagt wie / mit welchem Programm)
# Zeigt alle Dateien im aktuellen Verzeichnis an (detailierte Ansicht)
# setzt die Umgebungsvariable PATH auf einen neuen Wert
Perl-Module einbinden:
use Data::Dumper;
use Data::Dumper ″Path″;
Dumper(…)
# einbinden eines Moduls
# einbinden eines Moduls, falls es sich nicht in einem Systemordner befindet
# Verwendung eines Funktion des inkludierten Moduls

Kommentare werden mit einer Raute # eingeleitet, Befehle mit einem Semikolon abgeschlossen. Perl ist casesensitive.

Skalare sind einfache Variablen, entweder Zahlen oder Strings. Datentypen, wie man sie aus anderen
Programmiersprachen kennt, gibt es als solche nicht:
$zahl = 9;
$zeichenkette = 'Hello World';

Arrays sind Listen von Skalaren:
@food = (″apples″, 4, ″pears″);
print ″$food[2]″;
$size = @food;
@food2 = @food;
($x, @y) = @food;
(@test, $a) = @food;

# eine Liste von Skalaren wird einem Array zugewiesen
# Zugriff auf das 3. Element (Ausgabe ist pears)
# size enthält die Anzahl der Elemente von food (also 3)
# das Array food wird in das Array food2 kopiert
# $x enthält apples, @y die restlichen 2 Elemente
# test „frisst“ alle Elemente aus food auf (greediness), a geht
leer aus (enthält den Wert undef)
Handles haben keinen Präfix (also kein @, $ oder %) und werden üblicherweise komplett in Grossbuchstaben
geschrieben.
Befehle

Operatoren: +, -, *, /, ** (potenzieren), %, . (concat), x (wiederholen), =, ++, --, +=, -=, *=, /= und .=

Vergleichsoperatoren: ==, !=, ||, &&, or (niedrigere Priorität), and, eq (equal), ne (not equal), =~ (matches), !~

die ″… $!″ gibt eine Fehlermeldung aus und beendet das laufende Skript ($! enthält die Fehlermeldung)

Textausgabe in der Kommandozeile:
Die Programmiersprache Perl | 1
print 'Hello World';
print @food;
print '@food';
print ″@food″;
print scalar @food;
printf ″%.2d″ $i;
$″ = ″\n″;

# schreibt @food (keine Interpolation / Substitution)
# schreibt @food (keine Interpolation)
# gibt den Inhalt von @food aus (Interpolation)
# gibt die Anzahl der Elemente in @food aus
# Ausgabe mit format specifiers (.2 = zweistellig)
# definiert das Trennzeichen bei der Arrayausgabe
Strings:
($s1 eq $s2)
($s1 =~ /^$s2$/i)
chomp $s1
length($s1)
substr($s1, 3, 4)

Kontrollstrukturen:
foreach $elem (@food) { … }
for ($i = 0; $i < 10; $i++) { … }
while ($a < 10) { … }
until ($a < 10) { … }
do { … } while ($a < 10);
if (…) { … } elsif (…) { … } else { … }
next
last

# geht Elemente in @food durch
# Inversion von while, wird selten verwendet
# bedingte Abfrage
# entspricht continue resp. break in C
File Handling:
open(INFO, "+>"."test.txt") or
die "Can't open $file : $!\n";
$counter;
while ($line = <INFO>)
{
printf "%.3d: $line", $counter;
$counter++;
}
print INFO "Hello World";
close(INFO);

# zwei Strings vergleichen
# zwei Strings vergleichen (ignore case)
# entfernt das Newline am Zeilenende
# gibt die Länge des Strings zurück
# liefert einen Teilstring zurück (Position 3, Länge 4)
# open modes: < (input), > (output), >> (add),
#
+> (read & write)
# liest eine Zeile ein (@line würde alle Zeilen einlesen)
# Zeilennummer und Dateiinhalt ausgeben
# in die Datei schreiben
# Handle schliessen
Standard I/O:
STDIN
STDOUT
$line = <STDIN>;
# Standard-Handles sind immer geöffnet vom System
# eine Zeile Lesen von der Konsole (Benutzereingabe)

Hashes sind assoziative Arrays. Im Gegensatz zu gewöhnlichen Arrays erfolgt der Zugriff auf die einzelnen Elemente
(Values) über Strings (Keys) anstatt über Zahlen.
%H = ("key1", "val1", "key2", "val2", …);
# Anzahl der Elem. muss gerade sein (#keys = #values)
%H = (key1 => "val1", key2 => "val2", …);
# andere Variante der Hash-Definition
$H{"key"} = "value";
# Wertzuweisung
foreach $schluessel (keys %H) { … }
# keys liefert ein Array mit allen Schlüsseln in H zurück
@werte = values %H;
# liefert ein Array mit allen Werten in H zurück

Referenzen sind Pointer (Zeiger), also Adressen auf einen Speicherbereich. Die grossen Vorteile: ermöglichen
komplexe (baumartige) Datenstrukturen (etwa Arrays von Arrays) und beschleunigen Funktionsaufrufe, da nicht
immer der gesamte Inhalt einer Variablen / eines Arrays kopiert werden muss.
$ref = \@food;
# eine Referenz auf das Array @food
$ref = [ "red", "green", "black" ];
# Adresse auf ein (on the fly erzeugtes) Array
$ref = { key1 => value1, key2 => value2 }; # Adresse auf einen (on the fly erzeugten) Hash
@refs = \ ("red", "green", "black");
# gibt die Adressen jedes einzelnen Elements zurück
@numbers = ( [1, 2, 3], [4, 5, 6] );
# ein Array von Arrays
@$ref
%{$ref}
# Dereferenzierung (hier für eine Array- und Hash-Ref.)
${$ref}[1]
${$ref}{"key1"}
# Zugriff auf ein Element
$ref->[0]
$ref->[0][0]
# Deref.-operator (zwei Indices falls mehrdimensional)

String matching: Eine der grössten Stärken von Perl sind die Regular Expressions. Sie legen fest, wie eine
Zeichenfolge auszusehen hat, damit ein Match zustande kommt. Hinweis: $_, $1, $2, etc. sind vordefiniert
Die Programmiersprache Perl | 2
$s1 =~ /the/;
if (/the/) { … }
/([0-9]{1-3})(…)/
s/\bthe\b/there/gi;
s/([A-Z])/:$1:/g;
/\b(\w+)\b.*\1/
s/$search/$replace/g;
s/(.{2})/chr(hex $1)/eg;
# wird true, wenn ‚the‘ in $s1 vorkommt (case sensitive!)
# meint implizit if ($_ =~ /the/)
# Inhalt der ersten Klammer wird in $1 gespeichert, zweite Klammer in $2
# Substitution: ersetzt alle ‚the‘ in $_ durch ‚there‘ (global, ignore case)
# schreibt vor und nach jeden Grossbuchstaben in $_ einen Doppelpunkt
# zur Laufzeit Muster in () einsetzen mit \1; ein Wort muss also 2x vorkommen
# suchen und ersetzen in $_: auch mit Variablen möglich
# Hex-Code in ASCII-Code umwandeln (e = Funktionen auswerten)

Regular Expressions (RE, RegEx):
* + ?
# quantifiers, beziehen sich jeweils auf das Zeichen vorher (0 - ∞, 1 - ∞, 0 oder 1)
. ^ $
# Pattern matching characters (beliebiges Zeichen, String-Anfang, String-Ende)
^$
# leere Zeile
.*
# beliebiges Zeichen, beliebig oft (für alle Strings true)
[a-zA-Z9]
# character classes: entweder ein Klein-/Grossbuchstabe oder die 9
[^0-9]
# jedes beliebige Zeichen, nur keine Ziffer
[0-9]{1, 4}
# eine ein- bis vierstellige Zahl; für z.B. genau zweistellig: [0-9]{2}
| (…)
# oder- resp. und-Verknüpfung (capture, zusammenfassen)
\n \t \w \W \d
# Escape Sequenzen (newline, tab, alphanum. char, non-alphanum. char, digit,
\D \s \S \b \B
#
non-digit, whitespace, non-whitespace, word boundary, no word boundary)
\| \. \) \/ etc.
# Steuerzeichen müssen escaped werden, damit diese als gewöhnliche Zeichen gelten
[[:alnum:]]
# alphanumerische Zeichen - bsp. für eine Posix char class (gibt es nicht nur in Perl)

Split (kann ebenfalls mit REs umgehen):
@a = split(/:/, $info);
# teilt den String $info in ein Array auf; Trennzeichen ist der Doppelpunkt
split(/:+/);
# teilt den String $_ in ein Array auf; Trennzeichen sind ein oder mehrere :
split(//, $info)
# teilt den String $info in ein Array von Chars auf (entspricht einem C-String)

Subroutines (Prozeduren). In Perl haben Funktionen i.d.R. keine Parameterlisten. Alle übergebenen Werte werden
automatisch im Array @_ gespeichert. Rückgabewert ist jeweils die letzte ausgewertete Variable in einer SubRoutine (ausser, es wird explizit mit return ein Wert zurückgegeben).
sub a;
# Funktionsdeklaration (wenn Definition nach der ersten Verwendung kommt)
sub myfunc
# Funktionsdefinition
{
$para1 = $_[0];
$para1 = shift;
return $para1;
# holt den ersten Parameter aus @_
# speichert das erste Element von @_ in $para1
# den Parameter zurückgeben
}

Nützliche Funktionen:
push($x[, $y, …]);
$x = pop(@a);
shift(@a)
chr
org
chomp($a);
defined
join(' ', @a);
scalar
# erweitert ein Array und gibt die Anz. der Elemente des neuen Arrays zurück
# liefert das letzte Element zurück und löscht dieses aus dem Array
# liefert das erste Element zurück und löscht dieses aus dem Array
# ASCII-Code in Zeichen umwandeln
# liefert den ASCII-Code eines Zeichens
# schneidet das Newline einer Zeile ab
# prüft, ob eine Variable bereits definiert ist
# verbindet Elemente eines Arrays zu einem String (Space als Trennzeichen)
# erzwingt einen skalaren Kontext (wird selten verwendet)
Tipps und Hinweise

Nach der Installation von ActivePerl können Perl-Programme (.pl) auch im Kommandofenster unter Windows
ausgeführt werden.

Enthält die Liste bei der Arraydefinition wiederum ein Array, so wird dieses expandiert und an der entsprechenden
Stelle in die Liste eingefügt.

Perl-Programme sollten grundsätzlich immer mit dem –w ausgeführt werden, damit alle auftretenden Warnungen
erkannt und beseitigt werden können.

Der Hash %ENV enthält alle vom System definierten Environment Variablen.

Allgemein dürfen Klammern bei Funktionen weggelassen werden: print … statt print(…)
Die Programmiersprache Perl | 3

Ein String kann wie eine Zahl behandelt werden, falls er konvertierbar ist (nur Ziffern, e und . resp. , enthält)

Wird eine Datei nur zum Lesen geöffnet (input), muss der open mode nicht spezifiziert werden.

Wahrheitsprüfung einer Variablen: Der Inhalt wird implizit in einen bool’schen Wert konvertiert; bei Arrays wird der
skalare Kontext verwendet (also die Anzahl der Elemente). Spezialfall: ein String, der nur Nullen enthält, wird
implizit in eine Dezimalzahl konvertiert und deshalb zu false, obschon die Länge des Strings grösser als null ist.

(…) && (…); Ist die verkürzte Form von if (…) { … }

Perl-Code kann auch direkt in der Shell (Linux / Unix) eingegeben werden: echo "…" |perl

Hashes sind Funktionen, die den Schlüssel „zerstückeln“ resp. aus dem Schlüssel eine Dezimalzahl berechnen. Diese
Zuordnung sollte möglichst eindeutig sein, was in der Praxis nicht immer der Fall ist. Zu diesem Zweck wird in einer
Spalte der Hash-Tabelle zusätzlich der Schlüssel gespeichert, sodass die Funktion überprüfen, kann, ob es sich um
eine Kollision handelt oder nicht. Im Falle einer Kollision wird meistens lineares Sondieren angewendet (der nächste
freie Eintrag in der Tabelle wird verwendet). Der Hash-Algorithmus ist i.d.R. innerhalb einer Perl-Version für alle
Tabellen derselbe. D.h., die Tabelle wird unter Umständen sehr gross und enthält viele Löcher.

Regular Expressions müssen nicht zwingend in Slashes stehen (/…/); es können auch zwei beliebige andere Zeichen
verwendet werden.

Dereferenzierte Variablen sind keine Kopieren, sondern Aliases.

Ein whitespace character kann ein Leerzeichen, ein Tabulator, ein Newline oder Ähnliches sein (nicht nur ein
Leerzeichen).

Gewisse Escape-Sequenzen wie \w oder \W sind perlspezifisch.

Bei Vergleichen (>, <, <=, …) werden die Variablen automatisch in den skalaren (numerischen) Kontext konvertiert,
weil diese Vergleichsoperatoren nur für Zahlen definiert sind; das Schlüsselwort scalar ist daher überflüssig.

Ein geklammerter RE wie (.*) frisst die ganze Zeile weg (greediness), worauf alle nachfolgenden Expressions nicht
mehr beachtet werden. Es wird also immer der längste Ausdruck - der matcht - in $1 ($2, …) gespeichert.

Word boundaries sind einzelne Wörter. Bsp.: /\bthe\b/ matcht nur ‚the‘ als separates Wort, nicht jedoch ‚there‘

Scope. Alle Variablen, die ohne das Schlüsselwort my definiert werden, sind global verfügbar. Grundsätzlich sollte
man den Gültigkeitsbereich möglichst kompakt halten und alle lokal genutzten Variablen mit my definieren. Haben
zwei Variablen (eine global, die andere lokal) denselben Namen, so wird innerhalb von Funktionen jeweils die lokale
Variable verwendet. Der Befehl use strict; sorgt dafür, dass für alle globalen Variablen, deren Scope durch my
eingeschränkt werden könnte, eine Warnmeldung ausgegeben wird. Auch globale Variablen können – sofern sofern
diese nicht ausserhalb des Moduls zur Verfügung stehen sollen – mit dem Schlüsselwort my versehen werden.

while (<STDIN>) { … } meint implizit while ($_ = <STDIN>) { … }

Über CGI-Skripte können Perl-Programme auf Homepages dazu genutzt werden, html-Seiten on-the-fly zu erstellen.
Natürlich sind auch andere Einsatzmöglichkeiten denkbar.
Quellen und Links



Schneider, David (2009). Perl Programming. Version 2.0 – February 11, 2009.
http://search.cpan.org [2009-03-30]
http://www.perl.com [2009-04-07]
Version 1.1, 2009-04-07
© 2009 by Reto Da Forno | www.kcdev.ch.vu
Die Programmiersprache Perl | 4