Einführung in Perl. Hashes, Referenzen, Listen von Listen

Transkript

1 Einführung in Perl Hashes, Referenzen, Listen von Listen Jörn Clausen Georg Fuellen

2 Übersicht Datentypen: Wiederholung: Skalare und Arrays Hashes Referenzen (Listen Hashes) von (Listen Hashes) Variablendeklaration, Sichtbarkeit

3 Wiederholung Skalare: $num = 1234; $string = "Hello World!" = qw{foo bar = (1,3, = Element eines Arrays: $words[1] Slice eines

4 Kontext bestimmt Verhalten von = (1, 2, 3, 2, $num $last = (4, 3, 2, 1); Überprüfung des Kontexts: wantarray sub func {... return(@foo) if wantarray;... return($foo); }

5 Tabelle von keys und values beliebiger String als Schlüssel: Hashes $days{ jan } = 31; $days{ feb } = 28; $hours = ($days{ jan } + $days{ feb }) * 24; Assoziatives Array Schlüssel ist ein String: $foo{1} = 1; $foo{1.0} = 2; $foo{ 1 } = 3; $foo{ 1.0 } = 4;

6 Definition von Hashes Zuweisung durch Liste: %days = ( jan, 31, feb, 28, mar, 31); schlecht lesbar fehleranfällig besser: %days = ( jan => 31, feb => 28, mar => 31 );

7 Zugriff auf Hashes Schlüssel eines Hashes: keys foreach $month (keys(%days)) { print $month," has ",$days{$month}," days\n"; } Reihenfolge der Schlüssel undefiniert lexikographisch sortiert: foreach $name (sort(keys(%people))) {... } values liefert Liste der Werte

8 Zugriff auf Hashes, cont. alternative Methode: while (($month,$days) = each(%days)) { print "$month has $days days\n"; } liefert in skalarem Kontext nur Schlüssel each, keys und values benutzen selben Zähler Verhalten bei Veränderung des Hashes undefiniert

9 Hash als Menge 6 aus 49, ohne Zusatzzahl: my %numbers = (); while (keys(%numbers) < 6) { my $randnum = int(rand(49)) + 1; $numbers{$randnum} = 1; } print join(", ", sort({$a <=> $b} keys(%numbers))),"\n";

10 Schlüssel oder Wert? Arten des "Vorhandenseins": %hash = ( a => 1, b => 0, c => undef ); foreach $x (qw{a b c d}) { print "$x is true\n" if $hash{$x}; print "$x is defined\n" if defined($hash{$x}); print "$x exists\n" if exists($hash{$x}); } delete($h{b})

11 Variablen-Deklaration zwei Arten von Variablen: globale und lexikalische globale Variablen von überall sichtbar lexikalische Variablen an aktuellen Block gebunden local legt neue Instanz einer globalen Variable an my deklariert lexikalische Variable lexikalische Variablen überdecken globale Variablen im Block

12 Variablen-Deklaration, cont. $foo = 42; { my $foo = 24; print $foo,"\n"; # gibt 24 aus printfoo(); } # 42 { local $foo = 84; print $foo,"\n"; # gibt 84 aus printfoo(); } # 84 print $foo,"\n"; # gibt 42 aus printfoo(); # 42 sub printfoo { print "printfoo says: $foo\n"; }

13 lokalisierte Variablen temporäres Überschreiben von defaults: foreach $x qw{ } { debug("division by zero ") if $x == 0; print 1/$x," " unless $x == 0; sleep(1); } sub debug { my ($msg) local $ = 1; print $msg; }

14 Referenzen zwei Arten: symbolische Referenzen harte, echte Referenzen Analogie zu symbolic links und hard links, link count komplexe Datenstrukturen Objekt-Orientierte Programmierung

15 symbolische Referenzen Beispiel: %joe = (name => Joe User, age => 26); %jane = (name => Jane User, age => 24); $chef = jane = keys(%$chef); print $$chef{name}," is the boss\n";

16 PSfrag replacements echte Referenzen $bar $foo = 42; $foo PSfrag replacements $foo 2 42 $bar = \$foo; $bar 1 $bar Skalar $baz = \$bar;

17 Referenzen, cont. Referenzen auf andere Datentypen: $scalar_ref = \$scalar; $array_ref = \@array; $hash_ref = \%hash; $sub_ref = \ Dereferenzierung: $scalar_value = %hash_value = %$hash_ref; $retval = &$sub_ref(@parameters);

18 Referenzen und Sichtbarkeiten link count zählt Verweise auf Variable Variable wird erst gelöscht, wenn link count Null ist Beispiel: { my $foo = 42; $bar = \$foo; } print "$foo, $$bar\n";

19 Referenzen auf Arrays und Hashes Arrays als Parameter: $prod = vectmult(\@vec1, \@vec2); Zugriff auf Elemente: $value = $$array_ref[4]; alternative Schreibweise: $value = $array_ref->[4]; Hashes: $value = $$hash_ref{foo}; $value = $hash_ref->{foo};

20 Anonyme Referenzen Arrays und Hashes: $array_ref = [ a, b, c, d ]; $word_ref = [ qw{foo bar baz} ]; $hash_ref = { jan => 31, feb => 28, mar => 31 }; [] bzw. {} statt () Referenz auf Block: my $code_ref = sub {... };

21 Listen von Listen = qw{h He Li Be B = qw{ = (\@symbols, \@amus); Zugriff: $elements[0]->[2] $elements[1]->[1] -> zwischen Klammern optional: $elements[0][2] $elements[1][1]

22 LoLs mit anonymen Referenzen = ( [ H, He, Li, Be, B, C ], [ 1, 4, 7, 9, 11, 12 ] = ( [1, 2, 3], [4, 5, 6], [7, 8, 9] = ( [ [1,2], [3,4], [5,6] ], [ [9,8], [7,6], [5,4] ] );

23 Listen von Hashes Beispiel: %joe = (name => Joe User, age => 26); %jane = (name => Jane User, age => = (\%joe, \%jane); Zugriff: $people[0]->{name} $people[1]{age}

24 LoH mit anonymen Referenzen = ( { name => Joe User, age => 26 }, { name => Jane User, age => 24 } );

25 beliebige Kombinationen: LoLs, HoHs, LoHs, HoLs %bands = ( beatles => { members => [ John, Paul, George, Ringo ], albums => [ Help, Revolver ] }, thewho => { members => [ Roger, Pete, John, Keith ], albums => [ Quadrophenia ] } ); $bands{thewho}{members}[3] = Zak

26 autovivification Zuweisung an bisher unbenutzte Struktur: $array[10] = hello ; alloziert Platz für 10 weitere Elemente $buffer[2**24] alloziert 64 MB auf einmal komplexere Datenstrukturen: $books{tolkien}{1954} = [ Lord of the Rings ]; push(@{$books{ Tolkien }{1937}}, The Hobbit );

27 Modul Data::Dumper Visualisierung use Data::Dumper; $books{tolkien}{1954} = [ Lord of the Rings ]; push(@{$books{ Tolkien }{1937}}, The Hobbit ); print Dumper \%books; Ausgabe: $VAR1 = { Tolkien => { } }; 1937 => [ The Hobbit ], 1954 => [ Lord of the Rings ]

28 Typeglobs globale Variablen werden in Symbol-Tabelle abgelegt %foo, &foo,... werden zu typeglob zusammengefaßt Schreibweise: *foo Zugriff auf einzelne Variablen: $foo = 42; print ${*foo},"\n"; filehandles als Parameter Export von Variablen in packages

29 Aliase mit Hilfe von Typeglobs: $a = 10; *b = *a; $b = 20; print $a,"\n"; Aliase für Variablen zur Erinnerung: foreach und Parameterübergabe Modul English: $OUTPUT_AUTOFLUSH statt $ selektive Aliase: *b = \$a; Konstanten: *PI = \ ; $PI = 3;

30 Referenzen auf Subroutinen Sprungtabellen: %options = ( -h => \&usage, -v => sub { $verbosity=1; }, -f => sub { $interactive=0; } ); Signalhandler: $SIG{INT} = \&cleanup; sub cleanup { # remove temporary files... exit; }

31 Closures Closure: Referenz auf Subroutine, die sich lexikalische Variablen merkt Belegung der Variablen bei der Definition der Subroutine sub greetings { my ($salutation) return sub { my ($salutant) print "$salutation $salutant\n"; } } $hello = greetings("hello"); $hi = greetings("hi"); &$hello("world!"); &$hi("bob");

32 Closures als Callback Perl/Tk: sub mkbutton { my ($parent, $title) =@_; my $button = $parent->button( -text => $title, -command => sub { print "$title pressed\n"; } ); $button->pack(); } $main->mkbutton("ok"); $main->mkbutton("cancel");