¿Una forma sencilla de imprimir una matriz Perl? (con un poco de formato)

¿Existe una manera fácil de imprimir una matriz Perl con comas entre cada elemento?

Escribir un bucle for para hacerlo es bastante fácil pero no del todo elegante ... si eso tiene sentido.

Solo usa join():

# assuming @array is your array:
print join(", ", @array);

Puede utilizar Data::Dump:

use Data::Dump qw(dump);
my @a = (1, [2, 3], {4 => 5});
dump(@a);

Produce:

"(1, [2, 3], { 4 => 5 })"

Si está codificando para el tipo de claridad que entendería alguien que recién comienza con Perl, la construcción tradicional de este dice lo que significa, con un alto grado de claridad y legibilidad:

$string = join ', ', @array;
print "$string\n";

Esta construcción está documentada en perldoc -fjoin.

Sin embargo, siempre me ha gustado lo simple $,que lo hace. La variable especial $"es para interpolación y la variable especial $,es para listas. Combine cualquiera de los dos con restricción dinámica de alcance ' local' para evitar efectos en cadena en todo el script:

use 5.012_002;
use strict;
use warnings;

my @array = qw/ 1 2 3 4 5 /;

{
    local $" = ', ';
    print "@array\n"; # Interpolation.
}

O con $ ,:

use feature q(say);
use strict;
use warnings;

my @array = qw/ 1 2 3 4 5 /;
{
    local $, = ', ';
    say @array; # List
}

Las variables especiales $,y $"están documentadas en perlvar . La localpalabra clave, y cómo se puede usar para restringir los efectos de alterar el valor de una variable de puntuación global, probablemente se describa mejor en perlsub .

¡Disfrutar!

Además, es posible que desee probar Data :: Dumper . Ejemplo:

use Data::Dumper;

# simple procedural interface
print Dumper($foo, $bar);

Para inspección / depuración, verifique el Data::Printermódulo. Está destinado a hacer una cosa y solo una cosa:

mostrar variables y objetos de Perl en la pantalla, correctamente formateados (para ser inspeccionados por un humano)

Uso de ejemplo:

use Data::Printer;  
p @array;  # no need to pass references

El código anterior podría generar algo como esto (¡con colores!):

   [
       [0] "a",
       [1] "b",
       [2] undef,
       [3] "c",
   ]

Puede simplemente printhacerlo.

@a = qw(abc def hij);

print "@a";

Tendrás:

abc def hij

# better than Dumper --you're ready for the WWW....

use JSON::XS;
print encode_json \@some_array

Usando Data::Dumper:

use strict;
use Data::Dumper;

my $GRANTstr = 'SELECT, INSERT, UPDATE, DELETE, LOCK TABLES, EXECUTE, TRIGGER';
$GRANTstr    =~ s/, /,/g;
my @GRANTs   = split /,/ , $GRANTstr;

print Dumper(@GRANTs) . "===\n\n";

print Dumper(\@GRANTs) . "===\n\n";

print Data::Dumper->Dump([\@GRANTs], [qw(GRANTs)]);

Genera tres estilos de salida diferentes:

$VAR1 = 'SELECT';
$VAR2 = 'INSERT';
$VAR3 = 'UPDATE';
$VAR4 = 'DELETE';
$VAR5 = 'LOCK TABLES';
$VAR6 = 'EXECUTE';
$VAR7 = 'TRIGGER';
===

$VAR1 = [
          'SELECT',
          'INSERT',
          'UPDATE',
          'DELETE',
          'LOCK TABLES',
          'EXECUTE',
          'TRIGGER'
        ];
===

$GRANTs = [
            'SELECT',
            'INSERT',
            'UPDATE',
            'DELETE',
            'LOCK TABLES',
            'EXECUTE',
            'TRIGGER'
          ];

Puede que esto no sea lo que estás buscando, pero aquí hay algo que hice para una tarea:

$" = ", ";
print "@ArrayName\n";

También se puede utilizar el mapa, pero a veces es difícil de leer cuando hay muchas cosas en marcha.

map{ print "element $_\n" }   @array; 

Sin embargo, no he intentado correr abajo. Creo que esta es una forma complicada.

map{print $_;} @array;