¿Cómo puedo imprimir el contenido de un hash en Perl?

Sigo imprimiendo mi hash como # de cubos / # asignado. ¿Cómo imprimo el contenido de mi hash?

Sin usar un whilebucle sería más preferible (por ejemplo, una línea sería lo mejor).

Datos :: Dumper es tu amigo.

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

saldrá

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

Fácil:

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

Elegante, pero en realidad un 30% más lento (!):

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

Aquí cómo puede imprimir sin usar Data::Dumper

print "@{[%hash]}";

Para fines de depuración, a menudo lo usaré YAML.

use strict;
use warnings;

use YAML;

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

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

Resultados en:

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

Otras veces lo usaré Data::Dump. No necesita establecer tantas variables para que salga en un formato agradable del que tiene Data::Dumper.

use Data::Dump = 'dump';

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

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

Más recientemente, he estado usando Data::Printerpara depurar.

use Data::Printer;
p %variable;

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

(El resultado puede ser mucho más colorido en una terminal)

A diferencia de los otros ejemplos que he mostrado aquí, este está diseñado explícitamente para fines de visualización únicamente. Lo que se muestra más fácilmente si deshace la estructura de una variable vinculada o la de un 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"
    }
}

La respuesta depende de lo que haya en tu hash. Si tienes un hash simple, un simple

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

o

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

funcionará, pero si tiene un hash que está lleno de referencias, tendrá algo que puede recorrer esas referencias y producir una salida sensata. Este recorrido de las referencias normalmente se llama serialización. Hay muchos módulos que implementan diferentes estilos, algunos de los más populares son:

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

Debido al hecho de que Data::Dumperes parte de la biblioteca principal de Perl, es probablemente la más popular; sin embargo, algunos de los otros módulos tienen cosas muy buenas que ofrecer.

Mi favorito: Smart :: Comentarios

use Smart::Comments;
# ...

### %hash

Eso es.

Bucle:

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

Funcional

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

Pero por pura elegancia, tendría que elegir wrang-wrang's. Para mi propio código, elegiría mi foreach. O el uso de Dumper de Tetro.

La forma más fácil en mis experiencias es usar Dumpvalue .

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

Funciona a la perfección y no tiene que preocuparse por formatear el hash, ya que lo genera como lo hace el depurador Perl (ideal para la depuración). Además, Dumpvalue se incluye con el conjunto de stock de módulos Perl, por lo que no tiene que meterse con CPAN si está detrás de algún tipo de proxy draconiano (como si estuviera en el trabajo).

Si desea ser pedante y mantenerlo en una línea (sin declaraciones de uso y shebang), entonces me alejaré de la respuesta de tetromino y sugeriré:

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

No hacer nada especial aparte de usar el hash anónimo para omitir la variable temporal;)

Añado un espacio para cada elemento del hash para verlo bien:

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

Realmente me gusta ordenar las claves en un código de línea:

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