Comment puis-je imprimer le contenu d'une table de hachage en Perl?

Je garde l'impression que mon hachage comme nombre de seaux /# alloué.
Comment puis-je imprimer le contenu de mon hash?

Sans l'aide d'un while boucle serait le plus souhaitable (par exemple, un one-liner serait le mieux).

InformationsquelleAutor Kys | 2009-07-21

234

Data::Dumper est votre ami.
```
use Data::Dumper;
my %hash = ('abc' => 123, 'def' => [4,5,6]);
print Dumper(\%hash);
```
sortie
```
$VAR1 = {
          'def' => [
                     4,
                     5,
                     6
                   ],
          'abc' => 123
        };
```
- pourriez-vous ajouter le résultat de ce bout de code?
- l'affiche originale pouvez également regarder dans les divers Data::Dumper options, en particulier en tournant sur "Sortkeys" peut être très utile
- remarque l'importance d'avoir la barre en face de l' %
- J'ai été absent ces détails et il a été utile! Merci!
- Que signifie le fait d'ajouter un slash devant le % ?
- slash opérateur crée une référence, un peu comme le & opérateur en C et C++. La raison c'est important dans ce contexte est qu'en Perl, si vous appelez une fonction avec une valeur de hachage comme argument, que la valeur de hachage obtient listified et élargi dans plusieurs arguments - donc %hsh=("a" => 1, "b" => 2); foo(%hsh); serait équivalent à foo("a", 1, "b", 2). Si vous voulez plutôt la fonction d'opérer sur le hachage de lui-même, vous avez besoin de passer une référence à un hachage: foo(\%hsh); Voir perldoc.perl.org/perlsub.html#Pass-by-Reference
InformationsquelleAutor tetromino
58

Facile:
```
print "$_ $h{$_}\n" for (keys %h);
```
Élégant, mais en réalité, 30% plus lent (!):
```
while (my ($k,$v)=each %h){print "$k $v\n"}
```
- Louche: print "@_\n" while @_ = chaque %h
- Je pense que tu veux dire print "$_ $h{$_}\n" for (keys %h);, $k n'existe pas dans cet exemple.
- Aussi, l'indice de référence avant de faire des affirmations au sujet de l'efficacité (ou au moins qualifier le type de l'efficacité dont vous parlez). Le for boucle est plus rapide que la while jusqu'à au moins 10 000 clés: gist.github.com/151792
- Bien sûr, vous avez raison re: k$. Mais il est plus efficace en Perl 6! 🙂 Oui, vous avez raison sur ce que trop. Je n'aurais jamais pensé en fait d'optimiser ou de profil de mon Perl, mais je suis heureux de l'apprendre. Bien sûr, chaque doit être plus efficace (car il n'y a pas de supplément de hachage de recherche sur la touche). Mais c'est ~30% plus lent!
- Salut, Jonathan Graehl. Désolé, toujours pas la compréhension. Vous êtes en train de dire que chacun est ~30% plus lent basé sur quoi? Est à chaque fois, pour chaque situation, un écart de 30% ?
InformationsquelleAutor Jonathan Graehl
35

Voici comment vous pouvez imprimer sans utiliser Data::Dumper
```
print "@{[%hash]}";
```
InformationsquelleAutor
21

À des fins de débogage, je vais souvent utiliser YAML.
```
use strict;
use warnings;

use YAML;

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

print "# %variable\n", Dump \%variable;
```
Résultats dans:
```
# %variable
---
abc: 123
def:
  - 4
  - 5
  - 6
```
D'autres fois, je vais utiliser Données::Dump. Vous n'avez pas besoin de définir autant de variables pour l'obtenir à la sortie dans un beau format que vous faites pour Data::Dumper.
```
use Data::Dump = 'dump';

print dump(\%variable), "\n";
```
```
{ abc => 123, def => [4, 5, 6] }
```
Plus récemment, j'ai été en utilisant Données::Imprimante pour le débogage.
```
use Data::Printer;
p %variable;
```
```
{
    abc   123,
    def   [
        [0] 4,
        [1] 5,
        [2] 6
    ]
}
```
( Résultat peut être beaucoup plus coloré sur un terminal )

Contrairement aux autres exemples que j'ai montré ici, celui-ci est conçu à des fins d'affichage uniquement. Qui se montre de plus en plus facilement si vous videz la structure de l'égalité de variable ou 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"
    }
}
```
- ayant les couleurs "propre", mais soit je fais quelque chose de mal, ou en utilisant des Données d'utilisation:Imprimante; p %var;" ne pas imprimer sur les flèches dans la cendre, et pour un débutant comme moi qui m'aide
- Si vous regardez le résultat dans la réponse, vous verrez qu'il n'est pas sortie de la => comme vous vous attendez. Au lieu de cela, il permet d'imprimer la clé, plusieurs espaces, et de la valeur. Ce qui permet à un homme de balayage sur la sortie.
InformationsquelleAutor Brad Gilbert
11

La réponse dépend de ce qui est dans votre code de hachage. Si vous avez un simple hash d'un simple
```
print map { "$_ $h{$_}\n" } keys %h;
```
ou
```
print "$_ $h{$_}\n" for keys %h;
```
fera, mais si vous avez une table de hachage qui est rempli avec des références que vous aurez quelque chose qui peut marcher ces références et de produire un bon de sortie. Cette marche des références est normalement appelé la sérialisation. Il existe de nombreux modules qui implémentent des styles différents, les plus populaires sont:
En raison du fait que Data::Dumper est partie du noyau de la bibliothèque Perl, il est probablement le plus populaire; toutefois, certains des autres modules ont de très bonnes choses à offrir.

InformationsquelleAutor Chas. Owens
10

Mon préféré: Smart::Commentaires
```
use Smart::Comments;
# ...

### %hash
```
Que c'est.
- C'est cool. +1
- Désolé, en baisse de voter de moi pour des trucs qui détourne les commentaires pour la fonctionnalité réelle. Un entretien programmeur pourrait passer toute la journée à essayer de comprendre pourquoi le code tel qu'il a l'impression d'inattendu de trucs.
- np. C'est une source de filtre, donc je comprends. Aussi, après avoir écrit des scripts de vérifier chaque module que j'ai mis en production prep qu'il n'a pas use Smart::Comments, je le vois de cette perspective. Mais pour le compteur, Smart::Comments est assez bien comportée comme une portée module, il ne devrait pas être le comportement de la sortie dans un module qui n'est pas aussi utilisation SC. Donc, le problème serait isolé de ces étendues avec un utilisation déclaration. Si vous êtes en train de dire qu'un entretien programmeur n'a pas la responsabilité de lire la doc sur les modules inclus, je ne peux pas d'accord. Encore, merci pour les commentaires
- Je ne dis pas qu'ils n'ont pas une responsabilité, mais il n'est pas susceptible d'être la première chose qu'ils recherchent. Ne jamais avoir vu Smart module de commentaire avant que je ne sais pas pourquoi le code ci-dessus a été l'impression de quelque chose. Je pourrais passer des jours à sauter sur le commentaire et même pas le traiter car les commentaires n'ont rien à faire. En faisant d'eux de faire quelque chose, c'est très mauvais de l'omi. Ils peuvent être utilisés pour générer la documentation, etc, tant qu'ils ne modifient pas le comportement du programme.
InformationsquelleAutor Axeman
2

La façon la plus simple dans mes expériences, c'est simplement utiliser Dumpvalue.
```
use Dumpvalue;
...
my %hash = { key => "value", foo => "bar" };
my $dumper = new DumpValue();
$dumper->dumpValue(\%hash);
```
Fonctionne comme un charme et que vous n'avez pas à vous soucier de la mise en forme de hachage, comme il les sorties comme le débogueur Perl n' (idéal pour le débogage). De Plus, Dumpvalue est inclus avec le stock ensemble de modules Perl, de sorte que vous n'avez pas de gâchis avec CPAN si vous êtes derrière une sorte de draconiennes proxy (comme je suis au travail).

InformationsquelleAutor Weegee
1

Si vous voulez être pédant et de le conserver pour une ligne (sans utiliser des énoncés et shebang), alors je vais trier de piggy back-off de tétromino de répondre et de proposer:
```
print Dumper( { 'abc' => 123, 'def' => [4,5,6] } );
```
Ne fais rien de spécial autre que l'aide de l'anonyme de hachage pour ignorer la variable temp 😉
- L'OP dit qu'il a "mon hash" qui a besoin de l'impression. Cette réponse est juste l'intelligence pour son propre bien
- L'OP a été l'espoir de le faire en une seule ligne. Montrait une ligne de moyen de le faire. Donc, c'est digne d'un vote?
InformationsquelleAutor Kyle Walsh
1

Je ajouter un espace pour chaque élément de la table de hachage de le voir ainsi:
```
print map {$_ . " "} %h, "\n";
```
InformationsquelleAutor carlos_lm
1

J'aime vraiment pour trier les touches en une ligne de code:
```
print "$_ => $my_hash{$_}\n" for (sort keys %my_hash);
```
InformationsquelleAutor labist

Vous devez vous connecter pour publier un commentaire.