Farid Hajji

Perl: Einführung, Anwendungen, Referenz (2/e) [Support-Site]

Farid Hajji: Perl - Einführung, Anwendungen, Referenz
2., aktualisierte und erweiterte Auflage
Addison-Wesley Longman, ISBN 3-8273-1535-2

Kapitel 11: Subroutinen

Inhalt

• Synopsis
• Eigenschaften von Subroutinen
• Benutzerdefinierte Subroutinen
  • Aufruf von Subroutinen
    • Funktionen ohne Parameter und ohne Rückgabewert
    • Funktionen mit einem Parameter
    • Funktionen mit mehreren Parametern
    • Funktionen mit einem Rückgabewert
    • Funktionen mit mehreren Rückgabewerten
    • Funktionen, die vom Ausführungskontext abhängig sind
    • Funktionen, die ihre Parameter verändern
    • Alte Aufrufkonvention mit &
    • Vorsicht im Listenkontext
  • Definition von Subroutinen
    • Definition mit sub
    • Parameterübergabe in @_
    • Veränderung von Parameterwerten
    • Call by value mit my
    • Rückgabewerte
    • Private Variablen von Funktionen mit my
    • static-Variablen
    • Ausführungskontext und wantarray
• Eingebaute Subroutinen
  • Eigenschaften eingebauter Subroutinen
  • Skalare und Strings
  • Reguläre Ausdrücke und Mustersuche
  • Numerische Funktionen, Zeitberechnung
  • Array-, Listen- und Hashfunktionen
  • Ein- und Ausgabe, Dateien
  • Kontrollfluß und Scoping
  • Prozeßverwaltung
  • Module und Klassen
  • Sockets und Interprozeßkommunikation
  • Informationen aus Konfigurationsdateien
  • Sonstige Funktionen
• Fortgeschrittene Themen
  • Benannte Parameter und Defaultparameter
  • Closures
  • Memoizing
  • Prototypen
  • Übergabe von Filehandles und Typeglobs
  • AUTOLOAD und dynamisch erzeugte Funktionen
  • Überladen eingebauter Funktionen
• Aufgaben

Synopsis

myfunc(); myfunc; &myfunc();         # Aufruf von Subroutinen

myfunc($arg1, @list2);               # Argumente beim Aufruf
myfunc(\@list1, \@list2);            # Listen als Referenzen

# Aufruf mit benannten Argumenten:
$success = sendit( from => 'someone@somewhere.org',
                   to   => 'somebody@cs.someuniversity.edu',
                   subject => $subject,
                   body => \@lines );

$retval = myfunc(3277, "hi");        # Rückgabewert
($r1, $r2, @rest) = myfunc();        # Mehrere Rückgabewerte

$hour = (localtime(time))[2];        # Listenkontext
$ctate = localtime(time);            # Skalarer Kontext
sideeffects($i, $line);              # Void-Kontext

# Konventionelle Definition von Subroutinen:
sub myfunc {
    my ($from, $to, $subject, @body) = @_;
    # Tue etwas mit diesen Argumenten
    # Call by value: $from, $to, etc...
    # Parameter veränderbar: $_[0], $_[1], ...
}
# Definition mit benannten Argumenten:
sub myfunc {
    my %params = (
           subject  => 'testmail, please ignore', # Default-
           date     => localtime(time),           # Argumente
           @_ );
    # Tue etwas mit den Parametern
}

# Rückgabewerte bei der Definition:
sub myfunc {
    return $scalar;                   # Nur ein Skalar
    return ($val1, $val2, @list3);    # Rückgabeliste
    return wantarray ? @T : $s1;      # Kontextsensitiv
}

Beispielprogramme

lastone.pl	Letzte Anweisung == Wert der Funktion
addcumul.pl	wantarray() und kumulative Summe
closure1.pl	Das Grundprinzip der Closure
closure2.pl	Aufrufzähler und static-Variablen mit Closures
closure3.pl	Closures im Streaming-Modus: Kartesisches Produkt
closure4.pl	Einfacher Puffer. Closure mit gemeinsamen Daten
closure5.pl	Smarte Callbacks mit Closures. Simuliert GUI
fib-memoize.pl	Memoizing zur Beschleunigung der Fibonacci-Funktion
symbol.pl	Verwendet das Standardmodul Symbol für Filehandles
typglob.pl	Übergabe von Filehandles an Funktionen mit Typglobs
autoload1.pl	Eine benutzerdefinierte AUTOLOAD-Funktion
autoload2.pl	Selektive Simulation von Funktionen mit AUTOLOAD()
autoload3.pl	Laden von Funktionen aus einem persistenten Hash
autoload4.pl	Liest Funktionsdefinition bei Bedarf aus einer Datei
add.inc	Wird durch AUTOLOAD() von autoload4.pl geladen

Ergänzungen

• Memoizing mit dem Memoize-Modul:
  Mit Hilfe des Memoize-Moduls aus dem CPAN läßt sich das Memoizing noch viel einfacher gestalten. Sie müssen nicht mehr den Code einer Funktion verändern, um sich die Argumente bzw. das Ergebnis zu merken. Stattdessen rufen Sie einfach die Funktion memoize() auf und übergeben ihr den Namen der Zielfunktion. Diese wird dann so verändert, daß sie ihre Argumente/Rückgabewerte speichert.
  Ein Beispiel ist fib-memoize2.pl. Dieses Programm zeigt die Auswirkung des Memoizing auf die Fibonacci-Funktion, wie es auch in fib-memoize.pl der Fall war, jedoch unter Verwendung des Memoize-Moduls.
  Die Ausgabe von fib-memoize2.pl auf eine sehr stark belasteten Maschine ergibt:

  farid@dbgw:~/tmp> ./fib-memoize2.pl
  timethis 50: 79 wallclock secs (42.32 usr +  0.00 sys = 42.32 CPU)
  timethis 50:  0 wallclock secs ( 0.03 usr +  0.00 sys =  0.03 CPU)
              (warning: too few iterations for a reliable count)
  

  Es ist auch möglich, einen alternativen Namen für die beschleunigte Funktion zu spezifizieren:

  # fastfib() sei die memoized Version von fib():
  memoize('fib', INSTALL => 'fastfib');
  

  Eine interessante Anwendung ist auch das Ablegen des Memoizing-Caches in einem persistenten Hash, wodurch die Funktion ihre Werte sogar über Programmaufrufe hinweg memoized. Folgendes Beispiel stammt direkt aus man Memoize:

  memoize('fib', NORMALIZER   => 'n',
                 SCALAR_CACHE => [TIE, MLDBM, DB_File, $filename,
                                  O_RDWR | O_CREAT, 0666 ],
                 LIST_CACHE   => MERGE);
  
  sub n {
      my $context = wantarray() ? 'L' : 'S';
      # ... now compute the hash key from the arguments ...
      $hashkey = "$context:$hashkey";
  }
  

  Es gibt zwei Caches: SCALAR_CACHE wird verwendet, wenn die Funktion im skalaren Kontext aufgerufen wird und LIST_CACHE wenn die Funktion im Listenkontext verwendet wird. Es ist möglich, beide Caches in zwei getrennten persistenten Hashes zu speichern. Im obigen Beispiel werden diese Caches jedoch in einem einzigen persistenten Hash zusammengefaßt (MERGE) und durch eine Normalizer-Funktion (NORMALIZER) wieder voneinander unterschieden.
  Sie können auch statt normalen persistenten Hashes Storable-Persistenz erreichen (siehe Kapitel 18), indem Sie die Hilfsklasse Memoize::Storable verwenden:

  memoize('fib', SCALAR_CACHE => [TIE, Memoize::Storable, $filename, 'nstore']);
  

  Weitere Informationen zum Memoize-Modul finden Sie unter man Memoize (1999/10/31).

Lösungen zu ausgewählten Übungsaufgaben

In Vorbereitung

FAQ

In Vorbereitung

Errata

• Seite 312, splice()-Eintrag in Tabelle 11.4, Feld Bedeutung: Ersetzt Len (alle) Elemente von Array ab Offset durch Liste.
• Seite 319, unten, Seite 320, oben: Der use-Eintrag in Tabelle 11.9 ist zu streichen. Er steht in Tabelle 11.11.

[Prev] [Up] [Next]

[Alte Quelle]