Como posso imprimir o conteúdo de um hash no Perl?

Continuo imprimindo meu hash como # de baldes / # alocados. Como imprimo o conteúdo do meu hash?

Sem o uso de um whileloop seria o mais preferível (por exemplo, um one-liner seria o melhor).

Data :: Dumper é seu amigo.

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

irá produzir

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

Fácil:

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

Elegante, mas na verdade 30% mais lento (!):

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

Aqui, como você pode imprimir sem usar Data::Dumper

print "@{[%hash]}";

Para fins de depuração, usarei frequentemente YAML.

use strict;
use warnings;

use YAML;

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

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

Resulta em:

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

Outras vezes eu usarei Data::Dump. Você não precisa definir tantas variáveis ​​para que ele a produza em um formato agradável do que o necessário Data::Dumper.

use Data::Dump = 'dump';

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

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

Mais recentemente, tenho usado Data::Printerpara depuração.

use Data::Printer;
p %variable;

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

(O resultado pode ser muito mais colorido em um terminal)

Ao contrário dos outros exemplos que mostrei aqui, este foi projetado explicitamente para ser apenas para fins de exibição. O que aparece mais facilmente se você despejar a estrutura de uma variável vinculada ou a de um objeto.

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"
    }
}

A resposta depende do que está no seu hash. Se você tem um hash simples, um simples

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

ou

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

funcionará, mas se você tiver um hash preenchido com referências, terá algo que poderá percorrer essas referências e produzir uma saída sensata. Essa caminhada das referências é normalmente chamada de serialização. Existem muitos módulos que implementam estilos diferentes, alguns dos mais populares são:

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

Devido ao fato de fazer Data::Dumperparte da biblioteca principal do Perl, é provavelmente o mais popular; no entanto, alguns dos outros módulos têm coisas muito boas a oferecer.

Meu favorito: Smart :: Comentários

use Smart::Comments;
# ...

### %hash

É isso aí.

Looping:

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

Funcional

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

Mas, por pura elegância, eu teria que escolher o wrang-wrang. Para o meu próprio código, eu escolheria meu foreach. Ou o uso de Dumper da tetro.

A maneira mais fácil em minhas experiências é apenas usar o Dumpvalue .

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

Funciona como um encanto e você não precisa se preocupar em formatar o hash, pois ele o gera como o depurador Perl (ótimo para depuração). Além disso, o Dumpvalue está incluído no conjunto de módulos Perl, para que você não precise mexer no CPAN se estiver atrás de algum tipo de proxy draconiano (como eu estou no trabalho).

Se você quer ser pedante e mantê-lo em uma linha (sem as instruções de uso e o shebang), então eu meio que recuo da resposta do tetromino e sugiro:

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

Não fazer nada de especial além de usar o hash anônimo para pular a variável temp;)

Anexo um espaço para cada elemento do hash para vê-lo bem:

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

Eu realmente gosto de classificar as chaves em um código de linha:

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