L'impression des valeurs de hachage de tableaux en perl

J'ai une table de hachage de tableaux qui est déclaré comme suit:

my %hash;
push @{ $hash{ $value1[$_] } }, [ $value1[$_], $value2[$_], $value3[$_], $value4[$_], $value5[$_] ] for 0 .. $#value1;

Je veux être en mesure d'inspecter les valeurs pour chaque clé à l'aide de:

open KEYS, '>keys.txt' or die "Can't write to 'keys.txt'\n";

for my $key ( sort keys %hash ) {
    print KEYS "Key: $key contains the values: ";
    for my $value ( @{$hash{$value1}} ) {
        print KEYS "$value ";
    }   
    print KEYS "\n";
}
close(KEYS);

Alors que je peux visualiser les clés et les valeurs associées à l'aide de Data::Dumper, la sortie par le code ci-dessus donne les emplacements de la mémoire, plutôt que de valeurs, pour chaque clé. E. g:

Key: 'Value1' contains the values: ARRAY(0x7fcd8645ba68)

Même si je suis en poussant le même nombre de valeurs dans chaque tableau, chaque clé contient un nombre différent de valeurs

Est-il quelque chose de mal avec la façon dont je vais à ce sujet?

OriginalL'auteur fugu | 2013-06-27

6

Tout d'abord, dans votre boucle, vous avez
```
for my $value ( @{$hash{$value1}} ) {
    print KEYS "$value ";
}   
```
Ce qui sur terre est $value1? Je pense que vous vouliez l'utiliser $key. Toujours use strict; use warnings pour être prévenu sur les valeurs indéfinies et les variables non déclarées.

Ensuite, nous allons prendre un coup d'oeil ce qui se passe quand nous ne
```
my %hash;
push @{ $hash{ $value1[$_] } }, "(value$_)" for 0 .. $#value1;
```
au lieu de cela, c'est à dire il suffit de pousser une chaîne sur la arrayref dans la table de hachage. Ensuite, le résultat ressemble un peu comme
```
Key: Value1 contains the values: (value0)
Key: Value2 contains the values: (value1)
Key: Value3 contains the values: (value2)
```
Aha! Tout ce que nous pousser sur que arrayref est imprimé tel qu'il est. Si vous poussez un anonyme arrayref comme [...], vous obtenez le stringification de référence: ARRAY(0x1234567).

Vous voulez probablement que le contenu de ce arrayref. Facile: il suffit de déréférencement.
```
...;
print KEYS "[@$value] ";
```
ou quelque chose comme ça. Le "[...]" sont utilisés ici juste pour regrouper visuellement la sortie.

Style notes:

Veuillez considérer 3-arg open avec lexicale descripteurs:
```
my $filename = "keys.txt";
open my $keys, "<", $filename or die "Can't open $filename: $!";
```
ou de l'utilisation automatique d'erreur de manipulation:
```
use autodie;
open my $keys, "<", "keys.txt";
```
De toute façon, il est généralement important que vous incluez la raison de l'échec $! dans le message d'erreur, ou il est presque inutile.

Au lieu d'utiliser la boucle, votre code peut être plus élégant avec map et join, selon votre goût. J'aurais probablement écrit dans la boucle
```
use feature 'say';
for my $key ( sort keys %hash ) {
    say {$keys} "Key: $key contains the values: "
      . join " ", map { "[@$_]" } @{ $hash{$key} };
}
```
+1 pour aller ensemble de 9 mètres
Merci - c'est génial!
+1 explication Concise, de bons exemples et des bonus des conseils de style!

OriginalL'auteur amon
3

C'est parce que vous êtes à pousser un arrayref au lieu d'une liste de valeurs.

Comparer
```
push @array, [ $foo ];
```
à
```
push @array, $foo;
```
Les deux @arrays contient un seul élément, mais l'ancien titulaire d'un arrayref contenant $foo, tandis que le second tient juste $foo.

Si vous perdez de la place des accolades après le premier push argument, vous serez bon d'aller.

OriginalL'auteur Zaid

Vous devez vous connecter pour publier un commentaire.