Come posso annullare un hash restituito da un metodo di una classe?

Question

Ho una classe con un metodo che restituisce un hash. Normalmente, vorrei avere il risultato in questo modo:

%resp = $myclass->sub($foo); 

E poi i membri di accesso della hash restituita in questo modo:

$resp{key}{subkey}; 

nel caso di un hash 2d.

Immagino che ci deve essere un modo per combinare questo in un unico, linea elegante, qualcosa di simile:

$myclass->sub($foo)->{key}{subkey} 

Questo ovviamente non viene dereference correttamente come Perl restituisce questo quando si cerca di eseguire il codice:

Can't use string ("1/8") as a HASH ref

Nel tentativo sequenze dereferenziamento casuali, dal guardare "References quick reference" on Perlmonks, mi si avvicinò con la seguente, che Perl non si lamenta, ma anche non restituisce quello che sto cercando:

$%{$myclass->sub($foo)}->{key}{subkey} 

Qualcuno può dirmi che cosa è la sequenza di fuga magica di dereferenziamento?

Answer 1

Basta tornare un rifhash invece di un hash:

$myclass->sub($foo)->{key}->{subkey}

Answer 2

mi piacerebbe tornare un riferimento ad hash dal sub invece. In caso contrario (probabilmente) il vostro hash è trasformato in un LISTA poi in un hash di nuovo senza motivo:

sub mysub() { 
    ... 
    return \%myhash; 
} 

C'è meno la copia coinvolti quando si ritorna il riferimento, quindi, più efficiente.

Answer 3

Cambiare il sub per restituire un riferimento ad hash avrebbe funzionato meglio, ma per ottenere la funzionalità che sono alla ricerca di:

{ $myclass->sub($foo) }->{key}{subkey} 

che creerà un riferimento hash dalla lista restituita da sub, e poi subito dereference it

Modifica: il vantaggio di restituire un hashref dal sub piuttosto che un hash (come elenco) è in gran parte una delle prestazioni. Nel caso di hashref, l'hash viene creato una sola volta e quindi acceduto. Nell'elenco di casi, l'hash viene creato, quindi convertito in un elenco, quindi creato nuovamente e quindi sottoposto a dereferenziazione. Per piccoli hash questo non richiede troppo tempo, ma per quelli più grandi, è solo un lavoro non necessario per il runtime. In sostanza, se si prevede di utilizzare i dati come elenco in alcuni punti e come hash in altri, restituire l'hash come elenco è ok. Ma se hai sempre intenzione di usarlo come un hash, restituire il riferimento è più chiaro e più veloce.

Answer 4

Quello che stai cercando di fare non è né elegante né consigliabile. In qualche modo sei riuscito a richiamare la routine in un contesto scalare (questo è ciò che corrisponde a "1/8").

Restituisce un riferimento hash.

Ora, date un'occhiata a:

#!/usr/bin/perl 

package My::Mine; 

use strict; use warnings; 

sub test { 
    my %h = (
     a => { z => 1}, 
     b => { y => 2}, 
    ); 
    return %h; 
} 

package main; 

use strict; use warnings; 

my $class = 'My::Mine'; 

print { $class->test }->{a}{z}, "\n"; 

che non funzionano. Invece, si dovrà fare:

print +{ $class->test }->{a}{z}, "\n"; 

Ora, che è elegante Vedi perldoc -f print (Non !).

Per farla breve, restituire un riferimento all'hash.

Si noti che il nuovo hash anonimo che si sta costruendo non è gratuito. Né è il costo di restituire un hash come una lista semplice da una subroutine.

Answer 5

Se si desidera sempre ottenere solo una sottochiave, scrivere una subroutine breve per farlo e dimenticare di giocare a golf la linea. Un vantaggio è che puoi facilmente aggiungere qualche controllo di integrità:

sub get_subkey { 
     my($class, $arg, $key, $subkey) = @_; 

     my $hashref = $class->method($arg); 
     return unless ref $hashref; 

     return $hashref->{$key}{$subkey}; 
     }