Gibt es einen Trick bei dem ein hash value seinen hash key kennt? (Allgemeines zu Perl)

[thread]21678[/thread]

Gibt es einen Trick bei dem ein hash value seinen hash key kennt?

Leser: 8

Articles: hide open all | hide show old branches

+14 replies
barney

2025-07-04 14:43
User since
2008-08-31
223 Artikel
BenutzerIn
Ich habe mir ein kleines Benchmark Skript gebastelt um ein paar Module zu vergleichen. Im Skript habe ich einen Hash der eine Sub einem String zuordnet. Z.Bsp:
Code: (dl )

1 2 3 4 5 6 7 8 9

{ ... 'Sisimai::Address' => sub { my $Field = Sisimai::Address->find($HeaderLine); my @Addrs = $Field->@*; my $NumAddrs = @Addrs; say "Sisimai::Address got $NumAddrs" unless $NumAddrs == 5_000; }, }
Der String Sisimai::Address tauch sowohl links als auch rechts vom `=>` auf. Gibt es einen Trick wie man das deduplizieren kann?

Hintergrund ist natürlich dass ich vergessen hatte den String in der Subroutine anzupassen und mich dann über den Output gewundert hatte.
Anhänge

text/plain
291 lines
benchmark_address_parsing.pl
- +7 replies
- barney
  
  2025-07-04 17:19
  
  User since
  2008-08-31
  223 Artikel
  BenutzerIn
  
  Mit komischen verschachtelten anonymen Subs geht es, aber schön ist es nicht.
  Anhänge
  
  text/plain
  33 lines
  funny_hash.pl
  - +6 replies
  - barney
    
    2025-07-04 17:33
    User since
    2008-08-31
    223 Artikel
    BenutzerIn
    
    Oder mit `do`:
    
    Code: (dl )
    
    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
    
    use v5.24; use warnings; my %hash = ( do { my $key = 'AAA'; $key, sub { say $key; }; }, do { my $key = 'BBB'; $key, sub { say $key; }; }, ); $hash{'AAA'}->(); $hash{'BBB'}->();
    - +5 replies
    - haj
      
      2025-07-04 21:08
      
      User since
      2015-01-07
      582 Artikel
      BenutzerIn
      
      Ich finde die Variante mit do gut brauchbar. Aus kosmetischen Gründen würde ich das "fat comma" verwenden, weil das den Hash-Geruch verströmt:
      
      Code (perl): (dl )
      
      1 2 3 4 5 6
      
      do { my $key = 'AAA'; $key => sub { say $key; }; },
      
      ...und nein, es gibt keinen Trick, mit dem ein Hash-Wert seinen Schlüssel kennt.
      - barney
        
        2025-07-05 11:00
        
        User since
        2008-08-31
        223 Artikel
        BenutzerIn
        
        Das fette Komma macht die Sache wirklich lesbarer. Man kann die Sache auch noch ausreizen mit:
        
        Code (perl): (dl )
        
        1 2 3 4 5 6
        
        do { my $key; $key = 'AAA' => sub { say $key; }; },
        
        Last edited: 2025-07-05 11:29:05 +0200 (CEST)
      - +3 replies
      - hlubenow
        
        2025-07-07 16:30
        
        User since
        2009-02-22
        885 Artikel
        BenutzerIn
        
        1. Keine Ahnung, was ihr da mit dem "do" macht. Ist (für mich) wohl nicht so wichtig, sowas würde ich sowieso nicht machen.
        
        Code (perl): (dl )
        
        1 2 3 4 5 6 7 8 9 10 11 12 13
        
        #!/usr/bin/perl use warnings; use strict; use Data::Dumper; my %hash = ( do { my $key = 'AAA'; $key, sub { print "$key\n"; }; }, do { my $key = 'BBB'; $key, sub { print "$key\n"; }; }, ); print Dumper(\%hash);
        
        2. Es können ja mehrere Keys den gleichen Value haben:
        
        Code (perl): (dl )
        
        my %hash = ("a" => 10, "b" => 10);
        
        Für den Value 10 wäre es dann ja nicht eindeutig, ob der Key "a" oder "b" wäre. Es sei denn irgendwie in den Interna des Hashs (aber dazu weiß ich nichts).
        Wenn alle Values verschieden sind, kann man ansonsten ja mit einer Schleife über den Hash nach dem Key suchen.
        
        haj
        
        2025-07-07 20:30
        
        User since
        2015-01-07
        582 Artikel
        BenutzerIn
        
        2025-07-07T14:30:16 hlubenow
        1. Keine Ahnung, was ihr da mit dem "do" macht.
        
        Im Attachment zu barneys Artikel kannst Du den Code sehen, der zu der Frage geführt hat. Die Hash-Werte sind anonyme Subroutinen, dadurch können schon mal keine zwei Hash-Werte gleich sein. Die anonymen Subroutinen verwenden Klassen, deren Namen als Schlüssel im Hash verwendet werden sollen, und es geht dabei darum, diese Klassennamen (im Beispiel 'AAA' und 'BBB') nur an einer einzigen Stelle im Code zu schreiben.
        
        Wie soll eine Schleife über den Hash das Problem lösen?
        
        barney
        
        2025-07-07 23:51
        
        User since
        2008-08-31
        223 Artikel
        BenutzerIn
        
        Ja, mit einem Lookup auf dem Hash kann man die Frage lösen. Das ist auch am lesbarsten, weil man sich die do Blöcke spart. Die Blöcke hat man ja nur gebraucht um den Scope von $key zu begrenzen.
        
        Code (perl): (dl )
        
        1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
        
        use v5.24; use warnings; use Benchmark qw(cmpthese); sub find_key { my ($hash, $current_sub) = @_; for my $key ( keys $hash->%* ) { return $key if $hash->{$key} == $current_sub; } return "not found"; } my $subs; cmpthese( 2, $subs = { AAA => sub { say ''; say 'aaa'; say find_key($subs, __SUB__) }, BBB => sub { say ''; say 'bbb'; say find_key($subs, __SUB__) }, } );
        
        In der Praxis werde ich natürlich tunlichst all diese Tricks vermeiden und im Bedarfsfall den Schlüssel zweimal hinschreiben.
- +6 replies
- Crian
  
  2025-07-08 08:36
  
  User since
  2003-08-04
  5875 Artikel
  ModeratorIn
  
  Wenn man sowohl den Schlüssel als auch den Wert benötigt, könnte man einfach ein kleines Objekt mit beidem erstellen und diese entweder in einer Liste, oder wenn man den Zugriff als Hash braucht, als neuer Wert im Hash aufnehmen.
  s--Pevna-;s.([a-z]).chr((ord($1)-84)%26+97).gee; s^([A-Z])^chr((ord($1)-52)%26+65)^gee;print;
  
  use strict; use warnings; Link zu meiner Perlseite
  - +5 replies
  - hlubenow
    
    2025-07-08 17:59
    User since
    2009-02-22
    885 Artikel
    BenutzerIn
    
    Interessante Idee!
    Hab' das gerade mal versucht. Ich krieg' es hin, wenn ich die Objekte als Values in einen Hash tue. Als Keys ging es nicht so gut, da bekam ich einen Fehler, den ich erstmal nicht erklären konnte.
    
    Code (perl): (dl )
    
    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 warnings; use strict; package MyHash { sub new { my $classname = shift; my $self = {key => shift, value => shift}; return bless($self, $classname); } } my %h = (0 => MyHash->new("a", 10), 1 => MyHash->new("b", 20), 2 => MyHash->new("c", 30), 3 => MyHash->new("d", 40)); my $i; for $i (keys(%h)) { print "The value of the element is \"" . $h{$i}->{value} . "\".\n"; print "And the key is \"". $h{$i}->{key} . "\".\n\n"; }
    - +4 replies
    - hlubenow
      
      2025-07-09 15:17
      
      User since
      2009-02-22
      885 Artikel
      BenutzerIn
      
      Noch besser wäre es, wenn die Hash-Keys nicht einfach 0, 1, 2, 3, ... wären, sondern wenn die Keys des Hashes mit den Keys in den Objekten übereinstimmten, also hier dann "a", "b", "c", usw. wären.
      
      Dann kann man den Hash hinsichtlich der Keys wie einen normalen Hash verwenden, und wenn der Value seinen Key wissen will, kann er den aus dem Key des Objekts entnehmen. Macht Sinn.
      Last edited: 2025-07-09 15:25:13 +0200 (CEST)
      - Crian
        
        2025-07-10 08:25
        
        User since
        2003-08-04
        5875 Artikel
        ModeratorIn
        
        Ja so meinte ich das. Man muss dann halt immer noch den Getter für den eigentlichen Wert im "Wert" aufrufen, oder aber den vom Schlüssel. Dafür hat man die Flexibilität, auf beides zuzugreifen.
        
        Die Alternative ist, im Gegenzug ein zweites Hash zu erstellen, in dem die ursprünglichen Werte die Schlüssel sind und die ursprünglichen Schlüssel die Werte. Das geht natürlich nur, wenn auch die Werte unikat sind.
        
        Irgendwie finde ich die erste Lösung da aber handlicher. Da muss man sich auch später nie fragen, ob die beiden Hashes denn auch genau den gleichen Inhalt haben, und die Werte müssen nicht unikat sein.
        s--Pevna-;s.([a-z]).chr((ord($1)-84)%26+97).gee; s^([A-Z])^chr((ord($1)-52)%26+65)^gee;print;
        
        use strict; use warnings; Link zu meiner Perlseite
      - +2 replies
      - barney
        
        2025-07-10 10:27
        
        User since
        2008-08-31
        223 Artikel
        BenutzerIn
        
        In meiner ursprünglichen Frage ging es um den Aufruf von Routinen im Benchmark Modul. Da hat man nicht die Freiheit die Schnittstelle zu ändern.
        
        rosti
        
        2025-07-10 10:34
        
        User since
        2011-03-19
        3689 Artikel
        BenutzerIn
        
        2025-07-10T08:27:33 barney
        In meiner ursprünglichen Frage ging es um den Aufruf von Routinen im Benchmark Modul. Da hat man nicht die Freiheit die Schnittstelle zu ändern.
        
        Aber Du hast dafür die Freiheit, die Namen für die zu vergleichenden Codes frei vergeben zu dürfen ;)
        http://blog.rolfrost.de/
        
        The art of steam.

View all threads created 2025-07-04 14:43.