¿Cómo puedo obtener una parte única de hash en Perl?

Question

¿Hay alguna manera de obtener un sub-hash? ¿Necesito usar una porción hash?

Por ejemplo:

%hash = (a => 1, b => 2, c => 3); 

sólo quiero

%hash = (a => 1, b => 2); 

Answer 1

Hash slices devuelve los valores asociados con una lista de claves. Para obtener una tajada de hash se cambia el sello a @ y proporcionar una lista de claves (en este caso "a" y "b"):

my @items = @hash{"a", "b"}; 

A menudo se puede utilizar un operador de palabra cita para producir la lista:

my @items = @hash{qw/a b/}; 

también puede asignar a una rebanada de hash, así que si quieres un nuevo hash que contiene un subconjunto de otro hash que se puede decir

my %new_hash; 
@new_hash{qw/a b/} = @hash{qw/a b/}; 

Mucha gente va a utilizar un map en lugar de rodajas de patata:

my %new_hash = map { $_ => $hash{$_} } qw/a b/; 

A partir de Perl 5.20.0, usted puede obtener las claves y los valores en un solo paso si utiliza el sigilo% en lugar del @ sigilo:

my %new_hash = %hash{qw/a b/}; 

Answer 2

Un hash es un contenedor desordenada, pero el término segmento en realidad sólo tiene sentido en términos de un contenedor de pedido. Tal vez investigar el uso de una matriz. De lo contrario, puede que tenga que eliminar todos los elementos que no desea producir su 'sub-hash'.

Answer 3

Usted probablemente querrá para armar una lista de claves que desee:

my @keys = qw(a b); 

Y a continuación, utilizar un bucle para hacer el hash:

my %hash_slice; 
for(@keys) { 
    $hash_slice{$_} = %hash{$_}; 
} 

O:

my %hash_slice = map { $_ => $hash{$_} } @keys; 

(Mi preferencia es la segunda, pero la que más te guste)

Answer 4

Demasiada programación funcional me lleva a pensar primero en zip.

Con List::MoreUtils instalado,

use List::MoreUtils qw(zip); 

%hash = qw(a 1 b 2 c 3); 
@keys = qw(a b); 
@values = @hash{@keys}; 
%hash = zip @keys, @values; 

Por desgracia, el prototipo de la Lista :: de zip MoreUtils inhibe

zip @keys, @hash{@keys}; 

Si realmente quiere evitar la variable intermedia, podría

zip @keys, @{[@hash{@keys}]}; 

O simplemente escriba su propia zip sin el prototipo problemático. (Esto no necesita List :: MoreUtils en absoluto.)

sub zip { 
    my $max = -1; 
    $max < $#$_and $max = $#$_ for @_; 
    map { my $ix = $_; map $_->[$ix], @_; } 0..$max; 
} 

%hash = zip \@keys, [@hash{@keys}]; 

---

Si usted va a ser la mutación en el lugar,

%hash = qw(a 1 b 2 c 3); 
%keep = map +($_ => 1), qw(a b); 
$keep{$a} or delete $hash{$a} while ($a, $b) = each %hash; 

evita la copia extra que los map y zip soluciones incurren. (Sí., Mutando el hash mientras se está interactuando sobre que es seguro ... siempre y cuando la mutación sólo se está eliminando el par más recientemente iterada)

Answer 5

Fwiw, utilizo Moose :: Autobox aquí:

my $hash = { a => 1, b => 2, c => 3, d => 4 }; 
$hash->hslice([qw/a b/]) # { a => 1, b => 2 }; 

En la vida real, utilizo esto para extraer "nombre de usuario" y "contraseña" de un envío de formulario, y pasarlo a Catalyst's $c->authenticate (que espera, en mi caso, un hashref que contenga el nombre de usuario y contraseña, pero nada más)

Answer 6

embargo, otra forma:

my @keys = qw(a b); 
my %hash = (a => 1, b => 2, c => 3); 
my %hash_copy; 
@hash_copy{@keys} = @hash{@keys}; 

Answer 7

nuevo en Perl 5.20 es rodajas de patata que vuelven claves, así como los valores mediante el uso de% como en la última línea aquí:

my %population = ('Norway',5000000,'Sweden',9600000,'Denmark',5500000); 
my @slice_values = @population{'Norway','Sweden'}; # all perls can do this 
my %slice_hash = %population{'Norway','Sweden'}; # perl >= 5.20 can do this!