Un modo semplice per stampare array Perl? (con un po 'di formattazione)

C'è un modo semplice per stampare un array Perl con virgole tra ogni elemento?

Scrivere un ciclo for per farlo è abbastanza facile ma non del tutto elegante ... se ha senso.

Usa solo join():

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

Puoi usare Data::Dump:

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

Produce:

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

Se stai codificando per il tipo di chiarezza che sarebbe compreso da qualcuno che ha appena iniziato con Perl, il tradizionale questo costrutto dice cosa significa, con un alto grado di chiarezza e leggibilità:

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

Questo costrutto è documentato in perldoc -fjoin.

Tuttavia, mi è sempre piaciuto quanto sia semplice $,. La variabile speciale $"è per l'interpolazione e la variabile speciale $,è per gli elenchi. Combina uno dei due con il vincolo dinamico dell'ambito " local" per evitare effetti a catena in tutto lo 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
}

Le variabili speciali $,e $"sono documentate in perlvar . La localparola chiave e il modo in cui può essere utilizzata per limitare gli effetti dell'alterazione del valore di una variabile di punteggiatura globale è probabilmente meglio descritta in perlsub .

Godere!

Inoltre, potresti provare Data :: Dumper . Esempio:

use Data::Dumper;

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

Per l'ispezione / debug controllare il Data::Printermodulo. Ha lo scopo di fare una cosa e solo una cosa:

mostra variabili e oggetti Perl sullo schermo, formattati correttamente (per essere ispezionati da un essere umano)

Utilizzo di esempio:

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

Il codice sopra potrebbe produrre qualcosa di simile (con i colori!):

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

Puoi semplicemente printfarlo.

@a = qw(abc def hij);

print "@a";

Avrai:

abc def hij

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

use JSON::XS;
print encode_json \@some_array

Utilizzando 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 tre diversi stili di output:

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

Questo potrebbe non essere quello che stai cercando, ma ecco qualcosa che ho fatto per un incarico:

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

Puoi anche usare la mappa, ma a volte è difficile da leggere quando hai molte cose da fare.

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

Tuttavia, non ho provato a correre di sotto. Penso che questo sia un modo complicato.

map{print $_;} @array;