क्या हैश :: यौगिक हैश के लिए वैकल्पिक विकल्प है?

Question

मैं इस प्रकार

my $ch = { 
    k1 => [ { k=>1 }, { m=>2 } ], 
    k2 => [ { l=>90}, ... ], 
}; 

Hash::Util::lock_hashref_recurse($ch) प्रभावी ढंग से इन मूल्यों को लॉक नहीं करता एक यौगिक hashref है ..

@{$ch->{k1}}[0]->{k} = 'New value'; अनुमति दी है! मैं इस तरह के हैशफ को पूरी तरह से कैसे लॉक करूं?

Answer 1

documentation के अनुसार:

यह विधि केवल recurses हैश है कि एक और हैश द्वारा संदर्भित कर रहे हैं में। इस प्रकार हैश का एक हैश (होह) प्रतिबंधित हो जाएगा, लेकिन हैश के होश के एक हैश (होआओएच) में केवल शीर्ष हैश प्रतिबंधित होगा। अर्थात lock_hash/lock_hashref:

और तुम Hashes

के एरे

Answer 2

Hash::Util ही आप एक निम्न स्तर के समारोह है कि आप XS कार्यक्षमता के बिना पर्ल में दोहराने कर सकते हैं प्रदान करता है की एक हैश है। आपको जितनी अधिक कार्यक्षमता चाहिए वह एक सरल हैश ट्रैवर्सल है और मैन्युअल रूप से मैन्युअल रूप से कार्यान्वित किया जा सकता है। देखे गए लोगों की सूची रखते हुए और पाए गए हैंश की सूची रखते हुए नेस्टेड संदर्भों के माध्यम से आगे बढ़ें और फिर lock_hashref के साथ उस मिली सूची में लूप चलाएं।

Answer 3

use strictures; 
use Hash::Util qw(lock_hash); 
use Data::Visitor::Callback qw(); 

my $ch = { 
    k1 => [{k => 1}, {m => 2}], 
    k2 => [{l => 90},], 
}; 

Data::Visitor::Callback->new(
    hash => sub { 
     lock_hash %{ $_ }; 
     return $_; 
    } 
)->visit($ch); 

$ch->{k1}[0]{k} = 'New value'; 
__END__ 
Modification of a read-only value attempted at … 

Answer 4

जो किसी भी पर्ल चर केवल पढ़ने के लिए पूरी तरह से करने के लिए सक्षम है Const::Fast नहीं है,।

आपको हैश का मरने पर व्यवहार नहीं मिलेगा जब तक कि आप एक गैर-कानूनी कुंजी पढ़ने की कोशिश करते हैं।

Answer 5

Readonly के बारे में क्या?

उदा।

use Readonly; 
Readonly my %h3 => (
    k1 => [ { k=>1 }, { m=>2 } ], 
    k2 => [ { l=>90}, ], 
); 
print "old value: '$h3{k1}->[0]->{k}'\n"; 
$h3{k1}->[0]->{k} = 'New value'; 
print "new value: '$h3{k1}->[0]->{k}'\n"; 

देता

old value: '1' 
Modification of a read-only value attempted at readonly.pl line 7 

ध्यान दें कि %h3 एक हैश, नहीं एक hashref है। Hashrefs केवल पढ़ने के साथ अच्छी तरह से काम नहीं करते:

use Readonly; 
Readonly my $h2 => { 
    k1 => [ { k=>1 }, { m=>2 } ], 
    k2 => [ { l=>90}, ], 
}; 
print "old value: '$h2->{k1}->[0]->{k}'\n"; 
$h2->{k1}->[0]->{k} = 'New value'; 
print "new value: '$h2->{k1}->[0]->{k}'\n"; 

,

old value: '1' 
new value: 'New value'