---

< Teil 0: Geschichte, Philosophie | Übersicht | Teil 2: Literale, Arrays und Blöcke > Teil 4: Referenzen auf Arrays und Hashes >>

---

Teil 1 - Das erste Programm

Nachdem im vorigen Teil die Geschichte, Philosophie und Gemeinschaft der
Nutzer vorgestellt wurde, beginnt jetzt die Reise zum eigenen Perl-Programm.
Nachdem geprüft ist, ob alle wichtigen Werkzeuge funktionstüchtig und griffbereit
verpackt sind, geht es zum ersten Etappenziel: skalare Variablen und einfache IO.
Die weitere Route darf durch die Kommentarfunktion mitbestimmt werden.

Wir brauchen Perl und ein Ziel

Wer dieses Magazin liest, tut das wohl vor seinem Bildschirm, der vom Linux seiner
Wahl mit Pixeln versorgt wird. Selbst Mac-Nutzer haben wenigstens ein Unix unter
der Haube und somit Perl bereits installiert. Wen das launige Schicksal jedoch ins
Fensterland verschlug, bekommt mit Strawberry Perl nach wenigen Klicks eine
Arbeitsumgebung mit perl, make und C-Compiler, die es ihm erlaubt, diesem Tutorial
vollständig zu folgen. Denn hier wird für die echte Praxis geübt, nicht für geschönte
Realitätsausschnitte. Dieses Tutorium wird Folge für Folge ein brauchbares Programm
aufbauen und dabei jeden Schritt dokumentieren, damit die Leser gut vorbereitet sind
und in jeder digitalen Wildnis Ideen umsetzen können.

Außerdem macht es wesentlich mehr Spaß ein Programm nach eigenen Wünschen
anzupassen, als beinah sinnlose Codeschnipsel abzutippen. Das geplante Programm
ist ein Notizbuch, weil es eine kleine, praktische Sache ist, die jeder ab und an gut
gebrauchen kann und das linuxeigene note auf externe Editoren zurückgreift und
nicht immer einfach zu bedienen ist. Je nach zugesandten Anregungen wird es am
Ende zwitschern können oder es erlauben, daß die Notizen mehrere Nutzer in Echtzeit
bearbeiten.

Der Anfang sei jedoch ganz einfach, lediglich ein Rechner und etwas logisches
Denkvermögen werden vorausgesetzt. Und natürlich ein aktuelles Perl, mindestens
Version 5.12. Ein kurzes perl -v in der Kommandozeile (auch Shell oder Terminal) gibt
Auskunft was installiert ist. Wer jetzt 5.10 las, wird an einigen Stellen kleinere Abstriche
machen müssen. Aber spätestens mit einem 5.8.x sollte man über eine Aktualisierung
nachdenken und die Paketverwaltung bemühen. Wer das nicht darf oder riskieren möchte,
weil wichtige Programme oder eigene Projekte von Perl abhängig sind und er nicht wieder
alle Module neu aufspielen will, sollte sich das Modul App::perlbrew installieren (lassen).
Auch Menschen, welche die vielen Module, die während dieses Tutoriums vorgestellt
werden, nur testweise installieren möchten oder die es nicht mögen, hinter dem Rücken
der hauseigenen Paketverwaltung zu installieren, sollten den folgenden Abschnitt
sorgfältig lesen, alle anderen dürfen ihn ignorieren.

Perl und Module installieren

Um Module zu installieren wird hier CPANMINUS empfohlen, weil es nicht konfiguriert
werden muß, sehr einfach zu bedienen ist und keine Ausgaben macht, die Anfänger
verwirren könnten. Wer es nicht hat, wird noch einmal auf den Standardclient CPAN
zurückgreifen müssen und kann sehen was mit "verwirrenden Ausgaben" gemeint war:

# cpan App::cpanminus

Wenn die letzte Zeile der Ausgabe lautete "/usr/bin/make install -- OK" weiß man,
das alles gut ging. Nun folgt im Terminal mit Root-Rechten:

# cpanm App::perlbrew

Jetzt kann man sich überzeugen, das die darauf folgende Ausgabe wesentlich kompakter
und verständlicher ist. Sie endet hoffentlich mit:

Successfully installed App-perlbrew-0.27
1 distribution installed

Wer unter Unix rechtlich davon ausgeschlossen ist, außerhalb seines $HOME etwas zu tun,
oder das Tutorial als Experiment sieht, welches er jederzeit nach /dev/null schicken kann,
installiert perlbrew lokal (in $HOME/perl5/perlbrew) mit:

$ curl -L http://xrl.us/perlbrewinstall | bash

Damit die Brauerei ihren Betrieb aufnehmen kann, muß noch die ~/.bashrc (oder andere
Konfigurationsdatei der aktiven Shell) um folgendes erweitert werden:

PATH="$HOME/perl5/perlbrew/bin:$PATH"
source perl5/perlbrew/etc/bashrc

Nutzer der C-Shell setzen $PATH mit setenv und setzen in die zweite Zeile ein cshrc statt
dem bashrc. Die letzten Schritte der Einrichtung sind sehr einfach und werden auch erklärt,
wenn man nur perlbrew eingibt. Ähnlich hg oder git braucht es zuerst ein:

$ perlbrew init

Das Verzeichnis in dem man dies tut ist nicht wichtig. Mit

$ perlbrew available

kann man sich auflisten lassen, was derzeit aktuell ist, aber solang man das hier im
Sommer 2011 liest, wird es wohl auf ein

$ perlbrew install perl-5.14.1

hinauslaufen. Nun ist etwas Geduld gefragt, weil es einige Minuten dauert, Perl und seine
Kernmodule zu laden, kompilieren und zu testen und perlbrew dabei einfach nur schweigt.
Nach einem Neuaufruf der Shell mit exec oder einem neuen Terminalfenster und einem
einmaligen perlbrew switch 5.14.1 ist das aktuelle perl endlich aktiv und wird immer gerufen,
wenn man perl eingibt. (Der Interpreter wird klein geschrieben, die Sprache groß und PERL
schreibt nur wer es auf einen unfreundlichen Besuch aus der Perlgemeinde ankommen
lassen will. ) Um zum Systemperl zu wechseln genügt ein perlbrew off, was sich jederzeit mit:

$ perlbrew switch 5.14.1

wieder rückgängig machen lässt. Bitte beachten: alles was der Nutzer, der sich perlbrew
installierte, in der Shell tut, bezieht sich immer auf das aktive perl, egal ob man Module
installiert, Dokumentation liest, oder Werkzeuge benutzt, welche mit Perl geliefert werden.
Jedes nach dem switch geöffnete Terminal bezieht sich jetzt auf die lokale Installation
(in ~/perl5/perlbrew/perls/perl-5.14.1), auch nach einer Neuanmeldung oder Neustart des Systems.

Mein erstes Programm

Andere Einsteigertutorien nehmen sich mehr Zeit das allererste Programm zu bejubeln.
Klar, es ist es ein großartiges Gefühl mit einem simplen print "Hallo ihr da draußen" ein
richtiges Programm geschrieben zu haben, wo man doch bisher Programmieren für eine
schwarze Kunst gehalten hat. Diesen Moment der Begeisterung sollte jeder einmal
genossen haben. Und wenn man dabei nicht nachdenken muß was #include
oder class HelloWorldApp bedeutet, umso besser. Aber irgendwann meldet sich das Gehirn:
"Und wozu ist das jetzt gut? Alle Perlmodule im Verzeichnis auszugeben hätte wenigstens
noch einen praktischen Nutzen."

$ perl -e 'print "tschüß\n"'
$ perl -E 'say <*.pm>'

print kennt man vielleicht aus Ruby, Python, Java oder PHP. Es gibt den ihm folgenden Wert,
hier ein mit (doppelten) Anführungszeichen markierter Text, auf der Standardausgabe aus,
was meist die aktive Shell ist, von der aus perl gestartet wurde. Die zweite Zeile gibt alle
auf .pm endenden Dateien im aktuellen Verzeichnis aus, was meist Perl-Module sind. Jeder,
der nicht zum ersten mal ein Terminal öffnet, kann das verstehen, aber kaum eine Sprache
bringt das so kompakt ohne 2,3 andere Befehle aus dem Werkzeugkasten zu holen, die mit
dem Problem nichts zu tun haben und vom Neuling auch erst einmal begriffen werden müssen.

Mit der Option -e oder -E führt perl sofort das in (hier in einfache) Anführungszeichen gestellte
als Programm aus. Die großen Perl-Magier geben so direkt ihre Zaubersprüche ab, ohne Stab
und Editor. Im Folgenden wird jedoch ein Editor benutzt, denn das Programm wird stark wachsen.
Die Meisten haben bereits eine feste Meinung welcher Editor der beste ist und die besseren
bieten alles was während dieses Tutoriums gebraucht wird. Unentschlossene könnten Padre
oder Kephra probieren, welche beide in Perl geschrieben sind, also per cpanm beziehbar sind.
Padre bietet mehr IDE-artige Funktionen, wohingegen Kephra eher auf Konsistenz und das
schnelle Bearbeiten von Text ausgerichtet ist.

Das Projekt vorbereiten

Das neue Projekt bekommt am besten ein eigenes Verzeichnis und einen alias in der .bashrc

alias bn='perl $HOME/code/perl/betternote/bn.pl'

So kann es jederzeit einfach verwendet werden. Denn nur wer öfters benutzt was er entwickelt,
merkt auch was noch verbessert werden kann. Ebenso der Stolz auf das eigene Programm wird
sich nur so voll zeigen. Datei- und Verzeichnisnamen waren nur Vorschläge, wichtig ist nur zu
wissen, das Perlskripte meist so aufgerufen werden (perl Dateiname):

$ perl ~/perl/script.pl
$ ~/perl/script.pl

Die zweite Variante kann aber nur gewählt werden, wenn mit chmod oder über den Dateibrowser
(Rechtsklick > Eigenschaften > Zugiffsrechte) die Rechte der Datei auf ausführbar gesetzt wurden
und die erste Zeile der Datei die sogenannte Shebang enthält:

#!/usr/bin/perl

Dies macht natürlich nur unter Unix Sinn und auch nur wenn kein perlbrew verwendet wird.
Deshalb verwendete der vorgeschlagene alias die erste Variante. Windows-Nutzer legen sich
statt des alias eine Verknüpfung der .pl-Datei auf den Desktop. Einfach die Datei auswählen
(einfacher Linksklick) mit Rechts Kontextmenü aufklappen und Verknüpfung erstellen, die dann
auf den Desktop ziehbar ist.

Perls Format

Bevor es endlich wirklich losgeht, noch ein paar allgemeine Regeln, die zu kennen alles sehr
viel einfacher macht. Regel eins: Leerzeichen spielen (fast) keine Rolle. Solange man sich nicht
innerhalb der vielen Arten von Anführungszeichen befindet oder print als pri nt schreibt, ist es
vollkommen gleich, wo und wie viele Leerzeichen oder Zeilenanfänge stehen.

      print

'huhu'     ;

Regel zwei: Semikolons trennen die Befehle. Solange andere Befehle nicht eingreifen,
arbeitet perl das Programm Befehl für Befehl von oben nach unten und links nach rechts ab.
Da Zeilenenden nicht anzeigen können wo ein Befehl aufhört, macht es das Semikolon.
Auch wenn man nach dem letzten Befehl eines Programms oder Teilprogramms kein Semikolon
setzen muß, empfiehlt Perl-Guru Damian Conway es trotzdem zu tun. Das beugt späteren
Problemen vor, wenn man einen Befehl schnell mal in ein anderes Programm kopieren möchte.
Sein Buch "Perl Best Practices" enthält viele solcher nützlichen Hinweise und hat deshalb einen
hohen Stellenwert bei vielen Perl-Programmierern.

Regel drei: die Raute (#) leitet Kommentare ein. Wenn man etwas in das Programm schreiben
möchte, das der Interpreter ignorieren soll, fügt man eine Raute ein und alles von diesem Zeichen
bis zum nächsten Zeilenende gehört nicht zum ausgeführten Programm. Für längere Kommentare
nimmt man POD, das später vorgestellt wird und ein __END__ oder __DATA__ markiert das Ende
eines Programmes.

say 'yes'; # und ich dachte Perl sei schwer
say 'pound sign: #'; # ab hier ist's Kommentar

Sag es einfach

Was macht eigentlich dieses say, was man hier schon zweimal sehen konnte? Es ist eigentlich
nicht viel mehr als ein print, daß noch ein Steuerzeichen anfügt welches die Zeile beendet.
Die nächste Ausgabe beginnt dann in einer neuen. In Ruby und C nennt sich das puts,
in Python funktioniert das print auf diese Art.

Das say ist sehr praktisch, denn es läßt sich sehr leicht tippen. Die Buchstaben s, a und y liegen
auf der normalen QWERTZ-Tastatur nebeneinander. Ausserdem ist es kürzer und spart bis zu
6 Anschläge und tut letztlich genau das, was man in den meisten Fällen mit print machen will.
Es kam allerdings erst mit Version 5.10 und muß einzeln oder mit allen anderen Neuerungen
angemeldet werden, mit denen ältere Programme vermeidbare Probleme haben könnten.

use feature 'say';
# oder
use v5.10;

Benutz es einfach

Neue Projekte sollten aber darauf nicht verzichten. Deshalb wird die erste Zeile des Notizprogramms
nach der Shebang :

use v5.12;

Somit hat das Programm nicht nur Zugang zu allen neuen und interessanten Funktionen, es spart
auch eine Zeile die zuvor allen Anfängern in Perl-Foren mit der Ochsenpeitsche eingebleut wurde
und die man endlich nicht mehr so oft erwähnen muß, weil sie mit use v5.12; aufgerufen wird.

use strict;

Was dieser Befehl genau macht erklärt der nächste Abschnitt. Einfach gesagt findet er für den
Programmierer viele seiner Tippfehler.

Das use benutze heißt, weiß man aus dem Englischunterricht. Aber in Perl kann es dreierlei bedeuten.
Wenn eine Zahl folgt, prüft es die Version des laufenden perl. Ist es älter, wird sofort abgebrochen.
Ab 5.10 aktiviert es, wie bereits beschrieben, alle neuen Funktionen bis zur angegebenen Version.
Der vorhin verwendete Kommandozeilenparameter -E lädt alle verfügbaren neue Funktionen.

Folgt dem use ein Name, sucht perl nach einer gleichnamigen Datei die auf .pm ended und lädt sie
als Modul. Manche sagen auch Bibliothek dazu. Da daher 95% der Macht aller Programme kommt,
sollte der Befehl eigentlich noch vor print gelehrt werden.

Durch Gewohnheitsrecht hat sich durchgesetzt, daß Modulnamen in Camelcase also wie "SuperModul"
geschrieben werden, aber mindestens mit einem Großbuchstaben beginnen. Steht nach use etwas
Kleingeschriebenes, ist es kein Modul sondern ein Pragma, ein Befehl an Perl sich anders zu verhalten.
Nach strict ist das zweitnützlichste Pragma warnings, was perl veranlasst ausführlichere
Fehlermeldungen zu geben. Wer sich sich gerne belehren läßt, kann sogar diagnostics aktivieren.
Dann werden zu den Warnungen die Erklärungen aus perldiag (eine Seite der Perl-Dokumentation)
angezeigt.

Skalarvariablen

Selbst wer noch nie programmiert hat, kennt Variablen vom Matheunterricht. Da sind es Buchstaben,
die für eine Zahl stehen, die zu berechnen ist. Für Programmierer sieht das aber etwas anders aus.
Hier sind Variablen eine Art Kiste (Speicherplatz) in die man jederzeit einen anderen Wert hineintun
kann. (Außer in streng funktionalen Sprachen wie Haskell natürlich.) Die Namen der Kiste darf man
in Perl beliebig wählen, solange sie mit einem Buchstaben anfangen. Bei Verwendung des Pragmas
utf8 kann man sogar Umlaute oder japanische Katagana für Variablen und andere eigene Konstrukte
verwenden.

In vielen anderen Programmiersprachen gibt man den Kisten neben dem Namensschild noch eine
Inhaltsbeschreibung und zeigt so an, ob man Zahlen oder doch lieber Kartoffeln in der Kiste abzulegen
gedenkt. Bei Perl steckt diese Inhaltsangabe in einem Sonderzeichen, daß vor dem Variablennamen
steht: $, @ oder %, wobei es in diesem Teil nur um die einfachen gehen soll, die mit $ beginnen.
Das $ sieht aus wie ein S und erinnert den Benutzer, daß es ein Skalar also ein einfacher Wert ist.
Andere Sprachen unterscheiden da auch noch zwischen ganzen Zahlen, gebrochenen Zahlen,
Buchstaben, Text und vielem mehr. Aber Perl ist das alles erst einmal egal.

$n = '5';
say $n + 3;

Hier wurde ein kleiner Text (alles was in Anführungszeichen steht!) in die Kiste namens $n getan.
= weist das Ergebnis der rechten Seite der Linken zu. Eine Zeile später wird damit gerechnet.
Da Perl weiß was gemeint ist, lautet das Ergebnis natürlich 8. Manche würden sich bei sowas
die Haare raufen, weil das jede Computerlogik verletzt. Larry Wall versucht es aber "normalen"
Menschen einfach zu machen, in deren Alltag + sich auf Zahlen bezieht, nicht auf Schriftzeichen.
Dann muß halt perl den Mehraufwand betreiben und prüfen ob ein Wert auch als Zahl verstanden
werden kann, nicht der Programmierer. Ein Text wird aber nur als Zahl deutbar, wenn er auch mit
einer Ziffer beginnt. Ist die Zeichenkette (String) leer (''), entspricht das einer 0.

Wurde der Variable beim ersten Erwähnen kein Wert gegeben, ist sie nicht leer sondern hat keinen
definierten Inhalt, was $var = undef; oder undef $var; entspricht. Bei ja/nein-Entscheidungen ist '',
0 oder undef negativ, alles andere positiv.

Strikte Regeln

So wie das letzte Beispiel dort steht, würde es allerdings einen Fehler hervorrufen. Wenn man
eine Variable zum ersten mal erwähnt, muß man dazuschreiben, in welchem Bereich sie bekannt ist.
In der Informatik sagt man Gültigkeitsbereich. Das wären für den Anfang die Befehle my oder our.

my $notiz = 'Ich wollt nur mal Tach sagen.';
our $gruss = 'Tach!';

$notiz "lebt" nur bis zur nächsten schließenden, geschweiften Klammer (nur im aktuellen Block),
$gruss dagegen im ganzen "Modul". (Das war etwas gemogelt, reicht aber als erste Vereinfachung.)
Wäre kein my oder our angegeben, gäbe es diese Variable im ganzen Programm. Vor 20 Jahren,
als Perlskripte klein waren, spielte das keine Rolle, aber heute wäre es wie das Fahren ohne Gurt.
Man bräuchte nur ein Modul benutzen, daß ein Modul benutzt in dem es auch eine Variable $notiz
gibt, die während eines selbst ausgelösten Befehls verändert wird. Es könnten Wochen vergehen,
bis so eine Problemursache überhaupt gefunden wird. Deshalb schränkt man den Geltungsbereich
von Variablen möglichst stark ein und beide $notiz können koexistieren ohne voneinander Notiz
zu nehmen. Genau dafür wurde use strict; erfunden. Es zwingt immer einen Geltungsbereich zu
bestimmen, was man sonst nicht müßte und verbietet damit globale Variablen (überall bekannte).
Der angenehme Nebeneffekt davon ist, sollte man sich verschreiben ($notitz), dann gibt das einen
harten Fehler (compile error), und das Programm bricht ab, bevor es ausgeführt wurde, weil vor
dem $notitz kein my stand. Dabei gibt Perl die Zeilennummer samt Inhalt der schlimmen Stelle an
und ein Fehler weniger konnte sich einschleichen.

IO "von Hand"

Bis jetzt ist das Programm sehr klein.

#!/usr/bin/perl
use v5.12;
use warnings;
# use diagnostics; # nur wer mag

print "Notiz: ";
my $notiz = readline STDIN;

Die letzte Programmzeile liest vom Benutzer ein, was immer er in die Shell tippt und mit Enter absegnet.
Weil die Entertaste aber ein Zeichen abgibt, das die Zeile abschließt (das gleiche unsichtbare Zeichen,
daß den Unterschied zwischen print und say ausmacht), kommt auch die ganze Zeile Text in $notiz an.
readline, englisch für "lese Zeile", tut dies auch und STDIN sagt von wo, der Standardeingabe, das in den
meisten Betriebsystemen das Terminal ist, aber auch auf eine Braillezeile oder anderes umgeleitet sein kann.
Perl wäre nicht Perl wenn das nicht auch kürzer ginge. Statt readline läßt sich auch der am Anfang gezeigte
Diamantoperator nehmen. Nur wenn er ein Muster bekommt, sucht er damit die Dateinamen im aktuellen
Verzeichnis ab. Und solange das Skript keine Parameter bekommt, ließe sich sogar STDIN weglassen.

my $notiz = <>;
chomp $notiz;

Da das Zeilenendzeichen in $notiz nicht wirklich gebraucht wird, schneiden wir es mit chomp ab.
Manche schreiben lieber beides in einer Zeile: chomp( my $notiz = <> );, was Geschmackssache ist.
Bereits die äußerlich sehr unterschiedlichen Arten eine Zeile einzulesen zeigt die Wahlmöglichkeiten,
für die Perl geliebt und abgelehnt wird und die im vorigen Teil angesprochen wurden.

Doch wohin mit der Notiz? Sie sollte bis zum nächsten Programmstart erhalten bleiben, was Variablen
niemals leisten können. Dateien schon, da diese sicher auf der Festplatte lagern, zumindest solange
keine großes Magnetfeld zu Besuch kommt. Um eine Datei zu öffnen, verwendet man den Befehl open.
Dieser bekommt 3 mit Komma getrennte Information dahinter, die auch Parameter genannt werden.
1. das Handle, 2. den Modus und 3. den Dateinamen. Dateinamen sind erst einmal normaler Text.
Die möglichen Modi sind lesen (<), schreiben (>), anfügen (>>). Für Lese- und Schreibzugriffe stellt
man ein + davor (+<). Aus den Pfeilzeichen läßt sich der Sinn ableiten, wenn man sich bedenkt, daß
sie die Richtung anzeigen, in die der Datenstrom fließt. Zeigt die Spitze zum Dateinamen bedeutet
das schreiben und umgekehrt. Es lassen sich Modus und Dateiname auch als ein Text angeben
('>notizblock.txt'), ist aber nicht empfohlen. Wie Handle funktionieren, ist dem Leser schon bekannt,
denn STDIN ist so eines. Diese Schreibweise (ohne $) zu verwenden, wird aber auch nicht empfohlen,
weil es globale Variablen sind, die use strict; nicht verbieten kann. Deshalb sollte man Skalare nehmen,
in denen die Handle gespeichert werden und die genau wie Handle verwendet werden. Sobald die
Lebensdauer des Skalars erreicht ist, wird die Datei freigegeben, was auch jederzeit mit close
geschehen kann. Um die Datei für einen Schreibzugriff vorzubereiten muß getippt werden:

open my $FH, '>', 'notizblock.txt';
print $FH $notiz;
close $FH;

print oder say sind eigentlich Universalwerkzeuge um Text irgendwohin zu verschicken. Was bisher
geschah war insgeheim ein:

print STDOUT $notiz;

STDOUT ist das Handle für die Standardausgabe, was auch meist nur das Terminal ist. Wichtig ist:
zwischen Handle und Text bitte kein Komma setzen. Da print seine Nachricht auch in mehreren, durch
Komma getrennten Happen erhalten kann, braucht es einen Weg, den Handle unterscheiden zu können.
Die Nachricht wird wie folgt aus der Datei gelesen:

open my $FH, '<', 'notizblock.txt';
$notiz = <$FH>;
close $FH;

Statt readline (aka <>) geht auch read, um eine genau bestimmte Anzahl von Bytes zu lesen.

read( $FH, $notiz, 1);

Bei einem Zeichen wäre allerding getc (get character - bekomm ein Zeichen) kürzer, was vor allem für
Abfragen wie "[J/N]" effektiv ist und das chomp spart:

$notiz = getc $FH;

Das Ergebnis vom read ist die Anzahl der Zeichen, die tatsächlich gelesen werden konnten und
eof $FH kann melden ob man schon am Ende der Datei (eof - end of file) angekommen ist.

Aufgabe

Aus allem Vorgestellten ein vollständiges Programm zu machen, soll die Hausaufgabe für das nächste
Mal sein. Dafür fehlt allerdings noch eine Information. Mit dem Aufruf übernimmt ein Skript das aktuelle
Arbeitsverzeichnis ($CWD) der Shell. Also startet jemand "perl projekte/note/bn.pl" von "E:\Perl" aus
und im Code wird jetzt ein open $FH, '<', 'notizblock.txt'; ausgeführt, sucht perl "E:\Perl\notizblock.txt".
Die Textdatei sollte aber im Projektverzeichnis liegen und das Skript muß auch dort nachsehen, egal von
wo aus gestartet. Dafür bring Perl das Kernmodul (ist immer dabei) FindBin mit, welches ermöglicht:

use FindBin;
chdir $FindBin::Bin;

chdir wechselt das Arbeitsverzeichnis (wie cd in der Shell und Linux und Windows) und $FindBin::Bin ist
einfach eine mit our angemeldete Variable des Moduls, in der das gewünschte Verzeichnis gespeichert ist.
Ansonsten bitte keines der jetzt gezeigten Module benutzen.

IO Module

Auf die gezeigte Art können Dateien nur in Portionen (meist Zeilen) gelesen und geschrieben werden.
Es sei man kennt den Trick mit my $notiz = do { local $/; <$FH> };, wodurch der ganze Dateinhalt
in $notiz landet. Das ist aber auch nicht die perfekte Lösung. Zum Glück hat Uri Guttman bereits vor
Jahren File::Slurp geschrieben. Dadurch geht alles sauber, knapp, in einem Befehl und ohne Handle.

use File::Slurp;

my $notiz = read_file( 'notizblock.txt' );# lesen
write_file( 'notizblock.txt', $notiz ) ;  # schreiben
append_file( 'notizblock.txt', $notiz ) ; # anhängen

Da Golf (das kürzeste Programm gewinnt) der Sport der echten Perlprogrammierer ist, gibt es noch eine
kürzere Lösung, dank des ebenfalls legendären Brian Ingerson. Sein IO::All kann alles, daß irgendwie
mit Ein- oder Ausgabe zu tun hat. Damit läßt sich sogar ein Uhrzeitserver mit einer Zeile Perl schreiben.
Doch in diesem Teil interessiert nur lesen und schreiben von Dateien:

use IO::All;

$notiz < io('notizblock.txt'); # lesen
io('notizblock.txt') > $notiz; # auch lesen
$notiz > io('notizblock.txt'); # schreiben
$notiz >> io('notizblock.txt');# anhängen

$notiz < io('-');              # STDIN lesen

Die offizielle Dokumentation

Mit Perl kommt eine Dokumentation die recht gut ist und an der ab 5.14 wieder stärker gearbeitet wird.
Eine erste Übersicht über die dort enthaltenen Themen listet auf:

$ perldoc perl

Die Hilfe zu perldoc selber liefert (man ist ein Unix-Befehl):

$ perldoc perldoc
$ man perldoc

Beide Befehle zeigen das Gleiche an und sind beide mit dem Drücken der Taste 'q' zu beenden.
Auch die Dokumentation der Module läßt sich so lesen:

$ perldoc IO::All
$ man IO::All

Wer aber zum Beispiel mehr über die Funktion print wissen möchte, tippt in seine Shell:

$ perldoc -f print

Hierbei würde man den Systembefehl print erläutern, den die Shell kennt und nicht Perls print.

Die gleiche Dokumentation kann auch auf perldoc.org nachgeschlagen werden (oder kurz p3rl.org).
Neben der Navigation im Browser ist ein weiterer Vorteil dort, daß alle Versionen bis 5.8.8
nachgesehen werden können.
Einen kleinen Teil der perldoc gibt es auch übersetzt in der Wiki der perlcommunity.de.
Eine Liste mit fast sämtlichen anderen Perl-Ressourcen ist dort auch verlinkt.

Ausblick

Sobald man mehr als einen Wert hat, sollte man die Variablen kennen, die mit @ beginnen.
Die nächste Folge wird das behandeln, denn der Notizblock soll eine Liste an Notizen verwalten können.
Auch die verschiedenen Formate, in denen sich Werte (Literale) deklarieren lassen, werden erklärt.

---

< Teil 0: Geschichte, Philosophie | Übersicht | Teil 2: Literale, Arrays und Blöcke > Teil 4: Referenzen auf Arrays und Hashes >>

---

-- HerbertBreunung - 2011-06-30