Maneira fácil de imprimir array Perl? (com um pouco de formatação)

Existe uma maneira fácil de imprimir um array Perl com vírgulas entre cada elemento?

Escrever um loop for para fazer isso é muito fácil, mas não muito elegante ... se isso faz sentido.

Basta usar join():

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

Você pode usar Data::Dump:

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

Produz:

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

Se você está codificando para o tipo de clareza que seria compreendido por alguém que está apenas começando com Perl, o tradicional este construto diz o que significa, com um alto grau de clareza e legibilidade:

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

Esta construção está documentada em perldoc -fjoin.

No entanto, sempre gostei de como o $,torna simples . A variável especial $"é para interpolação e a variável especial $,é para listas. Combine qualquer um com a restrição de escopo dinâmica ' local' para evitar efeitos cascata em todo o script:

use 5.012_002;
use strict;
use warnings;

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

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

OU com $ ,:

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

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

As variáveis ​​especiais $,e $"são documentadas em perlvar . A localpalavra-chave e como ela pode ser usada para restringir os efeitos da alteração do valor de uma variável de pontuação global é provavelmente melhor descrita em perlsub .

Aproveitar!

Além disso, você pode querer experimentar o Data :: Dumper . Exemplo:

use Data::Dumper;

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

Para inspeção / depuração, verifique o Data::Printermódulo. Destina-se a fazer uma coisa e apenas uma coisa:

exibir variáveis ​​Perl e objetos na tela, devidamente formatados (para serem inspecionados por um humano)

Exemplo de uso:

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

O código acima pode gerar algo assim (com cores!):

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

Você pode simplesmente printisso.

@a = qw(abc def hij);

print "@a";

Você terá:

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)]);

Gera três estilos de saída 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'
          ];

Pode não ser o que você está procurando, mas aqui está algo que fiz para uma tarefa:

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

O mapa também pode ser usado, mas às vezes é difícil de ler quando há muitas coisas acontecendo.

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

Não tentei correr para baixo, no entanto. Acho que é uma maneira complicada.

map{print $_;} @array;