Comment puis-je imprimer le contenu d'un hachage en Perl?

Je continue à imprimer mon hachage en tant que # de buckets / # alloué. Comment imprimer le contenu de mon hachage?

Sans utiliser une whileboucle serait le plus préférable (par exemple, une seule ligne serait le meilleur).

Data :: Dumper est votre ami.

use Data::Dumper;
my %hash = ('abc' => 123, 'def' => [4,5,6]);
print Dumper(\%hash);

sortira

$VAR1 = {
          'def' => [
                     4,
                     5,
                     6
                   ],
          'abc' => 123
        };

Facile:

print "$_ $h{$_}\n" for (keys %h);

Élégant, mais en fait 30% plus lent (!):

while (my ($k,$v)=each %h){print "$k $v\n"}

Voici comment imprimer sans utiliser Data::Dumper

print "@{[%hash]}";

À des fins de débogage, j'utiliserai souvent YAML.

use strict;
use warnings;

use YAML;

my %variable = ('abc' => 123, 'def' => [4,5,6]);

print "# %variable\n", Dump \%variable;

Résulte en:

# %variable
---
abc: 123
def:
  - 4
  - 5
  - 6

D'autres fois, j'utiliserai Data::Dump. Vous n'avez pas besoin de définir autant de variables pour le faire sortir dans un bon format que vous le faites pour Data::Dumper.

use Data::Dump = 'dump';

print dump(\%variable), "\n";

{ abc => 123, def => [4, 5, 6] }

Plus récemment, j'ai utilisé Data::Printerpour le débogage.

use Data::Printer;
p %variable;

{
    abc   123,
    def   [
        [0] 4,
        [1] 5,
        [2] 6
    ]
}

(Le résultat peut être beaucoup plus coloré sur un terminal)

Contrairement aux autres exemples que j'ai montrés ici, celui-ci est conçu explicitement pour être uniquement à des fins d'affichage. Ce qui apparaît plus facilement si vous videz la structure d'une variable liée ou celle d'un objet.

use strict;
use warnings;

use MTie::Hash;
use Data::Printer;

my $h = tie my %h, "Tie::StdHash";
@h{'a'..'d'}='A'..'D';
p %h;
print "\n";
p $h;

{
    a   "A",
    b   "B",
    c   "C",
    d   "D"
} (tied to Tie::StdHash)

Tie::StdHash  {
    public methods (9) : CLEAR, DELETE, EXISTS, FETCH, FIRSTKEY, NEXTKEY, SCALAR, STORE, TIEHASH
    private methods (0)
    internals: {
        a   "A",
        b   "B",
        c   "C",
        d   "D"
    }
}

La réponse dépend de ce que contient votre hachage. Si vous avez un simple hachage, un simple

print map { "$_ $h{$_}\n" } keys %h;

ou

print "$_ $h{$_}\n" for keys %h;

fera l'affaire, mais si vous avez un hachage rempli de références, vous obtiendrez quelque chose qui peut parcourir ces références et produire une sortie sensible. Cette marche des références est normalement appelée sérialisation. Il existe de nombreux modules qui implémentent différents styles, certains des plus populaires sont:

• Data::Dumper
• Data::Dump::Streamer
• YAML::XS
• JSON::XS
• XML::Dumper

Etant donné que cela Data::Dumperfait partie de la bibliothèque principale de Perl, c'est probablement la plus populaire; cependant, certains des autres modules ont de très bonnes choses à offrir.

Mon préféré: Smart :: Commentaires

use Smart::Comments;
# ...

### %hash

C'est tout.

Boucle:

foreach(keys %my_hash) { print "$_ / $my_hash{$_}\n"; }

Fonctionnel

map {print "$_ / $my_hash{$_}\n"; } keys %my_hash;

Mais pour l'élégance pure, je devrais choisir celui de wrang-wrang. Pour mon propre code, je choisirais mon foreach. Ou l'utilisation du Dumper de Tetro.

Le moyen le plus simple dans mes expériences est d'utiliser simplement Dumpvalue .

use Dumpvalue;
...
my %hash = { key => "value", foo => "bar" };
my $dumper = new DumpValue();
$dumper->dumpValue(\%hash);

Fonctionne comme un charme et vous n'avez pas à vous soucier du formatage du hachage, car il le produit comme le débogueur Perl (idéal pour le débogage). De plus, Dumpvalue est inclus avec l'ensemble de modules Perl, vous n'avez donc pas à vous soucier du CPAN si vous êtes derrière une sorte de proxy draconien (comme je suis au travail).

Si vous voulez être pédant et vous en tenir à une seule ligne (sans instructions d'utilisation ni shebang), alors je vais en quelque sorte reprendre la réponse de tétromino et suggérer:

print Dumper( { 'abc' => 123, 'def' => [4,5,6] } );

Ne rien faire de spécial autre que d'utiliser le hachage anonyme pour ignorer la variable temporaire;)

J'ajoute un espace pour chaque élément du hachage pour bien le voir:

print map {$_ . " "} %h, "\n";

J'aime vraiment trier les clés dans un code de doublure:

print "$_ => $my_hash{$_}\n" for (sort keys %my_hash);