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?

Readers: 7

Articles: hide open all | hide show old branches

+9 replies
barney

2025-07-04 14:43
User since
2008-08-31
200 articles
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.
Attachments

text/plain
291 lines
benchmark_address_parsing.pl
- +7 replies
- barney
  
  2025-07-04 17:19
  
  User since
  2008-08-31
  200 articles
  BenutzerIn
  
  Mit komischen verschachtelten anonymen Subs geht es, aber schön ist es nicht.
  Attachments
  
  text/plain
  33 lines
  funny_hash.pl
  - +6 replies
  - barney
    
    2025-07-04 17:33
    User since
    2008-08-31
    200 articles
    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
      579 articles
      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
        200 articles
        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
        
        Yesterday 16:30
        
        User since
        2009-02-22
        883 articles
        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
        
        Yesterday 20:30
        
        User since
        2015-01-07
        579 articles
        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
        
        Yesterday 23:51
        
        User since
        2008-08-31
        200 articles
        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.
- Crian
  
  Today 08:36
  
  User since
  2003-08-04
  5874 articles
  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

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