Fragen zu Hashs (Allgemeines zu Perl)

[thread]19707[/thread]

Fragen zu Hashs

Tags: perl5 hash Ähnliche Threads

Leser: 16

Articles: hide open all | hide show old branches

+5 replies
panni

2015-07-01 10:43
User since
2012-02-15
23 Artikel
BenutzerIn
Hallo!

Gibt es irgendwo eine einfache :) und in deutsch geschriebene Erklärung was den Unterschied zwischen einem Hash und der Referenz eines Hashs ausmacht?

Ich akzeptiere, dass ich manche Hashs nur per Referenz übergeben kann (und eine normale Variablenzuweisung nicht klappt), aber ich würde gern für mich selbst wissen und verstehen warum.

Weiterhin verstehe ich nicht, warum ich bei Subroutinen ein Hash nur am Ende der Variablenkette übergeben kann.

So kommen die Werte bei
Code (perl): (dl )

&subroutine($a, $b, %hash);
korrekt in der Sub an, aber bei
Code (perl): (dl )

&subroutine(%hash, $a, $b);
nicht.

Was passiert eigentlich, wenn ich mehrere Hashs an eine Subroutine übergeben will?

Ja, also wenn jemand dazu einen Text hat, gerne hier posten.

Danke!
- GwenDragon
  
  2015-07-01 12:31
  
  User since
  2005-01-17
  14748 Artikel
  Admin1
  
  Ein Hash wie %hash expandiert bei der Parameterübergabe nach (Name1,Wert1,Key2,Wert2)
  
  subroutine($a, $b, %hash) wird zu subroutine($a, $b, (Name1,Wert1,Key2,Wert2);
  Wenn du dann in der Subroutine dann
  my $param1 = shift;
  my $param2 = shift;
  my %hash = @_;
  einliest, wird dem %hash dann der Rest der Liste zugewiesen.
  
  subroutine(%hash, $a, $b, %hash) wird zu subroutine((Name1,Wert1,Key2,Wert2),$a, $b);
  Wenn du dann in der Subroutine dann
  my $param1 = shift;
  my $param2 = shift;
  my %hash = @_;
  einliest, klappt sowas nicht mehr.
  
  Wenn du Arrays oder Hashes übergeben willst, dann nur über eine Referenz, die dann aber in der Subroutine dann auflösen musst.
  
  Ich hoffe ich konnet es irgendwie erklären.
  die Drachin Gwen
  
  Meine Perl-Artikel · perldev – verschiedene Perl-Versionen unter Windows starten
- Muffi
  
  2015-07-01 15:26
  User since
  2012-07-18
  1465 Artikel
  BenutzerIn
  Eine eigentümliche Eigenart von Perl ist, dass man einen Datentyp Hash nicht als Parameter übergeben kann.
  
  Du wirst jetzt sagen: Geht doch!
  Nicht so wirklich. Was Perl macht, wenn du einen Hash übergibst ist, es walzt diesen Hash auseinander und übergibt ihn als einzelne Parameter.
  Klingt komisch, ist komisch, ist aber halt so. Und wenn mans gewohnt ist auch gar nicht so schlimm.
  
  Also Wenn du schreibst
  
  Code (perl): (dl )
  
  subroutine($a, $b, %hash)
  
  dann machst du in Wirklichkeit:
  
  Code (perl): (dl )
  
  subroutine($a, $b, $hash_key1, $hash_value1, $hash_key2, $hash_value2, ...)
  
  Und auf der anderen Seite kannst du dann $a wieder zuweisen, $b wieder zuweisen und Perl recht einfach sagen: Mach mir aus dem Rest, der ankommt wieder einen Hash. D.h. da wird aus dem Salat wieder ein neuer Hash gebastelt.
  Wenn du nun 2 Hashes übergibst, dann gibts auch 2mal diesen Salat hintereinander. Und dann hast du ein Problem, weil Perl nicht mehr weiß wo Salat1 aufhört (Hash1) und Salat2 (Hash2) anfängt.
  Das gleiche Problem hast du, wenn nach dem Hash noch Parameter kommen. Also wo hört der Salat auf und wo fangen die Parameter an.
  
  In diesem Fall ( und im Zweifelsfall eigentlich immer) übergibt man Referenzen. Eine Referenz ist sowas wie eine Beschreibung oder auch Adresse wo im Computerspeicher dieser Hash liegt.
  
  Also
  
  Code (perl): (dl )
  
  subroutine($a, $b, \%hash1, \%hash2, ...)
  
  übergibt keinen Salat, sondern neben $a und $b einfach nur 2 Adressen. Und mit diesen 2 Adressen kriegst du auf der anderen Seite wieder deine Hashes.
  Last edited: 2015-07-01 15:33:12 +0200 (CEST)
  1 + 1 = 10
- +2 replies
- Raubtier
  
  2015-07-01 17:02
  
  User since
  2012-05-04
  1075 Artikel
  BenutzerIn
  
  Hallo panni,
  
  das gleiche Verhalten hast du nicht nur mit Hashes, sondern auch mit Arrays.
  
  Also ein Beispiel:
  
  Nehmen wir an, dass $scalar=1 und @array=qw(1 2);.
  
  subroutine($scalar, @array) ist dasselbe wie subroutine(1, 1, 2), daher kann innerhalb der subroutine nicht mehr entschieden werden, ob überhaupt ein Array übergeben wurde und wenn ja, wo. Bei @a2=(1,1) würde subroutine(@a2, 2) ebenfalls dasselbe tun.
  
  Arrays können also auch nur als Referenz übergeben werden, ansonsten sieht es innerhalb der sub so aus, als wären alle Array-Elemente einzeln übergeben worden. Das ist hier also analog zur Übergabe eines Hashes.
  
  Allgemein: in Perl übergibt man eine Liste von skalaren Werten an eine sub - und Referenzen sind Skalare, Arrays und Hashes werden zu Listen von Skalaren expandiert.
  
  Und noch ein allgemeiner Hinweis: bitte rufe Subs ohne das & auf, da dieses Prototypen überschreibt.
  - betterworld
    
    2015-07-01 18:44
    User since
    2003-08-21
    2614 Artikel
    ModeratorIn
    
    Hier noch ein weiterer Unterschied, der (glaube ich) noch nicht genannt wurde:
    
    Einen Hash kann man nicht als Wert in einem anderen Hash oder in einem Array speichern. Da kann man nämlich nur Skalare speichern, wenn auch beliebig viele. Eine Referenz ist ein Skalar, und somit ist auch eine Hashreferenz ein Skalar. Daher muss man immer Hashreferenzen benutzen, wenn man Datenstrukturen verschachteln möchte:
    
    Code: (dl )
    
    1 2 3 4 5 6
    
    my %hash1 = (name => "Heinz"); my %hash2 = (name => "Karl"); my @array; $array[0] = \%hash1; $array[1] = \%hash2;
    
    Hier kommt man um Hashreferenzen nicht herum, weil das Array den Hash nicht anders aufnehmen würde.
    
    Weitere Unterschiede gibt es bei Referenzen auf geblesste Hashes. Diese sind nämlich (fast immer) die Datenstruktur, auf denen ein Objekt basiert.
    Lieblingsmodule: IPC::System::Simple, Path::Class

View all threads created 2015-07-01 10:43.