पर्ल सरणी को प्रिंट करने का आसान तरीका? (थोड़ा प्रारूपण के साथ)

Question

क्या प्रत्येक तत्व के बीच अल्पविराम के साथ एक पर्ल सरणी को प्रिंट करने का एक आसान तरीका है?

यह करने के लिए एक लूप के लिए लिखना बहुत आसान है, लेकिन बहुत सुरुचिपूर्ण नहीं है .... अगर यह समझ में आता है।

Answer 1

बस उपयोग करें join():

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

Comments

या, यदि आप वास्तव में गंदा होना चाहते हैं {local $,=', ';print @array}:।

— मुशीक

ऐसा करने का एक से अधिक तरीका है .. लेकिन यह वह तरीका है जो आपको नफरत करने के बाद कोड को बनाए रखने वाले व्यक्ति को नहीं बनाता है। हां, perldoc perlvar मौजूद है, लेकिन मैं "join", '@ray' पर नज़र डालूंगा, जो कि सभी गूढ़ चर का पता लगाने के लिए प्रत्येक अन्य पंक्ति पर perlvar को हिट करने की तुलना में है।

— Oesor

@Oesor: यही कारण है कि मैं इसे गंदा कहा जाता है। लेकिन ठीक है, अन्य उत्तरों को देखते हुए, मैं वास्तव में सबसे खराब अपराधी नहीं हूं। :)

— मुस्किक

@musiKK मुझे पसंद है! अगर मैं अपने साथी सहकर्मियों की पहेली बनाना चाहता हूं तो यह कुछ ऐसा होगा जिसका मैं उपयोग करूंगा। :)

— एलेक्स

यह निर्देशिका सामग्री को मुद्रित करने के लिए वास्तव में अच्छी तरह से काम करता है। print "current directory contains " . join(', ', <*>) . "\n";

— रान्डेल

Answer 2

आप उपयोग कर सकते हैं Data::Dump:

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

पैदा करता है:

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

Comments

उबंटू / टकसाल पर, लिबडाटा-डंप-पर्ल पैकेज स्थापित करें।

— MUY बेल्जियम

सबसे अच्छा जवाब यहाँ! बहुआयामी सरणियों के साथ भी काम करता है। सबसे लचीला।

— लेओ लेपोल्ड हर्ट्ज़ é

Answer 3

यदि आप उस तरह की स्पष्टता के लिए कोडिंग कर रहे हैं, जो किसी ऐसे व्यक्ति द्वारा समझी जाएगी, जो अभी पर्ल के साथ शुरुआत कर रहा है, तो पारंपरिक इस निर्माण का कहना है कि इसका क्या अर्थ है, उच्च स्तर की स्पष्टता और सुगमता के साथ:

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

इस निर्माण में प्रलेखित है perldoc -fjoin।

हालांकि, मैंने हमेशा यह पसंद किया है कि $,यह कितना सरल है। विशेष चर $" प्रक्षेप के लिए है, और विशेष चर $,सूचियों के लिए है। localपूरे स्क्रिप्ट में रिपल इफेक्ट्स से बचने के लिए डायनेमिक स्कोप-विवशता के साथ किसी एक को मिलाएं :

use 5.012_002;
use strict;
use warnings;

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

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

या $ के साथ:

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

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

विशेष चर $,और perlvar$" में प्रलेखित हैं । localकीवर्ड, और कैसे यह एक वैश्विक विराम चिह्न वेरिएबल का मान बदलने के प्रभाव विवश करने के लिए इस्तेमाल किया जा सकता शायद सबसे अच्छा में वर्णन किया गया perlsub ।

का आनंद लें!

Answer 4

इसके अलावा, आप डेटा :: डम्पर आज़माना चाह सकते हैं । उदाहरण:

use Data::Dumper;

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

Comments

डेटा :: डम्पर एक मानक मॉड्यूल है और पर्ल के साथ स्थापित किया गया है। सभी मानक व्यावहारिकता और मॉड्यूल की सूची प्राप्त करने के लिए, देखें pelrdoc perlmodlib।

— शॉनहॉर्की

Answer 5

निरीक्षण / डिबगिंग के लिए Data::Printerमॉड्यूल की जाँच करें । यह केवल एक काम और एक काम करने के लिए है:

स्क्रीन पर पर्ल वैरिएबल और ऑब्जेक्ट्स प्रदर्शित करें, ठीक से स्वरूपित (मानव द्वारा निरीक्षण किया जाना)

उदाहरण का उपयोग:

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

उपरोक्त कोड कुछ इस तरह से (रंगों के साथ) उत्पादन कर सकता है:

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

Comments

उबंटू के तहत एक libdata-printer-perlपैकेज स्थापित कर सकता है ।

— 14

Answer 6

आप इसे बस कर सकते printहैं।

@a = qw(abc def hij);

print "@a";

आपको मिलेगा:

abc def hij

Comments

आपके पास प्रिंट में अल्पविराम हैं क्योंकि वे सरणी के प्रत्येक तत्व में हैं। आपको वास्तव में घोषित करना चाहिए use warnings;और देखना चाहिए कि यह क्या कहता है।

— टोटो

Answer 7

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

use JSON::XS;
print encode_json \@some_array

Answer 8

का उपयोग कर 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)]);

तीन अलग-अलग आउटपुट शैली बनाता है:

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

Answer 9

यह वह नहीं हो सकता है जो आप खोज रहे हैं, लेकिन यहां कुछ मैंने असाइनमेंट के लिए किया है:

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

Answer 10

मानचित्र का उपयोग भी किया जा सकता है, लेकिन कभी-कभी पढ़ने में मुश्किल होती है जब आपके पास बहुत सारी चीजें होती हैं।

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

Answer 11

मैंने नीचे चलाने की कोशिश नहीं की है, हालाँकि। मुझे लगता है कि यह एक मुश्किल तरीका है।

map{print $_;} @array;