Alle folgenden Beispiele beginnen mit diesem Code:
#!usr/bin/perl -w
print "In welchem Verzeichnis oder Ordner soll gearbeitet werden?\n";
chomp ($verzeichnis = <STDIN>);

Einen neuen Ordner erstellen:
print "wie soll der neue Ordner heissen?\n";
chomp ($ordner = <STDIN>);
chdir $verzeichnis || die "Wechsel in das Verzeichnis geht nicht $!";
mkdir $ordner, 0777 || die "Erstellen geht nicht $!"

Einen leeren Ordner löschen:
print "welcher Ordner soll weg?\n";
chomp ($ordneralt = <STDIN>);
chdir $verzeichnis || die "Wechsel in das Verzeichnis geht nicht $!";
rmdir $ordneralt || die "löschen funktioniert nicht $!";

Eine Datei löschen:
print "welche Datei + Endung soll weg?\n";
chomp ($dateialt = <STDIN>);
chdir $verzeichnis || die "Wechsel in das Verzeichnis geht nicht $!";
unlink $dateialt || die "löschen der Datei geht nicht $!";

Eine Datei umbenennen:
print "welche Datei soll umbenannt werden?\n";
chomp ($alt = <STDIN>);
print "wie ist der neue Name?\n";
chomp ($neu = <STDIN>);
chdir $verzeichnis || die "Wechsel in das Verzeichnis geht nicht $!";
rename ("$alt", "$neu");

Eine Datei kopieren:
print "welche Datei soll kopiertwerden?\n";
chomp ($alt = <STDIN>);
print "wie ist der neue Name?\n";
chomp ($neu = <STDIN>);
chdir $verzeichnis || die "Wechsel in das Verzeichnis geht nicht $!";
link ("$alt", "$neu");

Andere Perl-Themen

Der Dateiinhalt, der bearbeitet werden soll ist folgender:

Perun : Browser : HTML-CSS : Internet : PHP-JS
Sahanya : Bücher : Filme : Kurioses : PS-Tutorials

Und der Perl-Code zum Einlesen der Datei (themen.txt) und Ausgeben in der neuen Datei (blogthemen.txt) sieht so aus:

#!usr/bin/perl -w
open (BLOGTHEMEN, ">blogthemen.txt") || die "kann Datei nicht anlegen $!";
open (THEMEN, "themen.txt") || die "Datei oeffnen geht nicht $!";
while (<THEMEN>) {
chomp;
($blog, $thema1, $thema2, $thema3, $thema4) = split (/: /);
write (BLOGTHEMEN);
}

(Nachtrag: Hat man in der Quelldatei mehr Daten als man verarbeiten möchte, kann man diese auch selektieren. Zeile 6 sähe dann z. B. so aus:
($blog, $thema1, $thema2, $thema3, $thema4) = (split /:/) [0,1,2,3,5];

Um das Aussehen der Zieldatei zu beeinlussen, defniert man es:

format BLOGTHEMEN =
=============================
@||||||||||||||||||||||||||||
$blog
@<<<<<<<<
$thema1
@>>>>>>>>>>>>
$thema2
@||||||||
$thema3
@<<<<
$thema4
=============================
.

Die Ausgabedatei sieht danach so aus:

Die Einzelnen Strings wurden eingelesen, am Doppelpunkt durch split getrennt und den einzelnen Variablen zugeordnet.

In den Zeilen 1, 7, 8 und 14 sieht man die Gleich-Zeichen (29 Stück), die ich als Abgrenzung gewählt habe.

In den Zeilen 2 und 9 wird der Inhalt zentriert über die gesamte Breite von insgesamt 29 Zeichen (28 mal | und 1 mal @) dargestellt.

In den Zeilen 3 und 10 wird der Inhalt linksbündig dargestellt.

In den Zeilen 4 und 11 wird der Inhalt rechtsbündig dargestellt, allerdings nur auf eine Breite von insgesamt 9 Zeichen.

In den Zeilen 5 und 12 wird der Inhalt zentriert dargestellt, allerdings nur auf einer Breit von 9 Zeichen, so dass er linksbündig wirkt.

In den Zeilen 6 und 13 wird der Inhalt linksbündig dargestellt, allerdings nur 5 Zeichen, er ist also abgeschnitten.

Ändert man das Format @<<<< für die Zeilen 6 bzw. 13 in ^<<<<, so erhält man als Ausgabe: „PHP-” bzw. „PS-” — es wird also logisch getrennt. Es fehlen allerdings Teile der Variable. Für eine merhzeilige Darstellung muss der Code also erweitert werden.

^<<<<
$thema4
^<<<<
$thema4
^<<<<
$thema4

Er ergibt eine evtl. nicht gewollte Leerzeile:

Eine Änderung in
~ ^<<<<
$thema4
~ ^<<<<
$thema4
ergibt die folgende zweizeilige Ausgabe (Sie kann um beliebig viele Zeilen erweitert werden):

Der Zeilenumbruch erfolgt in der ersten Zeile logisch, allerdings wird das Wort „Tutorial” noch immer abgeschnitten — das Feld ist einfach zu kurz.

Eine Erweiterung des Codes um noch eine Zeile ~ ^<<<< mit der Zuordnung der entsprechenden Variablen $thema4, sähe dann im Ergebnis so aus:

Hier wird die Leerzeile bei Perun unterdrückt.

Das gleiche Ergebnis bekommt man allerdings auch mit ~~ ^<<<<. Die Vorteile: weniger Schreibarbeit und wenn man sich unsicher ist, wieviele Zeilen in der Ausgabe benötigt werden, ist man damit immer auf der sicheren Seite — es werden soviele Zeilen wie benötigt generiert.

Andere Perl-Themen

Eine Ausführliche Liste findet man hier. Und hier ein praktisches Beispiel:

#!usr/bin/perl -w
#fragt nach Datei und gibt Inhalt in neuer Datei aus
print "Welche Datei wollen sie oeffnen?\n";
chomp ($datei = <STDIN>);
until (-e "$datei.txt") {
print "Diese Datei gibt es nicht! Welche jetzt?\n";
chomp ($datei = <STDIN>);
}
print "Welche Datei soll neu erstellt werden?\n";
chomp ($datei_neu = <STDIN>);
while (-e "$datei_neu.txt") {
print "Diese Datei gibt es schon! Denk dir einen neuen Namen aus.\n";
chomp ($datei_neu = <STDIN>);
}
open (ALT, "$datei.txt") || die "oeffnen geht nicht $!";
open (NEU, "> $datei_neu.txt") || die "Die neue Datei anlegen geht nicht. $!";
while (<ALT>) {
chomp;
print NEU;
}
close ALT || die "schliessen der Ursprungsdatei geht nicht $!";
close NEU || die "schliessen der neuen Datei geht nicht $!";

Andere Perl-Themen

last — dauer bzw. anhalten
Die Schleife wird abgebrochen, wenn eine bestimmte Bedingung erfüllt ist (kann auch ohne Bedingung stehen).
redo — nochmal machen
Die Schleife wird unendlich oft wiederholt.
Die eingebenen Zahlen werden solange zusammengerechnet, bis ihre Summe 999 übersteigt
while () {
print "Nenne eine Zahl.\n";
chomp ($zahlen = <STDIN>);
$summe += $zahlen;
last if ($summe > 999);
redo;
}
print "Die Gesamtsumme ist $summe.\n";

next — nächste
Die Schleife wird abgebrochen und weiter geht es mit der nächsten Anweisung bzw. Schleife. Dies ähnelt ein bißchen dem while-else-Konstrukt.
while () {
print "Nenne eine Zahl.\n";
chomp ($zahl =<STDIN>);
if ($zahl > 999) {
print "Das ist eine hohe Zahl.\n";
next;
}
print "Das ist nicht sehr viel.\n";
}

Die Kontrollstrukturen if und unless können auch viel kürzer ausgedrückt werden:
Anstatt:
if ($zahl > 999) {
print "Das ist eine hohe Zahl.\n";
}

print "Das ist eine hohe Zahl.\n" if $zahl > 999;
oder
$zahl > 999 && print "Das ist eine hohe Zahl.\n";

Anstatt:
unless ($zahl < 999) {
print "Das ist eine hohe Zahl.\n";
}

print "Das ist eine hohe Zahl.\n" unless $zahl < 999;
oder
$zahl < 999 || print "Das ist eine hohe Zahl.\n";

Andere Perl-Themen

if … else (wenn … sonst)
print "Wie warm ist es?\n";
chomp ($temperatur = <STDIN>);
if ($temperatur > 22) {
print "Es ist zu heiss\n";
}
else {
print "Es ist zu kalt\n";
}

if .. elsif … else (wenn … oder … sonst )
print "Wie warm ist es?\n";
chomp ($temp = <STDIN>);
if ($temp > 24) {
print "Es ist zu warm.\n";
}
elsif ($temp < 21) {
print "Es ist zu kalt\n";
}
else {
print "Es ist gerade richtig.\n";
}

unless (außer wenn) — Gegenteil von if
print "Wie warm ist es?\n";
chomp ($temperatur = <STDIN>);
unless ($temperatur < 22) {
print "Es ist zu heiss\n";
}
else {
print "Es ist zu kalt\n";
}

while (während)
print "Nenne mehrere Zahlen. 999 beendet die Eingabe.\n";
chomp ($zahlen = <STDIN>);
while ($zahlen != 999) {
$summe += $zahlen;
print "Noch eine! 999 beendet die Eingabe.\n";
chomp ($zahlen = <STDIN>);
}
print "Die Gesamtsumme ist $summe.\n";

until (bis) — Gegenteil von while
print "Nenne mehrer Zahlen. 999 beendet die Eingabe.\n";
chomp ($zahlen = <STDIN>);
until ($zahlen == 999) {
$summe += $zahlen;
print "Noch eine! 999 beendet die Eingabe.\n";
chomp ($zahlen = <STDIN>);
}
print "Die Gesamtsumme ist $summe.\n";

for (für) — ähnelt while wird aber nur einmal ausgeführt
print "Nenne eine Zahl\n";
chomp ($zahl = <STDIN>);
for ($zahl) {
$quadrat = $zahl * $zahl;
}
print "$zahl zum Quadrat ergibt $quadrat\n";

foreach (für alle)
foreach $zahlen (0 .. 32) {
$quadrat = $zahlen * $zahlen;
print "$zahlen zum Quadrat ergibt $quadrat\n";
}

Andere Perl-Themen

Subroutinen geben dabei immer ihren letzten Wert aus. Hier einige Beispiele für den Umgang mit Subroutinen:

sub sag_hallo_zu {
print "Hallo $_[0]!\n";
}

sag_hallo_zu ("Welt"); Hallo Welt!

$x = "jemand";
sag_hallo_zu ($x); Hallo jemand!

sag_hallo_zu ("ich") + sag_hallo_zu ("du"); Hallo ich! Hallo du! — die SR wird hier zweimal aufgerufen

Mehrere Variablen ansprechen:

sub sag {
print "$_[0], $_[1]\n";
} man erhält eine Fehlermeldung, wenn hier noch $_[2] steht, aber keine 3 Variablen definiert sind

sag ("Tschuess", "du grausame Welt"); Tschüss du grausame Welt

sag ("Hallo", "Welt", "test"); Hallo Welt — die dritte Variable wird ignoriert

Um zu verhindern, das Variablen, die man in der Subroutine definiert mit Variablen außerhalb der Subroutine kollidieren, wenn sie den gleichen Namen haben, definiert man sie als „privat”

$a = addieren (3,4);
$b = addieren (1..5);
print "$a, $b"; 7, 15

sub addieren {
my ($summe);private Variable anlegen
$summe = 0; Startwert festlegen
foreach $_ (@_) { für jeden Wert der Liste
$summe += $_; 1+ Wert
}
return $summe;Rückgabewert
}

Andere Perl-Themen

$a = "Sahanya-lernt-PHP";
@worte = split (/-/,$a); entfernt Bindestriche

$a = "Sahanya lernt PHP";
#@worte = split (/\s+/,$a); entfernt Leerzeichen

Arbeitet man mit der Standardvariable $_ und möchte dort Leerzeichen entfernen, geht das so:

$_ = "Sahanya lernt PHP";
@worte = split;

Umgekehrt kann man mit join auch Werte aus Listen bzw. Arrays durch Trennzeichen in eine Skalarvariable schreiben:

@worte = qw (
Sahanya
lernt
PHP
);
$a = join (" ",@worte);

Also ist jetzt $a = "Sahanya lernt PHP"

Andere Perl-Themen

$_= "Sahanya lernt PHP";
s/a/o/;
print $_;#Sohanya lernt PHP (ersetzt wird nur das erste a)

$_= "Sahanya lernt PHP";
s/a/o/g;
print $_;#Sohonyo lernt PHP (es werden alle as ersetzt)

$_= "Sahanya lernt PHP";
s/h/y/g;
print $_;#Sayanya lernt PHP (es werden alle hs ersetzt)

$_= "Sahanya lernt PHP";
s/h/y/gi;
print $_;#Sayanya lernt PyP (es werden alle hs ersetzt, egal ob groß oder klein)

$_= "Sahanya lernt PHP";
s/(\w+)/-$1-/g;
print $_;#-Sahanya- -lernt- -PHP-

Der Substitute-Operator ersetzt außerdem in:

Skalarvariablen:
$a = "Sahanya lernt PHP";
$a =~ s/Sahanya/Perun/;
print $a;#Perun lernt PHP

Arrays:
@sahanya = qw (
erstens
zweitens
drittens);
$sahanya[1] =~ s/e/\?/;
print "@sahanya\n";#erstens zw?itens drittens

Hashs:
%sahanya = qw (
erstens eins
zweitens zwei
drittens drei
);
$sahanya{"zweitens"} =~ s/^/vier/;
while (($name, $zahl) = each %sahanya) {
print "$name hat die Zahl $zahl\n";
}#aus zwei wird vierzwei

Andere Perl-Themen

Eingaben, die keiner speziellen Variablen zugeordnet werden, werden zu $_.

Möchte man nur Teile einer Variable ausgeben, kann das so aussehen:

#!\usr\bin\perl -w
$_ = "Sahanya versucht PHP zu lernen";
/v.{3}ucht/;
print "$`\n"; Ausgabe: Sahanya (der Ausdruck vor dem gesuchten Wort)
print "$&\n"; Ausgabe: versucht (das gesuchte Wort)
print "$'\n"; Ausgabe: PHP zu lernen (der Ausdruck hinter dem gesuchten Wort)

Andere Perl-Themen

Für alle folgenden Beispiel gilt:

#!usr/bin/perl -w
$a = "sahanya_25";
diese Zeile wird durch die in den Beispielen ersetzt
print "das ist wahr\n";
}
else {
print "das ist falsch\n";
}

Muster für einzelne Zeichen und Zeichenkombinationen:

if ($a =~ m/A/) { falsch, der Buchstabe A kommt nicht vor
if ($a =~ m/A/i) { wahr, der Buchstabe A, egal ob groß oder klein, kommt vor
if ($a =~ m/a/) { wahr

if ($a =~ m/sha/) { falsch, die Buchstabenkombination „sha” kommt nicht vor
if ($a =~ m/saha/) { wahr

if ($a =~ m/[A-Z]/) { falsch, kein Großbuchstabe kommt vor
if ($a =~ m/[a-z]/) { wahr

if ($a =~ m/h(?=h)/) { falsch, auf den Buchstaben h folgt kein h
if ($a =~ m/h(?=a)/) { wahr

if ($a =~ m/h(?!a)/) { falsch, auf den Buchstaben h folgt ein a
if ($a =~ m/h(?!h)/) { wahr

if ($a =~ m/as|b/) { falsch, $a enthält weder die Buchstabenkombination as noch den Buchstaben b
if ($a =~ m/a|b/) { wahr $a enthält a und/oder b

if ($a =~ m/(s|n)b/) { falsch, weder auf s noch auf n folgt ein b
if ($a =~ m/(s|n)a/) { wahr, denn auf s folgt ein a

if ($a =~ m/[6-9]/) { falsch, keine der Zahlen 6 bis 9 kommt vor
if ($a =~ m/[0-9]/) { wahr
if ($a =~ m/[\d]/) { kürzer

if ($a =~ m/[a-zA-Z0-9_]/) { wahr

if ($a =~ m/[\w]/) { kürzer

if ($a =~ m/[\s]/) { falsch, es gibt keine Leerzeichen
if ($a =~ m/[\S]/) { wahr

das Zeichen „^” verneint die folgende Aussage:

if ($a =~ m/[^0-9]/) { wahr (es gibt Nicht-Zahlen bzw. Buchstaben)
if ($a =~ m/[\D]/) { kürzer

if ($a =~ m/[^a-zA-Z0-9_]/) { falsch, es gibt Wortzeichen
if ($a =~ m/[\W]/) { kürzer

Ich gehe im Folgendem von diesem Hash aus:

%hobby = qw (
Sahanya lesen
Perun schlafen
);

Dabei sind „Sahanya” und „Perun” die Schlüssel und „lesen” und „schlafen” die Werte.

Dem Hash einem Schlüssel mit einem dazugehörigen Wert hinzufügen:
%hobby{„Tolkien”} = („schreiben”)

Dem Hash mehrere Schlüssel mit Werten hinzufügen:
%hobby {„Hänsel”, „Gretel”} = („essen”, „wandern”)

Einen Schlüssel mit Wert aus dem Hash löschen:
delete $hobby{„Perun”}

Alle Werte des Hashs ausgeben:
print values %hobby

Alle Schlüssel des Hashs ausgeben:
print keys %hobby

Möchte man Werte und Schlüssel gemeinsam ausgeben, kann man das so machen:
foreach $name (keys %hobby) {
print "$name hat das Hobby $hobby{$name}\n"
}

Eine andere Möglichkeit ist diese:
while ($name, $freizeit) = each %hobby {
print "$name hat als Hobby $freizeit\n"
}

Achtung: Da sich while-Schleifen immer wiederholen, sollte man während dieser keine Schlüssel bzw. Werte dem Hash hinzufügen, da sie sich sonst unendlich wiederholt.

Andere Perl-Themen

Für alle folgenden Beispiele gilt @sahanya = 0, 10, 20, 30:

Werte zuweisen:

@perun = 4, @sahanya, 5 # @perun = 4, 0, 10, 20, 30, 5
@sahanya = @perun = (12, 24) # die Arrays erhalten beide die Werte 12 und 24
($sahanya, $perun) = ($perun, $sahanya) # die Arrays tauschen ihre Werte
@sahanya = <STDIN> # @sahanya = „Eingabe”

Werte ändern:

$sahanya[0] = 100 # @sahanya = 100, 10, 20, 30
$sahanya[0]++ # @sahanya = 1, 10, 20, 30
$sahanya[0] +=4 # @sahanya = 4, 10, 20, 30
@sahanya[0,1] = @sahanya[1,0] # @sahanya = 10, 0, 20, 30
@sahanya[0,1] = @sahanya[2,2] # @sahanya = 20, 20, 20, 30
@sahanya[0,1] = (80, 40) # @sahanya = 80, 40, 20, 30

@perun = reverse @sahanya # @perun = 30, 20, 10, 0
@perun = sort @sahanya # @perun = 0, 10, 20, 30 (sortiert nach ASCII-Zeichen,
hier zufällig die gleiche; aber bei @sahanya = 1, 4, 30 dann @perun = 1, 30, 4

Werte hinzufügen:

$sahanya[5] = 99 # @sahanya = 0, 10, 20, 30, undef, 99
push (@sahanya, 200) # @sahanya = 0, 10, 20, 30, 200
push (@sahanya, 88, 25) # @sahanya = 0, 10, 20, 30, 88, 25
unshift (@sahanya, 55) # @sahanya = 55, 0, 10, 20, 30
unshift (@sahanya, 55, 15)# @sahanya = 55, 15, 10, 20, 30

Werte entfernen:

$a = pop(@sahanya) # @sahanya = 0, 10, 20 (Variablenname spielt keine Rolle)
$a = shift (@sahanya) # @sahanya = 10, 20, 30 (Variablenname spielt keine Rolle)

Auf Arrays zugreifen:

($a) = @sahanya # $a = 0 ( $a erhält das erste Element von @sahanya)
($a, $b) = @sahanya # $a = 0 und $b = 10
$a = @sahanya # $a = 4 ($a erhält die Anzahl der Elemente von @sahanya)
$a = $sahanya[1] # $a = 10
$a = $sahanya[6] # $a = undef (es gibt nur die Werte 0 bis 3)
$a = $sahanya[-2] # $a = 20 (es wird von hinten gezählt)
$a = $#sahanya # $a = 3 (gibt den Index des letzten Wertes aus)
$a = $sahanya[$#sahanya] # $a = 30
$a = "Du bist $sahanya[1] Jahre alt." # $a = “Du bist 10 Jahre alt.”

Andere Perl-Themen

$a = "Sahanya";
chop ($a); # Sahany (letzter Buchstabe fehlt)
chop ($a); #Sahan (“)

Während der Befehl chomp sich nur auf den Newline-Befehl \n bezieht.

Eine Eingabeaufforderung mit <STDIN> wird in der Regel mit chomp beendet, um sicherzustellen, dass das Newline-Zeichen entfernt wird:

$eingabe = <STDIN>;
chomp $eingabe;

Das ganze geht aber auch kürzer:

chomp ($eingabe = <STDIN>);

Manchmal sollte bzw. muss man allerdings nach einer Eingabeaufforderung auch auf den chomp-Befehl verzichten, z. B. wenn man möchte, dass ein Wert in getrennten Zeilen untereinander ausgegeben wird.

Wenn $wort = "hallo" und $anzahl = 4 ergibt der folgende Code: hallohallohallohallo

print "Wie lautet das Wort?\n";
chomp ($wort = <STDIN>);
print "Wie oft soll es wiederholt werden?\n"; # \n bewirkt, dass Anwort in neuer Zeile gegeben wird
chomp ($anzahl = <STDIN>);
$c = $wort x $anzahl;
#print "So sieht das aus \n$c"; # \n bewirkt, dass erstes Wort nach Leerzeile startet

Wenn $wort = "hallo" und $anzahl = 4 ergibt der folgende Code:
hallo
hallo
hallo
hallo

print "Wie lautet das Wort?\n";
$wort = <STDIN>; #fehlendes chomp bewirkt, dass Antwort in mehreren Zeilen ist, weil newline bleibt
print "Wie oft soll es wiederholt werden?\n"; # \n bewirkt, dass Anwort in neuer Zeile gegeben wird
chomp ($anzahl = <STDIN>);
$c = $wort x $anzahl;
print "\n$c"; # \n bewirkt, dass erstes Wort nach einer Lerzeile startet

Andere Perl-Themen

Vergleichsoperatoren für Zahlen und Zeichenketten sollte man tunlichst nicht verwechseln, denn 5 ist kleiner als 20 >, aber 5 lt 20 ist nicht wahr, denn 2 kommt vor 5.

Andere Perl-Themen

print "sahanya"."perun"; #sahanyaperun
print "sahanya"." "."perun"; #sahanya perun
print "sahanya" x 3; #sahanyasahanyasahanya
print 5 x 3; # 555

Setzt man Skalarvariablen bei der Aneinanderhängung von Zeichenketten ein, sieht das ganze so aus:

$a = "sahanya";
$b = "perun";
$a = "$a"."$b";
print $a; #sahanyaperun

Kürzer geht die Aneinanderhängung von Zeichenketten auch so — anstatt der dritten Zeile im obigen Beispiel:

$a .= $b;

Andere Perl-Themen