मैं इसे यहाँ छोड़ दूँगा

मैं पर्ल को बदनाम करने का लक्ष्य नहीं रखता। मुझे पर्ल से प्यार है।
आपको बस पर्ल में एक सूची और एक सरणी के बीच अंतर करने की आवश्यकता है।

use Perl or die; 

 #!/usr/bin/perl use strict; my $x = ('a', 'b'); print $x; 

निष्कर्ष:
b


 #!/usr/bin/perl use strict; my @a = ('a', 'b'); my $x = @a; print $x; 

निष्कर्ष:
2


 #!/usr/bin/perl my @a = ('a', 'b'); my ($x) = @a; print $x; 

निष्कर्ष:
a


 #!/usr/bin/perl my @a = ('a', 'b'); print scalar @a; 

निष्कर्ष:
2


 #!/usr/bin/perl print scalar ('a', 'b'); 

निष्कर्ष:
b


 #!/usr/bin/perl $\ = "\n"; my $x = ('a', 'b', 'c'); print "x = $x"; my $x = @{['a', 'b', 'c']}; print "x = $x"; my $x = (@{['a', 'b', 'c']}); print "x = $x"; 

निष्कर्ष:
x = c
x = 3
x = 3

 #!/usr/bin/perl use strict; my $x; my $y; $y = ($x = ('a', 'b', 'c')); print "x = $x\n"; print "y = $y\n"; 

x =
y =

 #!/usr/bin/perl use strict; my $x; my $y; $y = (($x) = ('a', 'b', 'c')); print "x = $x\n"; print "y = $y\n"; 

x = a
y = 3

मैं पर्ल को बदनाम करने का लक्ष्य नहीं रखता। मुझे पर्ल से प्यार है।

 use Perl or die; 

विवरण यहाँ: perldoc perldata, "सूची मूल्य निर्माणकर्ताओं" से पढ़ें

---

ऑफटॉप, विभिन्न लोगों के साथ बातचीत से मैंने कुछ और उदाहरणों को सीखा:

 #!/usr/bin/perl use strict; use Data::Dumper; sub test1 { my %hash; $hash{shift} = 1; print Dumper \%hash; } sub test2 { my %hash; $hash{+shift} = 1; print Dumper \%hash; } test1('test'); test2('test'); 

निष्कर्ष:

 $ VAR1 = {
           'पारी' => 1
         };
 $ VAR1 = {
           'परीक्षण' => 1
         };

हैश में, कुंजी नाम को उद्धृत करने की आवश्यकता नहीं है, यह तुरंत एक स्ट्रिंग के रूप में प्रकट होता है, यूनीरी प्लस भी + शिफ्ट ऑपरेशन की गणना करता है, अर्थात $ _ [x], जहां x @_ सरणी में सूचकांक है

---

 s ggggg; 

यह समकक्ष है

 s///g; 

s ऑपरेटर आपको अन्य पात्रों के साथ / सीमांकक को बदलने की अनुमति देता है, यहाँ वर्ण g चुना गया है
अर्थात्, यह s /// gg है; जो बदले में s /// g के बराबर है; जाहिर है, एस के बाद एक जगह है ताकि मोती इस ऑपरेटर को कुछ sggggg फ़ंक्शन को कॉल करने से अलग कर सके; यह भी स्पष्ट है कि अंतरिक्ष के बजाय एक सीमांकक नहीं हो सकता है /

फिर से, मैं आपको ओ = डेपर्स मॉड्यूल की याद दिलाता हूं, जिसके बारे में मैंने अपने लेख में सिंगल-लाइन पर्ल प्रोग्राम्स में बात की थी, जो आपको सब कुछ दिखाएगा:

 perl -MO=Deparse -le "s ggggg;" 

 BEGIN {$ / = "\ n";  $ \ _ "\ n";  }
 s /// जी;
 -वाक्य विन्यास ठीक है

---

 #!/usr/bin/perl use strict; use Data::Dumper; use constant key => 1; my %hash; $hash{key} = 1; print Dumper \%hash; my %hash2; $hash2{+key} = 1; print Dumper \%hash2; my %hash3; $hash3{-key} = 1; print Dumper \%hash3; 

निष्कर्ष:

 $ VAR1 = {
           'की' => 1
         };
 $ VAR1 = {
           '1' => 1
         };
 $ VAR1 = {
           '-की' => १
         };

अगर "संख्यात्मक है तो यूनिरी" नकारात्मक अंकन करता है। यदि ऑपरेंड एक पहचानकर्ता है, तो एक स्ट्रिंग जिसमें पहचानकर्ता के साथ एक ऋण चिह्न समाहित होता है, वापस आ जाता है।

माइनस एक संख्या के सामने होने पर माइनस के रूप में काम करता है। यदि यह पहचानकर्ता के सामने आता है, तो माइनस और पहचानकर्ता से युक्त एक स्ट्रिंग वापस आ जाती है।

UPD : संभवत: सबसे पहले उन्होंने मुझे गलत समझा और मुझे ऋण देने लगे, "मैंने लक्ष्य निर्धारित नहीं किया"

UPD 2 :
आखिरी उदाहरण के बारे में। दस्तावेज कहता है
"स्केलर संदर्भ में सूची असाइनमेंट तत्वों की संख्या लौटाता है
असाइनमेंट के दाईं ओर अभिव्यक्ति द्वारा निर्मित »

यही है, अगर हम सूची में कुछ असाइन करते हैं, तो हम सूची में जो भी तत्व असाइन करते हैं, उन्हें वापस कर दिया जाएगा।

  $x = (($foo,$bar) = f()); 

$ x तत्वों की संख्या पर निर्भर करता है जो एफ द्वारा लौटाया गया है ()
UPD 3 : मैं देखता हूं कि लोगों ने माइनसकुलस का खुलासा किया है, इसलिए दिन के दौरान सबसे अधिक संभावना है (शायद 15:00 बजे) मैं लेख को मसौदा प्रतियों में डालूंगा ताकि कर्म न खोएं।
अगर आपको लेख पसंद आया हो तो इसे सेव करें।
UPD 4 : कर्म इतना बुरा नहीं है, मैं उन लोगों को धन्यवाद देता हूं जिन्होंने मेरा समर्थन किया, हैश {शिफ्ट} और sgggg के साथ और उदाहरण जोड़े;
UPD 5 (08.28.2012) : एक उदाहरण एक शून्य ऋण के साथ।