Ein hervorragendes Werkzeug zum Installieren von Perl-Modulen ist cpanm ("cpanminus").

Nach dem Kompilieren und Installieren von Perl aus den Quellen per

$ ./Configure -des -Dprefix=~
$ make test
$ make install

und der Installation von cpanm per

$ curl -L http://cpanmin.us | ~/bin/perl - --self-upgrade

kann man jedes (naja, fast jedes) CPAN-Modul mit einem simplen Aufruf zur Installation hinzufügen:

$ ~/bin/cpanm <module>

Abhängkeiten von anderen Modulen werden erkannt und rekursiv aufgelöst.

Das Programm cpanm lässt sich auch standalone an Ort und Stelle installieren (aus App::cpanminus):

cd ~/bin
curl -LO http://xrl.us/cpanm
chmod +x cpanm
# edit shebang if you don't have /usr/bin/env

Protokoll und Komponenten

Das Test Anything Protocol (TAP) definiert eine textorientierte Kommunikationsschnittstelle zwischen Programmen, die Tests durchführen, den sogenannten Produzenten des Protokolls, und Steuer- und Auswertungsprogrammen, die Testprogramme aufrufen, deren Ergebnisse einsammeln und anzeigen, den sogenannten Konsumenten des Protokolls.

• Die semi-offizielle Spezifikation des TAP Protokolls findet sich in dem Dokument Test::Harness::TAP.

• Die Standard-Klasse zur Implementierung von Produzenten: Test::Builder.

• Die Standard-Klasse zur Implementierung von Konsumenten: TAP::Parser.

Die genannten Klassen sind im Perl Core, also unter jeder neueren Perl-Installation von Hause aus verfügbar.

Objektorientierte Überdeckung für Test::More

Die Klasse Test::Builder stellt eine Grundlage (Basisklasse) für das Schreiben von Testprogrammen dar. Die Klasse erlaubt, das Test Anything Protocol in vollem Umfang "zu sprechen". Allerdings implementiert die Klasse nur einen begrenzten Umfang an Testmethoden:

ok is_eq is_num isnt_eq isnt_num like unlike cmp_ok

Eine andere Möglichkeit besteht darin, das Core-Modul Test::More zu nutzen, das auf Test::Builder aufbaut und u.a. die sehr wichtige Funktion is_deeply (Vergleich von Datenstrukturen) zur Verfügung stellt.

Der Nachteil von Test::More ist allerdings, dass es nur eine Funktionssammlung, keine Klasse ist. Wer objektorientiert arbeiten möchte, findet das eventuell nicht so gut. Es lässt sich aber leicht eine saubere objektorientierte Überdeckung für Test::More schreiben, wenn man einige Punkte beachtet.

Hier eine objektorientierte Hülle für is_deeply, die analog auf alle Testfunktionen von Test::More ausgedehnt werden kann:

1 use Test::More ();
2 
3 sub is_deeply {
4     my ($self,$ref1,$ref2,$text) = @_;
5 
6     local $Test::Builder::Level = $Test::Builder::Level + 1;
7     return Test::More::is_deeply($ref1,$ref2,$text);
8 }

Erklärung der Besonderheiten:

Zeile 1:

Test::More wird geladen. Das leere Klammerpaar verhindert, dass Funktionen des Moduls importiert und damit der Namensraum der Klasse, in der wir die Methode definieren, verunreinigt wird.

Zeile 6:

Die Variable $Test::Builder::Level definiert den Abstand auf dem Callstack zwischen dem Aufrufer und der Testfunktion in Test::More. Dies wird für das Reporting der genauen Codestelle im Fehlerfall benötigt. Wir erhöhen den Abstand um 1, da wir unsere Methode in die Aufrufhierarchie einfügen. Für die Klassenvariable $Test::Builder::Level gilt dynamisches Scoping. Daher können wir ihren Wert via local lokal setzen und uns darauf verlassen, dass beim Verlassen des Blocks automatisch der ursprüngliche Wert wieder hergetellt wird.

Zeile 7:

Wir rufen die Funktion is_deeply mit Package-Präfix voll qualifiziert als Test::More::is_deeply auf, da wir die Test::More-Funktionen aus gutem Grund nicht in den Namensraum der Klasse importiert haben (siehe Erklärung zu Zeile 1).

Um Texte mit Non-ASCII-Zeichen korrekt auf ein Terminal bzw. in ein Terminal-Window ausgeben zu können, ist es notwendig, das Character Encoding der Systemumgebung zu kennen. Diese Einstellung steht typischerweise auf der Environment-Variablen $LANG.

Unter Perl stellt das Core-Modul I18N::Langinfo eine Schnittstelle zur Abfrage der Locale-Umgebung zur Verfügung. Die Abfrage für das Character-Encoding sieht so aus:

1 use I18N::Langinfo ();
2 
3 my $charset = I18N::Langinfo::langinfo(I18N::Langinfo::CODESET());
4 print $charset,"\n";

Der Text muss vor Ausgabe in dieses Encoding gewandelt werden. Dies leistet die Funktion encode():

1 use Encode ();
2 
3 print Encode::encode($charset,$text);

Eine andere Möglichkeit ist, alle Ausgaben durch einen I/O-Layer umwandeln zu lassen. Mittels binmode() wird der entsprechende I/O-Layer auf dem Ausgabekanal, hier STDOUT, registriert:

1 binmode STDOUT,":encoding($charset)";
2 print $text;

Ein typischer Anwendungsfall ist die Ausgabe der Programmdokumentation auf STDOUT oder STDERR. Diese soll unabhängig vom konkret eingestellten Encoding auf $LANG immer richtig auf dem Terminal erscheinen. Im folgenden Beispiel bekommen wir die Doku UTF-8 kodiert von pod2text geliefert, wandeln sie mit encode() in das Encoding des Systems und geben sie aus:

 1 #!/usr/bin/env perl
 2 
 3 use strict;
 4 use warnings;
 5 
 6 =encoding utf8
 7 
 8 Dies ist ein Test: ÄÖÜäöüß
 9 
10 =cut
11 
12 use I18N::Langinfo ();
13 use Encode ();
14 
15 # Programmdokumentation erzeugen. Die hereinkommenden Daten sind
16 # UTF-8 encoded. Durch Aufruf von decode() teilen wir Perl dies mit.
17 my $text = Encode::decode('UTF-8',qx/pod2text $0/);
18 
19 # Encoding des Systems ermitteln
20 my $charset = I18N::Langinfo::langinfo(I18N::Langinfo::CODESET());
21 
22 # Dokumentation im Encoding des Systems ausgeben
23 print Encode::encode($charset,$text);
24 
25 # eof

Apache2::Reload ist ein Perl-Modul, das Module einer mod_perl-Applikation automatisch neu lädt, wenn diese geändert wurden. Andernfalls müsste der HTTP-Server neu gestartet werden um die Änderungen sichtbar zu machen, was während der Entwicklung umständlich und zeitaufwändig ist.

1. Apache2::Reload von CPAN herunterladen

2. Apache Libs und Headerfiles installieren (Redhat-System)

   yum install httpd-devel.x86_64

3. Modul installieren

   perl Makefile.PL
   make
   make install

   (make test geht nicht ohne Apache Testumgebung)

4. HTTP-Config ergänzen (habe es ans Ende von perl.conf gesetzt):

   PerlModule Apache2::Reload
   PerlInitHandler Apache2::Reload

5. Apache neu starten

   apachectl restart

Das Core-Modul Pod::Usage kann einen Programm-Hilfetext aus der eingebetteten POD-Dokumentation generieren. Es geht auch einfacher:

produziert auf STDOUT

NAME
    myprog - a simple program

LICENSE
    This program is free software; you can redistribute it and/or modify it
    under the same terms as Perl itself.

Perl kennt mehrere Zeichenketten, die - numerisch interpretiert - plus und minus Unendlich bedeuten.

Beispiel: Maximum ermitteln

Aber Achtung: Diese besonderen Werte sind nicht sonderlich gut dokumentiert und scheinen bei einigen Windows-Ports nicht zu funktionieren. Siehe: http://reneeb-perlblog.blogspot.com/2010/03/unendliches-perl.html

Analog zu lexikalischen Filehandles besitzt Perl lexikalische Dirhandles. Eine Dirhandle ist ein Iterator über einem Verzeichnis. Die Operationen auf Dirhandles lassen sich objektorientiert kapseln.

Hier eine entsprechende Klasse Dirhandle mit drei Methoden: new() (Directory öffnen), close() (Directory schließen) und next() (nächster Directory-Eintrag):

Beispiel: Gib alle Einträge des Verzeichnisses $dir auf STDOUT aus

 1 use Dirhandle;
 2 
 3 my $dh = Dirhandle->new($dir);
 4 while (my $entry = $dh->next) {
 5     say $entry;
 6 }
 7 $dh->close;

Das Dirhandle-Objekt $dh kann wie jede normale Dirhandle an die Perl-Builtins readdir(), telldir(), seekdir(), rewinddir(), closedir() übergeben werden.

Mit lexikalischen Filehandles ist es in Perl leicht möglich, File-I/O objektorientiert zu kapseln. Hier zur Veranschaulichung eine Klasse Filehandle mit drei Methoden: new() (Datei öffnen), close() (Datei schließen) und slurp() (Datei komplett einlesen):

Beispiel: Lies eine Datei komplett ein und gib sie auf STDOUT aus

 1 use Filehandle;
 2 
 3 my $fh = Filehandle->new('<',$file);
 4 print $fh->slurp;
 5 $fh->close;

Der Clou: Die Filehandle $fh kann unabhängig von der Klasse wie jede andere Perl-Filehandle benutzt werden, z.B. mit dem Diamant-Operator <> oder jeder anderen Filehandle-Operation wie read(), write() usw. Obiges Programm lässt sich also auch so implementieren:

 1 use Filehandle;
 2 
 3 my $fh = Filehandle->new('<',$file);
 4 while (<$fh>) {
 5     print;
 6 }
 7 $fh->close;

Ich weiß nicht, wann Perl mir mal abgestürzt ist, aber jetzt bin ich auf einen Fall gestoßen:

$ ./test.pl
Segmentation fault

Perl-Version (andere habe ich nicht probiert):

$ perl -v
This is perl, v5.10.1 (*) built for i686-linux

Variationen

Wenn $s kein In-Memory File ist, geht es.

Bei $s =~ s/./xx/; geht es (ohne g Modifier).

Bei $s =~ s/./x/g; geht es (der String wird nicht länger).

Schließen von STDERR vor dem s/// ändert nichts.

Perltidy stellt die Syntax von Perl-Code farbig und mit Fontattributen wie kursiv und fett dar, wenn man den Code mit Option -html nach HTML wandelt. Ich nutze dieses Feature, um lesbareren Perl-Code für mein Blog zu generieren.

Für die Einbettung des generierten HTML-Codes in eigene HTML-Seiten sind allerdings kleinere Sonderbehandlungen nötig.

Anpassung der Stylesheet-Definitionen

Perltidy generiert mit

$ perltidy -html -ss >FILE.css

eine Stylesheet-Datei, die die Definitionen der CSS-Klassen für die Syntaxelemente enthält und in die eigenen HTML-Seiten eingebunden werden kann:

/* default style sheet generated by perltidy */
body {background: #FFFFFF; color: #000000}
pre { color: #000000;
      background: #FFFFFF;
      font-family: courier;
    }

.c  { color: #228B22;} /* comment */
.cm { color: #000000;} /* comma */
.co { color: #000000;} /* colon */
.h  { color: #CD5555; font-weight:bold;} /* here-doc-target */
.hh { color: #CD5555; font-style:italic;} /* here-doc-text */
.i  { color: #00688B;} /* identifier */
.j  { color: #CD5555; font-weight:bold;} /* label */
.k  { color: #8B008B; font-weight:bold;} /* keyword */
.m  { color: #FF0000; font-weight:bold;} /* subroutine */
.n  { color: #B452CD;} /* numeric */
.p  { color: #000000;} /* paren */
.pd { color: #228B22; font-style:italic;} /* pod-text */
.pu { color: #000000;} /* punctuation */
.q  { color: #CD5555;} /* quote */
.s  { color: #000000;} /* structure */
.sc { color: #000000;} /* semicolon */
.v  { color: #B452CD;} /* v-string */
.w  { color: #000000;} /* bareword */

Anpassung 1

Die CSS-Definitionen für <body> und <pre> am Anfang sollten im Falle einer Einbettung nicht vorkommen, da diese an anderer Stelle definiert sind. Sie lassen sich mit grep wegfiltern.

$ perltidy -html -ss | grep '^\.'

Anpassung 2

Die Namen der CSS-Klassen bestehen aus ein oder zwei Buchstaben, was zu Nameclashes führen kann. Dies verbessere ich, indem ich dem Klassennamen einen Präfix voranstelle. Ich wähle "pt-".

$ perltidy -html -ss | grep '^\.' | sed -e 's/^\./.pt-/'

Resultierende CSS-Datei

.pt-c  { color: #228B22;} /* comment */
.pt-cm { color: #000000;} /* comma */
.pt-co { color: #000000;} /* colon */
.pt-h  { color: #CD5555; font-weight:bold;} /* here-doc-target */
.pt-hh { color: #CD5555; font-style:italic;} /* here-doc-text */
.pt-i  { color: #00688B;} /* identifier */
.pt-j  { color: #CD5555; font-weight:bold;} /* label */
.pt-k  { color: #8B008B; font-weight:bold;} /* keyword */
.pt-m  { color: #FF0000; font-weight:bold;} /* subroutine */
.pt-n  { color: #B452CD;} /* numeric */
.pt-p  { color: #000000;} /* paren */
.pt-pd { color: #228B22; font-style:italic;} /* pod-text */
.pt-pu { color: #000000;} /* punctuation */
.pt-q  { color: #CD5555;} /* quote */
.pt-s  { color: #000000;} /* structure */
.pt-sc { color: #000000;} /* semicolon */
.pt-v  { color: #B452CD;} /* v-string */
.pt-w  { color: #000000;} /* bareword */

Anpassung des HTML-Codes

Perltidy erzeugt mit

$ perltidy -html -pre <FILE >FILE.html

eine Quelltext-Darstellung in HTML. Diese kann in die eigene Seite eingebunden werden.

Anpassung 1

Der HTML-Code ist in ein <pre> ohne Klassenanabe eingefasst. Das CSS-Layout dieses <pre> lässt sich also nicht gezielt anpassen. Am besten filtert man es weg und setzt den HTML-Code in ein eigenes <pre>.

$ perltidy -html -pre <FILE | egrep -v '^</?pre>'

Anpassung 2

Die CSS-Klassennamen müssen an die oben gewählten Namen in der Stylesheet-Datei angepasst werden.

$ perltidy -html -pre | egrep -v '^</?pre>' | sed -e 's/class="/class="pt-/g'

Resultierender HTML-Code

Aus

print "Hello world!\n";

wird im HTML-Output (Umbruch hinzugefügt)

<span class="pt-k">print</span> <span class="pt-q">
  &quot;Hello world!\n&quot;</span><span class="pt-sc">;</span>

und im Browser

print "Hello world!\n";

Ist eine FAQ (s. perldoc -q occurrences), aber ich vergesse immer die genaue Syntax, da ich tr/// selten nutze und es mehrere Funktionen in sich vereint:

$n = $str =~ tr/\n//;

$n ist in diesem Fall die Anzahl der Zeilenumbrüche in $str.

Vielleicht trivial, aber mir war die Antwort bislang nicht klar: Wie gebe ich eine Gleitkomma-Zahl aus, ohne dass Stellen wegfallen oder überflüssige Nullen am Ende erscheinen?

Bei der Ausgabe von Gleitkommazahlen habe ich bislang automatisch zu printf/sprintf und %f gegriffen, aber das Format-Element %f formatiert die Zahlen ja immer auf eine feste Anzahl an Stellen und rundet auf die letzte Stelle. Z.B.

my $x = 0.123456789;
printf "%f",$x;

ergibt

0.123457

(%f formatiert/rundet per Default auf 6 Nachkommastellen)

Natürlich kann ich die Anzahl der Stellen groß wählen, aber dann bekomme ich u.U. zusätzliche Stellen, wenn die betreffende Zahl binär nur näherungsweise dargestellt werden kann:

my $x = 0.123456789;
printf "%.20f",$x;

ergibt

0.12345678899999999734

Andererseits erhalte ich am Ende überflüssige Nullen bei Zahlen, die dezimal weniger als die vorgegebenen Stellen besitzen:

my $x = 0.5;
printf "%.20f",$x;

ergibt

0.50000000000000000000

Was tun?

Die Lösung ist (anscheinend) einfach: Ich gebe die Zahl nicht als Zahl sondern als String aus! D.h. im Falle von printf/sprintf mit Format-Element %s!

Damit erhalte ich, was ich will. Die Zahl mit allen Stellen und nicht mehr

my $x = 0.123456789;
printf "%s",$x;

0.123456789

und ohne überflüssige Nullen

my $x = 0.5;
printf "%s",$x;

0.5

Bei näherer Überlegung leuchtet das ein, da Perl intern neben der (binären) numerischen Repräsentation eine Stringrepräsentation des Werts speichert, welche anfänglich genau der Zeichenfolge bei der Zuweisung entspricht.

Schlussfolgerung: Programme, die nicht rechnen, sondern Gleitkommazahlen nur einlesen und wieder ausgeben, sollten, um Verfälschungen auszuschließen, diese bei der Ausgabe grundsätzlich als Strings und nicht als Zahlen behandeln.

Für den Umgang mit Symlinks stellt Perl eine Reihe von Builtins zur Verfügung, die nicht unbedingt offensichtlich sind. Hier eine kurze Übersicht:

$bool = -l $path

Test auf Symlink.

@stat = lstat $path

Dateisystem-Eigenschaften des Symlink.

$destPath = readlink $path

Ziel des Symlink.

$bool = symlink $path,$destPath

Erstelle Symlink $path mit Ziel $destPath. Liefert 0 im Fehlerfall.

Wie ermittele ich, welche Perl-Module über das Grundsystem hinaus installiert wurden?

Die Antwort liefert das Kommando:

$ perldoc perllocal

Das Ergebnis ist ein formatiertes POD-Dokument, das die Installationshistorie aller per make install oder ./Build install installierten Module aufführt.

Das Dokument wird mit der Installation des ersten Moduls angelegt. Unmittelbar nach Installation des Core-Systems ist es noch nicht vorhanden, da noch kein zusätzliches Modul installiert wurde.

Mit jeder Modul-Installation wird ein Eintrag am Ende hinzugefügt. Wird ein Modul mehrfach installiert, taucht es mehrfach auf.

Programm

Liefere die Namen der zusätzlich installierten Module, alphabetisch sortiert, ohne Doubletten:

 1 #!/usr/bin/env perl
 2 
 3 use strict;
 4 use warnings;
 5 
 6 my %mod;
 7 my $cmd = 'perldoc -u perllocal';
 8 open(my $fh,'-|',$cmd) or die "ERROR: open failed ($!)";
 9 while (<$fh>) {
10     if (/^=head2.*\|(.*)>/) {
11         $mod{$1} = 1;
12     }
13 }
14 close($fh) or die qq|ERROR: Command failed: "$cmd" (Exit Code: $?)\n|;
15 
16 for my $mod (sort keys %mod) {
17     print "$mod\n";
18 }
19 
20 # eof

Der Speicherbedarf von einzelnen Perl-Variablen und komplexeren Datenstrukturen lässt sich mit Devel::Size ermitteln. Hier die Werte für Perl 5.10 auf einem 32-Bit System.

(Eine andere Betrachtung - Messung des verbrauchten virtuellen Speichers bei großen Datenstrukturen - hat Peter J. Holzer angestellt: http://www.hjp.at/programming/perl/memory/)

Skalare

Perl alloziert bei Strings jeweils 4 Bytes im Voraus, vermutlich um jedes UTF-8 Zeichen speichern zu können. Obige Berechnung geht von 1-Byte-Zeichen aus. Enthält der String UTF-8 Zeichen mit 2, 3 oder 4 Byte, vergrößert sich der Platzbedarf entsprechend.

Arrays

Perl vergrößert ein Array schrittweise auf 4, 8, 16, 32, 64, ... Elemente. D.h. wird das 4. Element zugewiesen, vergößert Perl intern schon auf 8 Elemente usw. Für jedes Element alloziert Perl einen Pointer (4 Bytes). Die angegebene Größe ist der Netto-Speicherbedarf des Array, d.h. der Speicherbedarf der (skalaren) Werte kommt noch hinzu.

Hashes

Perl vergrößert einen Hash schrittweise auf 8, 16, 32, 64, ... Elemente. D.h. wird das 8. Element zugewiesen, vergößert Perl intern auf 16 Elemente usw. Für jeden Key alloziert Perl vorab einen Pointer (4 Bytes). Zusätzlich kommt mit zunehmender Anzahl Buckets ein wachsender Overhead von 9, 10, 11, ... Bytes je Key hinzu. Die Größe des Key geht auch mit ein. Bei der Messung unten ist der Key der String "EintragNNNN", also 11 Zeichen lang. Die angegebene Größe ist der Netto-Speicherbedarf des Hash, d.h. der Speicherbedarf der Werte kommt noch hinzu.

Messung

Perl Version: 5.012001
Skalar ohne Wert: 16 Bytes
Referenz: 16 Bytes
Integer: 16 Bytes
Float: 24 Bytes
String - leer: 28 Bytes
String - 1 1-Byte Zeichen: 28 Bytes (Diff: 0)
String - 2 1-Byte Zeichen: 28 Bytes (Diff: 0)
String - 3 1-Byte Zeichen: 28 Bytes (Diff: 0)
String - 4 1-Byte Zeichen: 32 Bytes (Diff: 4)
String - 5 1-Byte Zeichen: 32 Bytes (Diff: 0)
String - 6 1-Byte Zeichen: 32 Bytes (Diff: 0)
String - 7 1-Byte Zeichen: 32 Bytes (Diff: 0)
String - 8 1-Byte Zeichen: 36 Bytes (Diff: 4)
String - 9 1-Byte Zeichen: 36 Bytes (Diff: 0)
String - 10 1-Byte Zeichen: 36 Bytes (Diff: 0)
String - 11 1-Byte Zeichen: 36 Bytes (Diff: 0)
String - 12 1-Byte Zeichen: 40 Bytes (Diff: 4)
String - 16 1-Byte Zeichen: 44 Bytes (Diff: 4)
String - 20 1-Byte Zeichen: 48 Bytes (Diff: 4)
Array - leer: 36 Bytes
Array - 4 Elemente: 52 Bytes (Diff: 16) - 13.0 Bytes/Key
Array - 8 Elemente: 84 Bytes (Diff: 32) - 10.5 Bytes/Key
Array - 16 Elemente: 148 Bytes (Diff: 64) - 9.2 Bytes/Key
Array - 32 Elemente: 276 Bytes (Diff: 128) - 8.6 Bytes/Key
Array - 64 Elemente: 532 Bytes (Diff: 256) - 8.3 Bytes/Key
Hash - leer: 68 Bytes
Hash - 4 Keys: 248 Bytes (Diff: 180) - 62.0 Bytes/Key
Hash - 8 Keys: 460 Bytes (Diff: 212) - 57.5 Bytes/Key
Hash - 16 Keys: 820 Bytes (Diff: 360) - 51.2 Bytes/Key
Hash - 32 Keys: 1604 Bytes (Diff: 784) - 50.1 Bytes/Key
Hash - 64 Keys: 3172 Bytes (Diff: 1568) - 49.6 Bytes/Key
Hash - 128 Keys: 6308 Bytes (Diff: 3136) - 49.3 Bytes/Key
Hash - 256 Keys: 13604 Bytes (Diff: 7296) - 53.1 Bytes/Key
Hash - 512 Keys: 25124 Bytes (Diff: 11520) - 49.1 Bytes/Key
Hash - 1024 Keys: 54308 Bytes (Diff: 29184) - 53.0 Bytes/Key

Programm

 1 #!/usr/bin/env perl
 2 
 3 use strict;
 4 use warnings;
 5 
 6 use Devel::Size;
 7 
 8 print "Perl Version: $]\n";
 9 
10 my $s1;
11 print 'Skalar ohne Wert: ',Devel::Size::size(\$s1)," Bytes\n";
12 
13 my $s2 = \$s1;
14 print 'Referenz: ',Devel::Size::size(\$s2)," Bytes\n";
15 
16 my $s3 = 4711;
17 print 'Integer: ',Devel::Size::size(\$s3)," Bytes\n";
18 
19 my $s4 = 1234.567;
20 print 'Float: ',Devel::Size::size(\$s4)," Bytes\n";
21 
22 my $s5 = '';
23 my $nLast = Devel::Size::size(\$s5);
24 print "String - leer: $nLast Bytes\n";
25 
26 for my $i (1..12,16,20) {
27     $s5 = 'x'x$i;
28     my $n = Devel::Size::size(\$s5);
29     print "String - $i 1-Byte Zeichen: $n Bytes (Diff: ",$n-$nLast,")\n";
30     $nLast = $n;
31 }
32 
33 my @a1;
34 $nLast = Devel::Size::size(\@a1);
35 print "Array - leer: $nLast Bytes\n";
36 
37 for my $i (4,8,16,32,64) {
38     my @a2 = (1..$i);
39     my $n = Devel::Size::size(\@a2);
40     my $diff = $n-$nLast;
41     my $avg = $n/$i;
42     printf "Array - $i Elemente: $n Bytes (Diff: $diff) - %.1f Bytes/Key\n",
43         $avg;
44     $nLast = $n;
45 }
46 
47 my %h1;
48 $nLast = Devel::Size::size(\%h1);
49 print "Hash - leer: $nLast Bytes\n";
50 
51 for my $i (4,8,16,32,64,128,256,512,1024) {
52     my %h2;
53     for (my $j = 1; $j <= $i; $j++) {
54         $h2{sprintf 'Eintrag%04d',$j} = $j;
55     }
56     # @h2{(1..$i)} = (1..$i);
57     my $n = Devel::Size::size(\%h2);
58     my $diff = $n-$nLast;
59     my $avg = $n/$i;
60     printf "Hash - $i Keys: $n Bytes (Diff: $diff) - %.1f Bytes/Key\n",$avg;
61     $nLast = $n;
62 }
63 
64 # eof

#!/usr/bin/env perl

Mit dieser Shebang-Zeile wird der Perl-Interpreter über die Environment-Variable $PATH gesucht. D.h. die Shebang-Zeile muss nicht angepasst werden, wenn das Skript in mehreren Umgebungen mit unterschiedlichen Installationspfaden laufen soll.