¿Existe una sintaxis simple para declarar varias claves con un valor en perl?

Question

¿Existe una manera simple de declarar un hash con múltiples claves que apuntan al mismo valor en perl?

Aquí es algo similar a lo que estoy buscando (que en realidad no sé si esto funciona o no):

my $hash = { 
      a, b, c => $valA, 
      d, e, f => $valB 
      }; 

tal que ....

print $hash->{a}; #prints $valA 
print $hash->{b}; #prints $valA 
print $hash->{c}; #prints $valA 
print $hash->{d}; #prints $valB 
print $hash->{e}; #prints $valB 
print $hash->{f}; #prints $valB 

Answer 1

Usted puede escribir lo siguiente:

my %hash; 
$hash{$_} = $valA for qw(a b c); 
$hash{$_} = $valB for qw(d e f); 

Answer 2

n , no hay una sintaxis simple para esto. (De hecho, => está documentado como un alias para ,, cuyo único efecto formal es que permite una palabra oculta a la izquierda, incluso en modo estricto).

Lo mejor que podría hacer sin definir sus propios submarinos podría ser algo como

@hash{qw(a b c)} = ($valA) x 3 ; 
@hash(qw(d e f)} = ($valB) x 3 ; 

Answer 3

Sí, como Henning Makholm señaló, no hay ningún atajo directo, ya => es un alias para ,. Lo más parecido a un atajo que puedo pensar es:

foreach('a','b','c') 
{ 
    $hash->{$_}=$valA; 
} 

foreach('d','e','f') 
{ 
    $hash->{$_}=$valB; 
} 

Answer 4

Usted puede usar la asignación rebanada de hash:

my $hash = {}; 

@$hash{a,b,c} = ($valA) x 3; 
@$hash{d,e,f} = ($valB) x 3; 

Answer 5

No hay construido en sintaxis, pero siempre puede escribir la suya:

my $value = sub {map {$_ => $_[1]} @{$_[0]}}; 

my $hash = { 
    [qw(a b c)]->$value('valA'), 
    [qw(d e f)]->$value('valB'), 
}; 

say join ', ' => map "$_: $$hash{$_}", sort keys %$hash; 
# a: valA, b: valA, c: valA, d: valB, e: valB, f: valB 

Si va a hacer esto mucho, puede consultar la función Hash::Utilhv_store, que le permite cargar varias teclas exactamente con la misma ubicación de memoria.

Answer 6

La asignación también se puede hacer con instrucciones, como con map. Aquí, el mapa se expandirá en dos listas.

my $hash = { 
    (map { $_ => $valA } ('a' .. 'c')), 
    (map { $_ => $valB } ('d' .. 'f')), 
}; 

Answer 7

Me gusta usar una porción hash en un lado y el operador de lista de replicación en el otro. Yo uso el valor escalar de la matriz de teclas para averiguar cuántos valores de replicar:

@hash{ @keys } = ($value) x @keys;