'मौजूद' का उपयोग कर अतिरिक्त हैश लुकअप?

Question

मैं कभी कभी इस तरह एक हैश का उपयोग:

if(exists $ids{$name}){ 
    $id = $ids{$name}; 
} 

अच्छा अभ्यास है कि है? मैं थोड़ा चिंतित हूं कि इसमें दो लुकअप हैं जहां वास्तव में एक किया जाना चाहिए। क्या अस्तित्व की जांच करने और मूल्य असाइन करने का कोई बेहतर तरीका है?

Answer 1

exists साथ की जाँच करके किया गया था, आप autovivification को रोकने के। Autovivification : What is it and why do I care? देखें।

अद्यतन:trendels नीचे बताए गए अनुसार, आपके द्वारा पोस्ट किए गए उदाहरण में ऑटोविविफिकेशन नहीं खेलता है। मुझे लगता है कि वास्तविक कोड में बहु-स्तर हैंश शामिल हैं। अगर यह एक बहु स्तरीय हैश आप यह कर सकते हैं नहीं है

#!/usr/bin/perl 

use strict; 
use warnings; 

use Data::Dumper; 

my (%hash, $x); 

if (exists $hash{test}->{vivify}) { 
    $x = $hash{test}->{vivify}->{now}; 
} 

print Dumper \%hash; 

$x = $hash{test}->{vivify}->{now}; 

print Dumper \%hash; 

__END__ 


C:\Temp> t 
$VAR1 = { 
    'test' => {} 
}; 
$VAR1 = { 
    'test' => { 
     'vivify' => {} 
    } 
}; 

Answer 2

आप एक देखने इस तरह से यह कर सकते हैं:

$tmp = $ids{$name}; 
$id = $tmp if (defined $tmp); 

हालांकि, मैं परेशान नहीं होगा जब तक कि मैंने देखा है कि है कि एक टोंटी

Answer 3

:

यहाँ एक उदाहरण है

$id = $ids{$name} || 'foo'; 

या $ आईडी पहले से ही अपना महत्व होता है यदि:

$id ||= $ids{$name}; 

जहां 'foo' डिफ़ॉल्ट या गिरावट वाला मान है। यदि यह एक बहु-स्तर हैश है तो आप थ्रेड में पहले चर्चा की गई ऑटोविविफिकेशन से बचने के लिए 'मौजूद' का उपयोग करेंगे या अगर ऑटोविविफिकेशन कोई समस्या नहीं होने वाला है तो इसका उपयोग न करें।

Answer 4

आप हैश पर Hash::Util की लॉक_की लागू कर सकते हैं। फिर एक eval के भीतर अपने असाइनमेंट प्रदर्शन करते हैं।

my %h; 
for my $key (@some_vals) { 
    ... 
    $h{$key} = undef unless exists $h{$key}; 
    ... 
} 

return keys %h; 

इस कोड को थोड़ा आमतौर पर की तुलना में तेजी प्रयोग किया जाता है $h{$key}++:

#!/usr/bin/perl 
use Hash::Util qw/lock_keys/; 

my %a = (
    1 => 'one', 
    2 => 'two' 
); 

lock_keys(%a); 

eval {$val = $a{2}};  # this assignment completes 
eval {$val = $a{3}};  # this assignment aborts 
print "val=$val\n";  # has value 'two' 

Answer 5

अगर मैं उच्च प्रदर्शन चाहते हैं मैं इस मुहावरे लिखने के लिए जब चाहते सेट के रूप में हैश बनाने के लिए प्रयोग किया जाता रहा हूँ। exists बेकार असाइनमेंट से बचाता है और undef मूल्य के लिए आवंटन से बचाता है। आपके लिए सबसे अच्छा जवाब है: इसे बेंचमार्क करें! मुझे लगता है कि exists $ids{$name}$id=$ids{$name} से थोड़ा तेज़ है और यदि आपके पास बड़ा मिस अनुपात है तो आपका संस्करण मौजूद है, असाइनमेंट और परीक्षण के बाद तेज़ हो सकता है।

उदाहरण के लिए यदि मैं तेज़ सेट चौराहे चाहता हूं तो मैं ऐसा कुछ लिखूंगा।

sub intersect { 
    my $h; 
    @$h{@{shift()}} =(); 
    my $i; 
    for (@_) { 
    return unless %$h; 
    $i = {}; 
    @$i{grep exists $h->{$_}, @$_} =(); 
    $h = $i; 
    } 
    return keys %$h; 
} 

Answer 6

प्रदर्शन इस मामले में महत्वपूर्ण नहीं है "डेवेल :: NYTProf"। लेकिन आपके सवाल का जवाब देने के लिए: अगर हैश में मूल्य मौजूद नहीं है

, "मौजूद है" बहुत तेजी से

if(exists $ids{$name}){ 
    $id = $ids{$name}; 
} 

है लेकिन अगर यह करने वाला दूसरा देखने किया जाता है मौजूद है। केवल एक ही स्वरूप को प्रभावी बनाने से मौजूद है, तो मूल्य की संभावना है हो जाएगा तेजी से

$id = $ids{$name}; 
if($id){ 
    #.... 
} 

एक पर्ल मेलिंग सूची से इस छोटे से बेंचमार्क देखते हैं।

#!/usr/bin/perl -w 
use strict; 
use Benchmark qw(timethese); 

use vars qw(%hash); 
@hash{ 'A' .. 'Z', 'a' .. 'z' } = (1) x 52; 

my $key = 'xx'; 
timethese 10000000, { 
     'defined' => sub { 
       if (defined $hash{$key}) { my $x = $hash{$key}; return $x; }; 
       return 0; 
     }, 
     'defined_smart' => sub { 
       my $x = $hash{$key}; 
       if (defined $x) { 
         return $x; 
       }; 
       return 0; 
     }, 
     'exists' => sub { 
       if (exists $hash{$key}) { my $x = $hash{$key}; return $x; }; 
       return 0; 
     }, 
     'as is' => sub { 
       if ($hash{$key}) { my $x = $hash{$key}; return $x; }; 
       return 0; 
     }, 
     'as is_smart' => sub { 
       my $x = $hash{$key}; 
       if ($x) { return $x; }; 
       return 0; 
     }, 

}; 

एक कुंजी ('xx') का उपयोग करके मौजूद नहीं है जो दिखाता है कि 'मौजूद' विजेता है।

Benchmark: timing 10000000 iterations of as is, as is_smart, defined, defined_smart, exists... 
    as is: 1 wallclock secs (1.52 usr + 0.00 sys = 1.52 CPU) @ 6578947.37/s (n=10000000) 
as is_smart: 3 wallclock secs (2.67 usr + 0.00 sys = 2.67 CPU) @ 3745318.35/s (n=10000000) 
    defined: 3 wallclock secs (1.53 usr + 0.00 sys = 1.53 CPU) @ 6535947.71/s (n=10000000) 
defined_smart: 3 wallclock secs (2.17 usr + 0.00 sys = 2.17 CPU) @ 4608294.93/s (n=10000000) 
    exists: 1 wallclock secs (1.33 usr + 0.00 sys = 1.33 CPU) @ 7518796.99/s (n=10000000) 

एक प्रमुख ('एक्स') है कि मौजूद है करता है का उपयोग कर पता चलता है कि 'is_smart' के रूप में विजेता है।

Benchmark: timing 10000000 iterations of as is, as is_smart, defined, defined_smart, exists... 
    as is: 3 wallclock secs (2.76 usr + 0.00 sys = 2.76 CPU) @ 3623188.41/s (n=10000000) 
as is_smart: 3 wallclock secs (1.81 usr + 0.00 sys = 1.81 CPU) @ 5524861.88/s (n=10000000) 
    defined: 3 wallclock secs (3.42 usr + 0.00 sys = 3.42 CPU) @ 2923976.61/s (n=10000000) 
defined_smart: 2 wallclock secs (2.32 usr + 0.00 sys = 2.32 CPU) @ 4310344.83/s (n=10000000) 
    exists: 3 wallclock secs (2.83 usr + 0.00 sys = 2.83 CPU) @ 3533568.90/s (n=10000000)