मैं पर्ल सबराउटिन को सशर्त रूप से परिभाषित कैसे कर सकता हूं?

Question

मैं एक पर्ल फ़ंक्शन को परिभाषित करना चाहता हूं (इसे "अंतर" कहते हैं) जो कमांड-लाइन तर्क पर निर्भर करता है। निम्नलिखित कोड काम नहीं करता:

if ("square" eq $ARGV[0]) {sub difference {return ($_[0] - $_[1]) ** 2}} 
elsif ("constant" eq $ARGV[0]) {sub difference {return 1}} 

ऐसा लगता है कि हालत नजरअंदाज कर दिया है, और इसलिए "अंतर" समारोह $ [0] ARGV के मूल्य की परवाह किए बिना दूसरी परिभाषा हो जाता है।

मैं समारोह में एक शर्त रख कर कोड काम कर सकते हैं:

sub difference { 
    if ("square" eq $ARGV[0]) {return ($_[0] - $_[1]) ** 2} 
    elsif ("constant" eq $ARGV[0]) {return 1} 
} 

लेकिन यह वास्तव में मेरा इरादा नहीं है - मैं शर्त की जरूरत नहीं है निष्पादन के दौरान हर बार मूल्यांकन किया जाना। मुझे बस कार्य की परिभाषा को प्रभावित करने के लिए एक तरीका चाहिए।

मेरे प्रश्न हैं:

1. पहले निर्माण क्यों काम नहीं करता है?
2. यह कोई त्रुटि क्यों नहीं देता है, या कुछ अन्य संकेत है कि कुछ गलत है?
3. क्या पर्ल में सशर्त रूप से कार्यों को परिभाषित करने का कोई तरीका है?

Answer 1

अन्य लोगों ने आपके द्वारा अनुरोधित वाक्यविन्यास पहले से ही प्रस्तुत कर दिया है, लेकिन मैं इसके लिए अधिक स्पष्ट सबराउटिन संदर्भों का उपयोग करने की अनुशंसा करता हूं, ताकि आप परिभाषा को कुशलतापूर्वक इस्तेमाल किए बिना संदर्भ में कुशलतापूर्वक उपयोग कर सकें।

sub square_difference { return ($_[0] - $_[1]) ** 2 } 
sub constant_difference { return 1 } 

my %lookup = (
    'square' => \&square_difference, 
    'constant' => \&constant_difference, 
); 

my $difference = $lookup{$ARGV[0]} || die "USAGE: $0 square|constant\n"; 
print &$difference(4, 1), "\n"; 

यह एक ही मूल दृष्टिकोण है, लेकिन मुझे लगता है कि इस वाक्य रचना आप और अधिक आसानी से आप प्रत्येक के और अधिक जोड़ने के रूप में एक सा सबरूटीन्स के लिए तर्क को मैप करने देगा: उदाहरण के लिए। ध्यान दें कि यदि आप उस तरह की चीज में हैं, तो Strategy Pattern पर यह एक भिन्नता है।

Answer 2

मैं व्यक्तिगत रूप से इस का एक बहुत नहीं किया है, लेकिन आप एक चर का उपयोग करने के सबरूटीन धारण करने के लिए चाहते हो सकता है:

my $difference; 
if ("square" eq $ARGV[0]) {$difference = sub {return ($_[0] - $_[1]) ** 2}} 
elsif ("constant" eq $ARGV[0]) {$difference = sub {return 1}} 

साथ कॉल:

&{ $difference }(args); 

या:

&$difference(args); 

या, जैसा कि लियोन टिमर्मन्स द्वारा सुझाया गया है:

$difference->(args); 

स्पष्टीकरण के बारे में थोड़ी - यह एक चर $difference बुलाया वाणी और, अपने परिवेश के आधार पर, यह सेट एक गुमनाम सबरूटीन के लिए एक संदर्भ धारण करने के लिए। इसलिए आपको subroutine को कॉल करने के लिए dereference$difference एक सबराउटिन (इसलिए & सामने) के रूप में है।

संपादित करें: कोड परीक्षण और काम करता है।

एक और संपादित करें:

यीशु, मैं इतना use ing strict और warnings है कि मैं भूल जाते हैं वे वैकल्पिक हैं करने के लिए इस्तेमाल कर रहा हूँ।

लेकिन गंभीरता से। हमेशा use strict; और use warnings;। इससे इस तरह की चीज़ों को पकड़ने में मदद मिलेगी, और आपको उपयोगी उपयोगी संदेश मिलेंगे जो बताते हैं कि क्या गलत है। strict और warnings की वजह से मुझे अपने जीवन में कभी भी डीबगर का उपयोग नहीं करना पड़ा - यह त्रुटि-जांच संदेश कितना अच्छा है। वे इस तरह की सभी चीजों को पकड़ लेंगे, और आपको के लिए उपयोगी संदेश भी देंगे, वे गलत हैं।

तो कृपया, जब भी आप कुछ लिखते हैं, कोई फर्क नहीं पड़ता कि कितना छोटा (जब तक यह obfuscated नहीं है), हमेशा use strict; और use warnings;।

Answer 3

आपको बस इतना करना इस तरह प्राप्त किया जा सकता चाहते हैं क्या:

if ($ARGV[0] eq 'square') { 
    *difference = sub { return ($_[0] - $_[1]) ** 2 }; 
} 
elsif ($ARGV[0] eq 'constant') { 
    *difference = sub { return 1 }; 
} 

Answer 4

Subs संकलन समय पर परिभाषित कर रहे हैं -> यदि आप "उपयोग चेतावनी" सक्षम था, आप सबरूटीन परिभाषा के बारे में एक त्रुटि संदेश देखा होगा।

Answer 5

फिर भी एक और तरीका है:

my $diffmode; 
BEGIN { $diffmode = $ARGV[0] } 
sub difference { 
    if ($diffmode eq 'square') { ($_[0] - $_[1]) ** 2 } 
    elsif ($diffmode eq 'constant') { 1 } 
    else { "It don't make no never mind" } 
} 

Answer 6

कैसे कोड काम करने के लिए के लिए सभी सुझावों के लिए धन्यवाद। बस पूर्णता के लिए, मैं अपने प्रश्न के उच्च स्तरीय जवाब दूंगा।

1. क्योंकि कार्यों संकलन समय पर परिभाषित कर रहे हैं, लेकिन शर्तों और/या कमांड लाइन तर्क रनटाइम पर मूल्यांकन किया जाता है पहले निर्माण काम नहीं करता। जब तक स्थिति का मूल्यांकन किया जाता है, नामित फ़ंक्शन को पहले ही परिभाषित किया जा चुका है।

2. कंपाइलर "चेतावनियों का उपयोग" के साथ चेतावनी देता है, हालांकि एक प्रोग्रामर के लिए बहुत उपयोगी नहीं है जो 1 :-) से अनजान है, अर्थपूर्ण चेतावनी देने में कठिनाई यह है कि अगर किसी कथन के अंदर परिभाषित कार्य समझ सकते हैं यदि आप लिन टिमर्मन्स के सुझाव में, अगर कथन के भीतर फ़ंक्शन के साथ कुछ भी करते हैं। मूल कोड एक खाली अगर कथन के लिए संकलित करता है, और संकलक इनके बारे में चेतावनी देने के लिए सेट नहीं है।

3. कड़ाई से बोलते हुए, सशर्त रूप से कार्यों को परिभाषित करना संभव नहीं है, लेकिन सशर्त रूप से कार्यों (rbright) या उपनाम (लियोन Timmermans) को कार्यों के लिए परिभाषित करना संभव है। सर्वसम्मति यह प्रतीत होती है कि संदर्भ उपनामों से बेहतर हैं, हालांकि मुझे पूरा यकीन नहीं है कि क्यों।

नोट 1: मूल्यांकन आदेश तब तक स्पष्ट नहीं है जब तक आप वास्तव में इस तरह की समस्या में भाग नहीं लेते; कोई एक पर्ल कल्पना कर सकता है जो संकलन समय पर स्थितियों का मूल्यांकन करेगा जब भी इसे सुरक्षित रूप से किया जा सके। स्पष्ट रूप से पर्ल ऐसा नहीं करता है, क्योंकि निम्न कोड भी एक परिभाषित सबराउटिन के बारे में चेतावनी देता है।

use warnings ; 
if (1) {sub jack {}} else {sub jack {}} 

Answer 7

अन्य उत्तर कोड संदर्भ या उपनाम का उपयोग कर अन्य उत्तर सही हैं। लेकिन एलियासिंग उदाहरण यिकी टाइपग्लोब सिंटैक्स पेश करते हैं और सख्त से निपटने के लिए भूल जाते हैं।

Alias एक भूल गया मॉड्यूल है जो सख्त रखने के दौरान एक संदर्भ देने के लिए आवश्यक सभी जादू को लपेटता है।

use strict; 
use Alias; 

my $difference_method = $ARGV[0]; 
if("square" eq $difference_method) { 
    alias difference => sub { return ($_[0] - $_[1]) ** 2 }; 
} 
elsif("constant" eq $difference_method) { 
    alias difference => sub { return 1 }; 
} 
else { 
    die "Unknown difference method $difference_method"; 
} 

और अब difference($a, $b) काम करता है।

यदि आपको केवल अपने कोड के अंदर difference() पर कॉल करने की आवश्यकता है, यानी। आप इसे एक समारोह के रूप में निर्यात नहीं करने जा रहे हैं, मैं सिर्फ एक कोड संदर्भ का उपयोग करता हूं और एलियासिंग भूल जाता हूं।

my $difference_method = $ARGV[0]; 

my $Difference; 
if("square" eq $difference_method) { 
    $Difference => sub { return ($_[0] - $_[1]) ** 2 }; 
} 
elsif("constant" eq $difference_method) { 
    $Difference => sub { return 1 }; 
} 
else { 
    die "Unknown difference method $difference_method"; 
} 

$Difference->($a, $b); 

सशर्त बदलते क्या एक समारोह करता है का पालन करने के कोड कठिन और कम लचीला बनाता है, बस किसी भी वैश्विक पर व्यवहार को बदलने की तरह।

my $Difference_Method = $ARGV[0]; 

sub difference { 
    if($Difference_Method eq 'square') { 
     return ($_[0] - $_[1]) ** 2; 
    } 
    elsif($Difference_Method eq 'constant') { 
     return 1; 
    } 
    else { 
     die "Unknown difference method $Difference_Method"; 
    } 
} 

किसी भी समय आप प्रपत्र की एक सबरूटीन है ...

sub foo { 
    if($Global) { 
     ...do this... 
    } 
    else { 
     ...do that... 
    } 
} 

आप एक समस्या है: जब आपको लगता है कि आप सिर्फ इस अनुकूलित कर रहे इसे और अधिक स्पष्ट हो जाता है।

एलिसिंग & को हाथ से चिपकाने के बजाय बंद करने के दौरान रन टाइम पर समान समय उत्पन्न करने के लिए सबसे उपयोगी है। लेकिन यह एक और सवाल के लिए है।