1 2 3 4 5 6
sub foo { my %hash = @_; for my $key ( keys %hash ) { print "$key : ", $hash{$key}, "\n"; } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
sub foo { my ( $hash1, $hash2 ) = @_; # oder # my $hash1 = shift; # my $hash2 = shift; # damit liegt in $hash1 und $hash2 jeweils eine Referenz auf einen Hash # ersten Hash dereferenzieren, indem ein % vor die Referenz gestellt wird for my $key ( keys %$hash1 ) { # die einzelnen Elemente derefenzieren mit Pfeil-Operator und geschweiften Klammern print "$key : ", $hash1->{$key}, "\n"; } # zweiten Hash dereferenzieren; Kommentare siehe vorige Schleife for my $key ( keys %hash2 ) { print "$key : ", $hash2->{$key}, "\n"; } }
2017-03-30T17:41:56 LinuxerDa der Inhalt des Hashes zu einer Liste wird, geht der Bezug zum Hash verloren; Wenn Du so zwei Hashes übergeben würdest, kannst Du innerhalb der Subroutine nicht feststellen, wo der erste Hash aufhört und der zweite beginnt.
Guest Andi123Ich möchte u.a. einen Hash an ein Sub übergeben. In der Sub will ich den Inhalt von %content nur lesen, nicht ändern.
$returnValue = doSub($key, \%content);
Weder mit
noch mit
komme ich an %content ran.
1 2 3 4 5 6
sub foo { my $key = shift; my $hashref = shift; # und dann die Hash-Referenz derefenzieren }
1 2 3 4 5 6
sub foo { my $key = shift; my %hash = @_; # und dann normal mit %hash als Hash arbeiten }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
#!/usr/bin/perl use strict; use warnings; use Data::Dumper; my %content = ( 'a' => 666, 'b' => 2); print "Vorher:\n"; print Dumper \%content; change_hash(\%content); print "Nachher:\n"; print Dumper \%content; sub change_hash { print "Bin im sub.\n"; my $href = shift; print "Im sub: hash-wert von 'a' ist $href->{'a'} - aber nicht mehr lange...\n"; $href->{'a'} = 42; $href->{'c'} = 7; }
%content = @_;
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
#!/usr/bin/perl use strict; use warnings; use 5.010; use utf8; #### in einer Subroutine derefernzieren #### # ## Wir bauen uns ein Toast-Brot nach eigenen Wünschen # # sub Toast_mit ($brotart, $anzahl_der_scheiben, $referenz_auf_reihenfolge_des_belags, $referenz_auf_belaege) # sub Toast_mit { my $was = shift; # Art des Brotes my $wieviel = shift; # Menge der Brotscheiben my $reihenfolge_ref = shift; # Referenz auf Array mit den Belägen my $belag_ref = shift; # Referenz auf Hash mit Belag und Menge des Belags say "Du möchtest $wieviel × $was"; say " mit folgenden Belägen:"; for my $belag ( @{$reihenfolge_ref} ) { # Referenz auf einen Array wird durch Voranstellen von @ in ein Array dereferenziert say " ", $belag, ": ", $belag_ref->{$belag}; # Referenz auf einen Wert in einem Hash wird durch nachfolgendes -> dereferenziert # ${$belag_ref}{$belag}; # oder durch vorangestellten $ } } my %belaege = ( Butter => "4 Stück", Salami => "2 Scheiben", Petersilie => "4 Blätter", Senf => "100 g", Tomate => "1 Scheibe"); my @reihenfolge = qw(Butter Salami Tomate Senf Petersilie); Toast_mit("Roggenbrot", 3, \@reihenfolge, \%belaege);
Guest Andi123Linuxer schrieb "# und dann die Hash-Referenz derefenzieren".
Das ist dann immer die Stelle, wo ich verzweifelt google. Gibt es ein Tutorial, wo das evtl. erklärt wird? Vor allen Dingen das WIE.
1 2 3 4 5 6 7 8 9 10 11 12
#!/usr/bin/perl use warnings; use strict; my %hash = (test => 123, foo => 42, bar => 13); my $href = \%hash; print $href . "\n"; # Aha: Eine Hash-Referenz. # Jetzt wieder dereferenzieren: my %newhash = %{$href}; print $newhash{test} . "\n"; # Wieder ganz normaler Hash.