Un moyen facile d'imprimer un tableau Perl? (avec un peu de mise en forme)

Existe-t-il un moyen simple d'imprimer un tableau Perl avec des virgules entre chaque élément?

Ecrire une boucle for pour le faire est assez facile mais pas tout à fait élégant ... si cela a du sens.

Utilisez simplement join():

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

Vous pouvez utiliser Data::Dump:

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

Produit:

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

Si vous codez pour le type de clarté qui serait compris par quelqu'un qui commence tout juste avec Perl, la construction traditionnelle dit ce que cela signifie, avec un degré élevé de clarté et de lisibilité:

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

Cette construction est documentée dans perldoc -fjoin.

Cependant, j'ai toujours aimé la simplicité $,. La variable spéciale $"est pour l'interpolation et la variable spéciale $,est pour les listes. Combinez l'un ou l'autre avec une contrainte de portée dynamique ' local' pour éviter d'avoir des effets d'entraînement tout au long du script:

use 5.012_002;
use strict;
use warnings;

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

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

OU avec $ ,:

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

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

Les variables spéciales $,et $"sont documentées dans perlvar . Le localmot-clé, et comment il peut être utilisé pour limiter les effets de la modification de la valeur d'une variable de ponctuation globale, est probablement mieux décrit dans perlsub .

Prendre plaisir!

Vous pouvez également essayer Data :: Dumper . Exemple:

use Data::Dumper;

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

Pour l'inspection / le débogage, vérifiez le Data::Printermodule. Il est destiné à faire une chose et une seule chose:

afficher des variables et des objets Perl à l'écran, correctement formatés (à inspecter par un humain)

Exemple d'utilisation:

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

Le code ci-dessus peut afficher quelque chose comme ceci (avec des couleurs!):

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

Vous pouvez simplement printcela.

@a = qw(abc def hij);

print "@a";

Vous aurez:

abc def hij

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

use JSON::XS;
print encode_json \@some_array

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

Génère trois styles de sortie différents:

$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'
          ];

Ce n'est peut-être pas ce que vous recherchez, mais voici quelque chose que j'ai fait pour une mission:

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

La carte peut également être utilisée, mais parfois difficile à lire lorsque vous avez beaucoup de choses à faire.

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

Je n'ai pas essayé de courir ci-dessous, cependant. Je pense que c'est une manière délicate.

map{print $_;} @array;