पेरलोल - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

perllol - पर्ल में सारणियों के सारणियों में हेरफेर

वर्णन

घोषणा और पहुँच of Arrays of Arrays
पर्ल में बनाने के लिए सबसे सरल दो-स्तरीय डेटा संरचना, कभी-कभी सरणियों की एक सरणी होती है
इसे सामान्यतः सूचियों की सूची कहा जाता है। इसे समझना काफी आसान है, और लगभग
जो कुछ भी यहां लागू होता है वह बाद में कट्टर डेटा के साथ भी लागू होगा
संरचनाओं।

किसी सरणी की एक सरणी सिर्फ एक नियमित पुरानी सरणी @AoA है जिसे आप दो के साथ प्राप्त कर सकते हैं
सबस्क्रिप्ट, जैसे $AoA[3][2]। यहाँ सरणी की घोषणा है:

5.010 का उपयोग करें; # ताकि हम कहो() का उपयोग कर सकें

# हमारे एरे को, एरे संदर्भों की एक एरे असाइन करें
@एओए = (
["फ्रेड", "बार्नी", "कंकड़", "बमबम", "डिनो", ],
["जॉर्ज", "जेन", "एलरॉय", "जूडी", ],
["होमर", "बार्ट", "मार्ज", "मैगी", ],
);
$AoA[2][1] कहें;
Bart

अब आपको इस बात का बहुत ध्यान रखना चाहिए कि बाहरी ब्रैकेट का प्रकार गोल हो, यानी कि
कोष्टक. ऐसा इसलिए है क्योंकि आप एक @array को असाइन कर रहे हैं, इसलिए आपको कोष्ठक की आवश्यकता है। अगर
आप वहां चाहते थे नहीं @AoA बनने के लिए, बल्कि इसका केवल एक संदर्भ होने के लिए, आप ऐसा कर सकते हैं
कुछ और इस तरह:

# सरणी संदर्भों की सरणी के लिए एक संदर्भ निर्दिष्ट करें
$ref_to_AoA = [
["फ्रेड", "बार्नी", "कंकड़", "बमबम", "डिनो", ],
["जॉर्ज", "जेन", "एलरॉय", "जूडी", ],
["होमर", "बार्ट", "मार्ज", "मैगी", ],
];
$ref_to_AoA->[2][1] कहें;
Bart

ध्यान दें कि बाहरी ब्रैकेट प्रकार बदल गया है, और इसलिए हमारा एक्सेस सिंटैक्स भी बदल गया है।
ऐसा इसलिए है क्योंकि सी के विपरीत, पर्ल में आप स्वतंत्र रूप से एरे और संदर्भों का आदान-प्रदान नहीं कर सकते हैं
तत्संबंधी. $ref_to_AoA एक सरणी का संदर्भ है, जबकि @AoA एक सरणी है।
इसी तरह, $AoA[2] एक सरणी नहीं है, बल्कि एक सरणी रेफरी है। तो आप इन्हें कैसे लिख सकते हैं:

$AoA[2][2]
$ref_to_AoA->[2][2]

इन्हें लिखने के बजाय:

$AoA[2]->[2]
$ref_to_AoA->[2]->[2]

खैर, ऐसा इसलिए है क्योंकि नियम यह है कि केवल आसन्न कोष्ठक पर (चाहे वर्गाकार हो या घुंघराले),
आप पॉइंटर डीरेफ़रेंसिंग तीर को छोड़ने के लिए स्वतंत्र हैं। लेकिन आप ऐसा तत्काल नहीं कर सकते
पहला यदि यह एक अदिश राशि है जिसमें एक संदर्भ है, जिसका अर्थ है कि $ref_to_AoA हमेशा
इसकी जरूरत है.

बढ़ रहा है आपका खुद की
एक निश्चित डेटा संरचना की घोषणा के लिए यह सब ठीक है और अच्छा है, लेकिन यदि आप चाहें तो क्या होगा
तुरंत नए तत्व जोड़ने के लिए, या इसे पूरी तरह से स्क्रैच से बनाने के लिए?

सबसे पहले, आइए इसे एक फ़ाइल से पढ़कर देखें। यह कुछ-कुछ a पर पंक्ति जोड़ने जैसा है
समय। हम मान लेंगे कि एक सपाट फ़ाइल है जिसमें प्रत्येक पंक्ति एक पंक्ति है और प्रत्येक शब्द एक है
तत्व। यदि आप इन सभी से युक्त एक @AoA सरणी विकसित करने का प्रयास कर रहे हैं, तो यह सही है
ऐसा करने का तरीका:

जबकि (<>) {
@tmp = विभाजन;
पुश @AoA, [@tmp ];
}

आपने इसे किसी फ़ंक्शन से भी लोड किया होगा:

$i के लिए (1..10) {
$AoA[$i] = [ somefunc($i) ];
}

या हो सकता है कि आपके पास सारणी के साथ एक अस्थायी चर बैठा हो।

$i के लिए (1..10) {
@tmp = somefunc ($ i);
$AoA[$i] = [ @tmp ];
}

यह महत्वपूर्ण है कि आप "[ ]" ऐरे रेफरेंस कंस्ट्रक्टर का उपयोग करना सुनिश्चित करें। ऐसा है क्योंकि
यह काम नहीं करेगा:

$AoA[$i] = @tmp; # गलत!

जो आप चाहते हैं वह नहीं होने का कारण यह है कि उस जैसी नामित सरणी निर्दिष्ट करना
स्केलर, स्केलर संदर्भ में एक सरणी ले रहा है, जिसका अर्थ है कि केवल संख्या की गणना करता है
@tmp में तत्व।

यदि आप "यूज़ स्ट्रिक्ट" के अंतर्गत चल रहे हैं (और यदि आप नहीं हैं, तो आखिर आप ऐसा क्यों नहीं हैं?),
आपको इसे खुश करने के लिए कुछ घोषणाएँ जोड़नी होंगी:

सख्त उपयोग करें;
मेरा (@AoA, @tmp);
जबकि (<>) {
@tmp = विभाजन;
पुश @AoA, [@tmp ];
}

बेशक, आपको नाम रखने के लिए अस्थायी सरणी की बिल्कुल भी आवश्यकता नहीं है:

जबकि (<>) {
धक्का @AoA, [विभाजित];
}

आपको भी उपयोग नहीं करना पड़ेगा धक्का दें(). यदि आपको जानकारी हो तो आप सीधा असाइनमेंट बना सकते हैं
आप इसे कहां रखना चाहते थे:

मेरा (@AoA, $i, $line);
$i के लिए (0..10) {
$लाइन = <>;
$AoA[$i] = [विभाजित " ", $लाइन ];
}

या बस भी

मेरा (@AoA, $i);
$i के लिए (0..10) {
$AoA[$i] = [विभाजन " ", <> ];
}

आपको आमतौर पर ऐसे फ़ंक्शंस का उपयोग करने से सावधान रहना चाहिए जो संभावित रूप से सूचियाँ लौटा सकते हैं
ऐसा स्पष्ट रूप से बताए बिना अदिश संदर्भ। यह सामान्य लोगों के लिए अधिक स्पष्ट होगा
पाठक:

मेरा (@AoA, $i);
$i के लिए (0..10) {
$AoA[$i] = [विभाजन " ", अदिश(<>) ];
}

यदि आप किसी सरणी के संदर्भ के रूप में $ref_to_AoA वैरिएबल चाहते हैं, तो आपको यह करना होगा
कुछ इस तरह:

जबकि (<>) {
पुश @$ref_to_AoA, [विभाजन];
}

अब आप नई पंक्तियाँ जोड़ सकते हैं. नए कॉलम जोड़ने के बारे में क्या? यदि आप बस के साथ काम कर रहे हैं
मैट्रिक्स, सरल असाइनमेंट का उपयोग करना अक्सर सबसे आसान होता है:

$x के लिए (1..10) {
$y के लिए (1..10) {
$ एओए [$ एक्स] [$ वाई] = फंक ($ एक्स, $ वाई);
}
}

$x के लिए ( 3, 7, 9 ) {
$AoA[$x][20] += func2($x);
}

इससे कोई फर्क नहीं पड़ता कि वे तत्व पहले से ही वहां हैं या नहीं: यह ख़ुशी से निर्माण करेगा
उन्हें आपके लिए, आवश्यकतानुसार हस्तक्षेप करने वाले तत्वों को "अनिर्धारित" पर सेट करें।

यदि आप केवल एक पंक्ति में जोड़ना चाहते हैं, तो आपको कुछ अधिक मज़ेदार दिखने वाला कुछ करना होगा:

# मौजूदा पंक्ति में नए कॉलम जोड़ें
पुश @{ $AoA[0] }, "विल्मा", "बेट्टी"; # स्पष्ट डेरेफ़

पर्ल 5.14 से पहले, यह संकलित भी नहीं होता था:

पुश $AoA[0], "विल्मा", "बेट्टी"; # अंतर्निहित डेरेफ़

ऐसा कैसे? क्योंकि एक समय की बात है, तर्क धक्का दें() एक वास्तविक सरणी होनी चाहिए, नहीं
बस एक का संदर्भ। यह अब सच नहीं है. वास्तव में, लाइन "अंतर्निहित डेरेफ़" के रूप में चिह्नित है
उपरोक्त बिल्कुल ठीक काम करता है--इस उदाहरण में--वह करने के लिए जो स्पष्ट डेरेफ़ कहता है उसने किया।

"इस उदाहरण में" मैंने जो कहा उसका कारण यह है केवल काम करता है क्योंकि $AoA[0] पहले से ही
एक सरणी संदर्भ रखा। यदि आप इसे अपरिभाषित चर पर आज़माते हैं, तो आप एक लेंगे
अपवाद। ऐसा इसलिए है क्योंकि अंतर्निहित डीरेफ़रेंस कभी भी किसी अपरिभाषित को स्वत: जीवंत नहीं करेगा
परिवर्तनशील तरीका "@{ }" हमेशा रहेगा:

मेरा $aref = undef;
पुश $aref, qw(कुछ और मान); # गलत!
पुश @$aref, qw(कुछ और); # ठीक है

यदि आप इस नए अंतर्निहित डीरेफ़रेंसिंग व्यवहार का लाभ उठाना चाहते हैं, तो तुरंत आगे बढ़ें:
यह आंख और कलाई पर कोड को आसान बनाता है। बस यह समझें कि पुरानी रिलीज़ें बंद हो जाएंगी
संकलन के दौरान उस पर. जब भी आप किसी ऐसी चीज़ का उपयोग करते हैं जो केवल कुछ में ही काम करती है
पर्ल की रिलीज़ और बाद में, लेकिन पहले नहीं, आपको एक प्रमुख स्थान देना चाहिए

v5.14 का उपयोग करें; # सरणी ऑप्स द्वारा सरणी रेफरी के निहित डीरेफ़ के लिए आवश्यक

उस फ़ाइल के शीर्ष पर निर्देश जिसे इसकी आवश्यकता है। इस तरह जब कोई चलाने की कोशिश करता है
किसी पुराने पर्ल के अंतर्गत नया कोड, जैसी त्रुटि प्राप्त करने के बजाय

पुश करने के लिए arg 1 का प्रकार /tmp/a लाइन 8 पर, ""betty";" के पास, ऐरे (एरे एलिमेंट नहीं) होना चाहिए;
संकलन त्रुटियों के कारण /tmp/a का निष्पादन निरस्त हो गया।

उन्हें विनम्रतापूर्वक इसकी जानकारी दी जाएगी

पर्ल v5.14.0 आवश्यक--यह केवल v5.12.3 है, /tmp/a पंक्ति 1 पर रुका हुआ है।
BEGIN विफल--संकलन /tmp/a पंक्ति 1 पर निरस्त हुआ।

पहुँच और मुद्रण
अब आपकी डेटा संरचना को प्रिंट करने का समय आ गया है। आप उसे कैसे करने जा रहे हैं? तो अगर
आप केवल एक तत्व चाहते हैं, यह मामूली बात है:

$AoA[0][0] प्रिंट करें;

हालाँकि, यदि आप पूरी चीज़ मुद्रित करना चाहते हैं, तो आप नहीं कह सकते

@AoA प्रिंट करें; # गलत

क्योंकि आपको केवल संदर्भ सूचीबद्ध मिलेंगे, और पर्ल कभी भी स्वचालित रूप से संदर्भ को रद्द नहीं करेगा
आपके लिए चीजें. इसके बजाय, आपको खुद को एक या दो लूप रोल करना होगा। यह संपूर्ण प्रिंट करता है
शैल-शैली का उपयोग करते हुए संरचना के लिए() के बाहरी सेट पर लूप का निर्माण करें
सबस्क्रिप्ट।

$aref (@AoA) के लिए {
कहें "\t [@$aref ],";
}

यदि आप सबस्क्रिप्ट का ट्रैक रखना चाहते हैं, तो आप यह कर सकते हैं:

$i के लिए ( 0 .. $#AoA ) {
कहें "\t elt $i is [@{$AoA[$i]} ],";
}

या शायद ये भी. आंतरिक लूप पर ध्यान दें.

$i के लिए ( 0 .. $#AoA ) {
$j के लिए ( 0 .. $#{$AoA[$i]} ) {
कहें "elt $i $j is $AoA[$i][$j]";
}
}

जैसा कि आप देख सकते हैं, यह थोड़ा जटिल होता जा रहा है। इसीलिए कभी-कभी इसे लेना आसान होता है
आपके रास्ते में अस्थायी:

$i के लिए ( 0 .. $#AoA ) {
$aref = $AoA[$i];
$j के लिए ( 0 .. $#{$aref} ) {
कहें "elt $i $j is $AoA[$i][$j]";
}
}

हम्म... यह अभी भी थोड़ा बदसूरत है। इस बारे में कैसा है:

$i के लिए ( 0 .. $#AoA ) {
$aref = $AoA[$i];
$n = @$aref - 1;
$j के लिए ( 0 .. $n ) {
कहें "elt $i $j is $AoA[$i][$j]";
}
}

जब आप अपने डेटा संरचनाओं के लिए कस्टम प्रिंट लिखते-लिखते थक जाते हैं, तो आप इस पर गौर कर सकते हैं
मानक डंपवैल्यू या डेटा::डम्पर मॉड्यूल। पूर्व वही है जो पर्ल डिबगर है
उपयोग करता है, जबकि बाद वाला पार्स करने योग्य पर्ल कोड उत्पन्न करता है। उदाहरण के लिए:

v5.14 का उपयोग करें; # + प्रोटोटाइप का उपयोग करते हुए, v5.14 पर नया

उप शो(+) {
डंपवैल्यू की आवश्यकता है;
राज्य $सुंदरता = नया डंपवैल्यू::
टिक => q("),
कॉम्पैक्टडंप => 1, # इन दो पंक्तियों पर टिप्पणी करें
VeryCompact => 1, # यदि आप बड़ा डंप चाहते हैं
;
डंपवैल्यू $खूबसूरती@_;
}

# किसी सरणी के लिए सरणी संदर्भों की एक सूची निर्दिष्ट करें।
मेरा @AoA = (
["फ़्रेड", "बार्नी" ],
["जॉर्ज", "जेन", "एलरॉय" ],
["होमर", "मार्ज", "बार्ट" ],
);
पुश $AoA[0], "विल्मा", "बेट्टी";
@AoA दिखाएँ;

प्रिंट आउट लेंगे:

0 0..3 "फ्रेड" "बार्नी" "विल्मा" "बेटी"
1 0..2 "जॉर्ज" "जेन" "एलरॉय"
2 0..2 "होमर" "मार्ज" "बार्ट"

जबकि यदि आप मेरे द्वारा कही गई दो पंक्तियों पर टिप्पणी करना चाहते हैं, तो यह आपको यह दिखाता है
इसके बजाय इस तरह:

0 ARRAY(0x8031d0)
0 "फ्रेड"
1 "बार्नी"
2 "विल्मा"
3 "बेटी"
1 ARRAY(0x803d40)
0 "जॉर्ज"
1 "जेन"
2 "एलरॉय"
2 ARRAY(0x803e10)
0 "होमर"
1 "मार्ज"
2 "बार्ट"

स्लाइस
यदि आप एक बहुआयामी सरणी में एक स्लाइस (पंक्ति का हिस्सा) प्राप्त करना चाहते हैं, तो आप जा रहे हैं
कुछ फैंसी सबस्क्रिप्टिंग करनी होगी. ऐसा इसलिए है क्योंकि हमारे पास इसका एक अच्छा पर्यायवाची शब्द है
डीरेफ़रेंसिंग के लिए सूचक तीर के माध्यम से एकल तत्व, ऐसी कोई सुविधा मौजूद नहीं है
स्लाइस।

यहां बताया गया है कि लूप का उपयोग करके एक ऑपरेशन कैसे किया जाता है। हम पहले की तरह @AoA वेरिएबल मानेंगे।

@भाग = ();
$ x = 4;
($y = 7; $y < 13; $y++) के लिए {
पुश @पार्ट, $AoA[$x][$y];
}

उसी लूप को स्लाइस ऑपरेशन से बदला जा सकता है:

@भाग = @{$AoA[4]}[7..12];

या थोड़ी दूरी पर:

@भाग = @{ $AoA[4] } [7..12 ];

लेकिन जैसा कि आप भली-भांति कल्पना कर सकते हैं, यह पाठक के लिए बहुत कठिन हो सकता है।

आह, लेकिन क्या होगा यदि आप चाहते हैं? दो आयामी टुकड़ा, जैसे $x को 4..8 और $y से चलाना
7 से 12 तक चलाएँ? हम्म... यहाँ सरल तरीका है:

@newAoA = ();
के लिए ($startx = $x = 4; $x <= 8; $x++) {
के लिए ($starty = $y = 7; $y <= 12; $y++) {
$newAoA[$x - $startx][$y - $starty] = $AoA[$x][$y];
}
}

हम स्लाइस के माध्यम से कुछ लूपिंग को कम कर सकते हैं

के लिए ($x = 4; $x <= 8; $x++) {
पुश @newAoA, [@{$AoA[$x] } [7..12 ] ];
}

यदि आप श्वार्टज़ियन ट्रांसफ़ॉर्म में होते, तो संभवतः आपने उसके लिए मानचित्र का चयन किया होता

@newAoA = मानचित्र { [@{ $AoA[$_] } [7..12 ] ] } 4 .. 8;

यद्यपि यदि आपके प्रबंधक ने आप पर नौकरी की सुरक्षा (या तेजी से असुरक्षा) की मांग करने का आरोप लगाया है
गूढ़ कोड, इस पर बहस करना कठिन होगा। :-) अगर मैं तुम होते, तो मैं उसे इसमें डाल देता
समारोह:

@newAoA = splice_2D( \@AoA, 4 => 8, 7 => 12 );
उप ब्याह_2डी {
मेरा $lrr = शिफ्ट; # सरणी रेफरी की सरणी का संदर्भ!
मेरा ($x_lo, $x_hi,
$y_lo, $y_hi) = @_;

वापसी मानचित्र {
[@{ $lrr->[$_] } [ $y_lo .. $y_hi ] ]
} $x_lo .. $x_hi;
}

onworks.net सेवाओं का उपयोग करके ऑनलाइन perllol का उपयोग करें