फ़ंक्शन घोषणा "उप फ़ंक्शन ($$)" का क्या अर्थ है?

Question

मैं कुछ समय के लिए पर्ल का उपयोग किया गया, लेकिन आज मैं इस कोड में आए:

sub function1($$) 
{ 
    //snip 
} 

क्या पर्ल में मतलब है?

Answer 1

यह prototype के साथ एक फ़ंक्शन है जो दो स्केलर तर्क लेता है।

---

वास्तव में सामान्य रूप से पर्ल प्रोटोटाइप का उपयोग न करने के लिए मजबूत तर्क हैं - जैसा कि नीचे दी गई टिप्पणियों में उल्लेख किया गया है। मजबूत तर्क शायद है:

• Far More Than Everything You've Ever Wanted to Know about Prototypes in Perl

2008 से StackOverflow पर एक चर्चा नहीं है:

• SO 297034

MooseX::Method::Signatures मॉड्यूल में एक संभव प्रतिस्थापन नहीं है।

Answer 2

जैसा कि अन्य उत्तर उल्लेख है, $$ प्रोटोटाइप घोषित करता है। दूसरा जवाब क्या नहीं कहता है कि प्रोटोटाइप क्या हैं। वे इनपुट सत्यापन के लिए नहीं हैं, वे पार्सर के लिए संकेत हैं।

आप दो कार्यों की तरह घोषणा की है कल्पना कीजिए:

sub foo($) { ... } 
sub bar($$) { ... } 

अब जब आप कुछ अस्पष्ट, जैसे लिखें:

foo bar 1, 2 

पर्ल जानता है, जहां कोष्ठक डाल करने के लिए; बार में दो तर्क होते हैं, इसलिए यह दो निकटतम उपभोग करता है। foo एक आर्ग लेता है, तो यह बार का परिणाम और दो आर्ग लेता है:

foo(bar(1,2)) 

एक और उदाहरण:

bar foo 2, 3 

एक ही लागू होता है; तो यह हो जाता है 2. बार दो आर्ग लेता foo, एक आर्ग लेता है, तो यह foo(2) और 3 हो जाता है: तो यह नकारने

bar(foo(2),3) 

यह पर्ल की एक बहुत ही महत्वपूर्ण हिस्सा है, के रूप में "कभी नहीं का उपयोग करें" आप क्या कर रहा है एक असंतोष लगभग हर आंतरिक कार्य प्रोटोटाइप का उपयोग करता है, इसलिए यह समझकर कि वे आपके कोड में कैसे काम करते हैं, आप बेहतर ढंग से समझ सकते हैं कि इन्हें बिल्टिन द्वारा कैसे उपयोग किया जाता है। फिर आप अनावश्यक कोष्ठक से बच सकते हैं, जो अधिक सुखद दिखने वाले कोड के लिए बनाता है।

अंत में, एक विरोधी पैटर्न मैं के खिलाफ आपको चेतावनी देगा:

package Class; 
sub new ($$) { bless $_[1] } 
sub method ($) { $_[0]->{whatever} } 

आप तरीकों (Class->method या $instance->method) के रूप में कोड बुला रहे हैं, प्रोटोटाइप की जांच पूरी तरह से व्यर्थ है। यदि आपका कोड केवल एक विधि के रूप में कहा जा सकता है, तो प्रोटोटाइप जोड़ना गलत है। मैंने कुछ लोकप्रिय मॉड्यूल देखे हैं जो यह करते हैं (हैलो, XML::Compile), लेकिन यह गलत है, इसलिए ऐसा न करें।

sub foo { 
    my ($self, $a, $b) = @_; # $a and $b are the bars to fooify 
    .... 

या

use MooseX::Method::Signatures; 

method foo(Bar $a, Bar $b) { # fooify the bars 
    .... 

foo($$) के विपरीत, इन सार्थक और पठनीय हैं: आप कितने आर्ग पारित करने के लिए दस्तावेज़ के लिए, कैसे के बारे में जानना चाहते हैं।