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

printing

Question

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

Sin usar un bucle while sería lo más preferible (por ejemplo, un one-liner sería lo mejor).

Answer 1

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

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

Answer 2

Aquí puedes imprimir sin usar Data :: Dumper

print "@{[%hash]}";

Answer 3

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

Answer 4

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 como un amuleto 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).

Answer 5

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

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

o

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

servirá, pero si tiene un hash que está lleno de referencias, encontrará algo que puede recorrer esas referencias y producir un resultado sensato. 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 a que Data::Dumper forma parte de la biblioteca central de Perl, es probablemente la más popular; sin embargo, algunos de los otros módulos tienen muy buenas cosas para ofrecer.

Answer 6

Looping:

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 el de wrang-wrang. Para mi propio código, elegiría mi foreach. O el uso del Dumper de Tetro.

Answer 7

Mi favorito: Smart::Comments

use Smart::Comments;
# ...

### %hash

Eso es.

Answer 8

Para fines de depuración, a menudo 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 usaré Data::Dump . No es necesario que configure tantas variables para que salga en un formato agradable que no sea para Data::Dumper .

use Data::Dump = ''dump'';

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

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

Más recientemente he estado utilizando Data::Printer para la depuración.

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 solo para fines de visualización. Lo cual aparece más fácilmente si se descarta 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"
    }
}

Answer 9

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

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

Answer 10

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

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

No hacer nada especial más que usar el hash anónimo para omitir la variable temp;)

Answer 11

Data::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
        };