क्या हैश संदर्भ पर पुनरावृत्त करने के लिए इसे पूरी तरह से perl में कॉपी करना आवश्यक है?

Question

आइए कहें कि मेरे पास एक बड़ा हैश है और मैं इसकी सामग्री की सामग्री पर पुन: प्रयास करना चाहता हूं। मानक मुहावरा कुछ इस तरह होगा:

while(($key, $value) = each(%{$hash_ref})){ 
    ///do something 
} 

हालांकि, अगर मैं समझता हूँ कि मेरी पर्ल सही ढंग से यह वास्तव में दो बातें कर रही है। सबसे पहले

%{$hash_ref} 

सूची संदर्भ में रेफरी का अनुवाद कर रहा है। इस प्रकार

(key1, value1, key2, value2, key3, value3 etc) 

जैसे कुछ लौटने पर मेरी स्टैक्स मेमोरी में संग्रहीत किया जाएगा। फिर प्रत्येक विधि चल जाएगी, स्मृति में पहले दो मानों को खाएं (key1 & value1) और प्रक्रिया के लिए उन्हें मेरे समय लूप पर लौटाना।

यदि मेरी समझ यह सही है कि इसका मतलब है कि मैंने अपने पूरे हैश को मेरी स्टैक्स मेमोरी में प्रभावी रूप से प्रतिलिपि बनाई है, तो केवल नई प्रतिलिपि को फिर से चालू करने के लिए, जो कि बड़े हैश के लिए महंगा हो सकता है, क्योंकि इसे फिर से शुरू करने की कीमत के कारण सरणी दो बार, लेकिन संभावित कैश हिट के कारण भी अगर दोनों हैंश को स्मृति में एक बार में नहीं रखा जा सकता है। यह बहुत अक्षम लगता है। मैं सोच रहा हूं कि क्या वास्तव में ऐसा होता है, या यदि मैं या तो वास्तविक व्यवहार को गलत समझ रहा हूं या संकलक मेरे लिए अक्षमता को अनुकूलित करता है?

मान लें कि मैं मानक व्यवहार के बारे में सही हूं।

1. क्या हैश की प्रतिलिपि से बचने के लिए हैश की प्रतिलिपि बनाने से बचने के लिए कोई वाक्यविन्यास है? यदि हैश के लिए नहीं है तो सरल सरणी के लिए कोई है?

2. क्या इसका मतलब यह है कि उपर्युक्त उदाहरण में मैं अपने हैश की प्रति और मेरे वास्तविक हैश के बीच असंगत मूल्य प्राप्त कर सकता हूं यदि मैं अपने लूप के भीतर हैश_फ सामग्री को संशोधित करता हूं; जिसके परिणामस्वरूप $ वैल्यू एक अलग मूल्य है तो $ हैश_फ -> ($ कुंजी)?

Answer 1

कोई प्रतिलिपि each द्वारा बनाई गई है (हालांकि आप काम के माध्यम से $key और $value में लौटे मूल्यों नकल करते हैं)। हैश खुद को each पर भेज दिया गया है।

each थोड़ा खास है। यह निम्नलिखित वाक्यविन्यासों का समर्थन करता है:

each HASH 
each ARRAY 

जैसा कि आप देख सकते हैं, यह मनमाने ढंग से अभिव्यक्ति स्वीकार नहीं करता है। (यह each EXPR या each LIST होगा)। इसका कारण सूची संदर्भ में मूल्यांकन करने के बजाय हैश %foo को each पर पास करने के लिए each(%foo) को अनुमति देना है। each ऐसा कर सकता है क्योंकि यह एक ऑपरेटर है, और ऑपरेटरों के पास अपने स्वयं के पार्सिंग नियम हो सकते हैं। हालांकि, आप \% प्रोटोटाइप के साथ कुछ ऐसा कर सकते हैं।

use Data::Dumper; 

sub f  { print(Dumper(@_)); } 
sub g(\%) { print(Dumper(@_)); } # Similar to each 

my %h = (a=>1, b=>2); 
f(%h); # Evaluates %h in list context. 
print("\n"); 
g(%h); # Passes a reference to %h. 

आउटपुट:

$VAR1 = 'a';   # 4 args, the keys and values of the hash 
$VAR2 = 1; 
$VAR3 = 'b'; 
$VAR4 = 2; 

$VAR1 = {    # 1 arg, a reference to the hash 
      'a' => 1, 
      'b' => 2 
     }; 

%{$h_ref}, %h रूप में ही है तो ऊपर के सभी %{$h_ref} को भी लागू होता है।

---

ध्यान दें कि हैश की प्रतिलिपि बनाई गई है, भले ही हैश की प्रतिलिपि न हो। चाबियां "प्रतिलिपि बनाई गई हैं", लेकिन मान सीधे लौटाए जाते हैं।

use Data::Dumper; 
my %h = (abc=>"def", ghi=>"jkl"); 
print(Dumper(\%h)); 
$_ = uc($_) for %h; 
print(Dumper(\%h)); 

आउटपुट:

$VAR1 = { 
      'abc' => 'def', 
      'ghi' => 'jkl' 
     }; 
$VAR1 = { 
      'abc' => 'DEF', 
      'ghi' => 'JKL' 
     }; 

आप इस here के बारे में अधिक पढ़ सकते हैं।

Answer 2

नहीं, आपके द्वारा उद्धृत वाक्यविन्यास एक प्रतिलिपि नहीं बनाता है।

यह अभिव्यक्ति:

%{$hash_ref} 

बिल्कुल के बराबर है:

%$hash_ref 

और $hash_ref अदिश चर संभालने वास्तव में एक हैश के लिए एक संदर्भ शामिल है, तो % जोड़ने पर सामने बस है संदर्भ को 'dereferencing' - यानी यह उस मान को हल करता है जो अंतर्निहित हैश का प्रतिनिधित्व करता है (वह बात जो $hash_ref इंगित कर रही थी)।

यदि आप each फ़ंक्शन के लिए दस्तावेज़ देखें, तो आप देखेंगे कि यह एक हैश को तर्क के रूप में उम्मीद करता है। मोर्चे पर % डालने का तरीका यह है कि जब आप हैशफ है तो आप हैश प्रदान करते हैं।

आप अपने खुद के सबरूटीन लिखा था और इस तरह से यह करने के लिए एक हैश पारित कर दिया है:

my_sub(%$hash_ref); 

फिर कुछ स्तर पर आप कह सकते हैं कि हैश किया गया 'की नकल की' था, सबरूटीन विशेष @_ सरणी के अंदर के बाद से हैश से सभी कुंजी/मूल्य जोड़े की एक सूची होगी। हालांकि, उस स्थिति में, @_ के तत्व वास्तव में कुंजी और मानों के लिए उपनाम हैं। यदि आप कुछ ऐसा करते हैं तो आपको वास्तव में एक प्रति प्राप्त होगी: my @args = @_।

पर्ल का बिल्टिन each फ़ंक्शन प्रोटोटाइप '+' के साथ घोषित किया गया है जो अंतर्निहित डेटा संरचना के संदर्भ में प्रभावी रूप से हैश (या सरणी) तर्क को सहारा देता है।

एक तरफ, संस्करण 5.14 के साथ शुरू, each फ़ंक्शन एक हैश का संदर्भ भी ले सकता है। तो बजाय:

($key, $value) = each(%{$hash_ref}) 

आप बस कह सकते हैं:

($key, $value) = each($hash_ref)