मैं यहाँ एक उत्तर प्रदान करूँगा क्योंकि यहाँ के लोग मेरे लिए बहुत क्लिक नहीं करते थे।
पर्ल का आशीर्वाद समारोह पैकेज के अंदर सभी कार्यों के लिए किसी भी संदर्भ को जोड़ता है।
हमें इसकी आवश्यकता क्यों होगी?
आइए जावास्क्रिप्ट में एक उदाहरण व्यक्त करके शुरू करते हैं:
(() => {
'use strict';
class Animal {
constructor(args) {
this.name = args.name;
this.sound = args.sound;
}
}
/* [WRONG] (global scope corruption)
* var animal = Animal({
* 'name': 'Jeff',
* 'sound': 'bark'
* });
* console.log(animal.name + ', ' + animal.sound); // seems good
* console.log(window.name); // my window's name is Jeff?
*/
// new is important!
var animal = new Animal(
'name': 'Jeff',
'sound': 'bark'
);
console.log(animal.name + ', ' + animal.sound); // still fine.
console.log(window.name); // undefined
})();
अब कक्षा निर्माण को हटा दें और उसके बिना करें:
(() => {
'use strict';
var Animal = function(args) {
this.name = args.name;
this.sound = args.sound;
return this; // implicit context hashmap
};
// the "new" causes the Animal to be unbound from global context, and
// rebinds it to an empty hash map before being constructed. The state is
// now bound to animal, not the global scope.
var animal = new Animal({
'name': 'Jeff',
'sound': 'bark'
});
console.log(animal.sound);
})();
फ़ंक्शन अनऑर्डर किए गए गुणों की एक हैश तालिका लेता है (क्योंकि 2016 में गतिशील भाषाओं में एक विशिष्ट क्रम में गुण लिखने के लिए कोई मतलब नहीं है) और उन गुणों के साथ एक हैश तालिका देता है, या यदि आप नया कीवर्ड डालना भूल गए हैं, तो यह पूरे वैश्विक संदर्भ (उदाहरण के लिए ब्राउज़र में विंडो या नोडज में वैश्विक) वापस कर देगा।
पर्ल के पास कोई "यह" या "नया" नहीं है और न ही "क्लास" है, लेकिन इसमें अभी भी एक फ़ंक्शन हो सकता है जो समान व्यवहार करता है। हमारे पास न तो कोई निर्माता होगा और न ही कोई प्रोटोटाइप, लेकिन हम अपनी इच्छा के अनुसार नए जानवरों को बनाने और उनके व्यक्तिगत गुणों को संशोधित करने में सक्षम होंगे।
# self contained scope
(sub {
my $Animal = (sub {
return {
'name' => $_[0]{'name'},
'sound' => $_[0]{'sound'}
};
});
my $animal = $Animal->({
'name' => 'Jeff',
'sound' => 'bark'
});
print $animal->{sound};
})->();
अब, हमारे पास एक समस्या है: क्या होगा अगर हम चाहते हैं कि जानवर हमारे बजाय खुद से ध्वनियों का प्रदर्शन करें, जो कि उनकी आवाज है। यही है, हम एक कार्य प्रदर्शन चाहते हैं जो जानवर की अपनी आवाज़ को प्रिंट करता है।
ऐसा करने का एक तरीका यह है कि प्रत्येक व्यक्तिगत पशु को यह सिखाया जाए कि यह कैसे ध्वनि है। इसका मतलब है कि प्रत्येक बिल्ली का प्रदर्शन करने के लिए अपना स्वयं का डुप्लिकेट फ़ंक्शन है।
# self contained scope
(sub {
my $Animal = (sub {
$name = $_[0]{'name'};
$sound = $_[0]{'sound'};
return {
'name' => $name,
'sound' => $sound,
'performSound' => sub {
print $sound . "\n";
}
};
});
my $animal = $Animal->({
'name' => 'Jeff',
'sound' => 'bark'
});
$animal->{'performSound'}();
})->();
यह बुरा है क्योंकि हर बार एक जानवर के निर्माण के दौरान PerformSound को पूरी तरह से नए फ़ंक्शन ऑब्जेक्ट के रूप में रखा जाता है। 10000 जानवरों का मतलब होता है 10000 प्रदर्शन। हम चाहते हैं कि एक एकल फंक्शन परफॉर्म किया जाए जो सभी जानवरों द्वारा उपयोग किया जाता है जो अपनी खुद की आवाज़ को देखता है और इसे प्रिंट करता है।
(() => {
'use strict';
/* a function that creates an Animal constructor which can be used to create animals */
var Animal = (() => {
/* function is important, as fat arrow does not have "this" and will not be bound to Animal. */
var InnerAnimal = function(args) {
this.name = args.name;
this.sound = args.sound;
};
/* defined once and all animals use the same single function call */
InnerAnimal.prototype.performSound = function() {
console.log(this.name);
};
return InnerAnimal;
})();
/* we're gonna create an animal with arguments in different order
because we want to be edgy. */
var animal = new Animal({
'sound': 'bark',
'name': 'Jeff'
});
animal.performSound(); // Jeff
})();
यहाँ वह जगह है जहाँ पर्ल थोरा के समानांतर रुकता है।
जावास्क्रिप्ट का नया ऑपरेटर वैकल्पिक नहीं है, इसके बिना, "यह" ऑब्जेक्ट विधियों के अंदर वैश्विक गुंजाइश को दूषित करता है:
(() => {
// 'use strict'; // uncommenting this prevents corruption and raises an error instead.
var Person = function() {
this.name = "Sam";
};
// var wrong = Person(); // oops! we have overwritten window.name or global.main.
// console.log(window.name); // my window's name is Sam?
var correct = new Person; // person's name is actually stored in the person now.
})();
हम प्रत्येक पशु के लिए एक कार्य करना चाहते हैं जो कि उस जानवर की स्वयं की आवाज़ को देखता है जो निर्माण के दौरान इसे हार्डकोड करने के बजाय करता है।
आशीर्वाद हमें वस्तुओं के प्रोटोटाइप के रूप में एक पैकेज का उपयोग करने देता है। इस तरह, वस्तु "पैकेज" के बारे में पता है, यह "संदर्भित" है, और बदले में पैकेज में कार्य हो सकते हैं "पहुंच" उस विशिष्ट पैकेज के निर्माण से बनाए गए विशिष्ट उदाहरण हैं:
package Animal;
sub new {
my $packageRef = $_[0];
my $name = $_[1]->{'name'};
my $sound = $_[1]->{'sound'};
my $this = {
'name' => $name,
'sound' => $sound
};
bless($this, $packageRef);
return $this;
}
# all animals use the same performSound to look up their sound.
sub performSound {
my $this = shift;
my $sound = $this->{'sound'};
print $sound . "\n";
}
package main;
my $animal = Animal->new({
'name' => 'Cat',
'sound' => 'meow'
});
$animal->performSound();
सारांश / टीएल; डीआर :
पर्ल का कोई "यह", "वर्ग" नहीं है, न ही "नया"। किसी पैकेज के लिए किसी वस्तु को आशीर्वाद देना उस वस्तु को पैकेज का संदर्भ देता है, और जब यह पैकेज में फ़ंक्शन को कॉल करता है, तो उनके तर्क 1 स्लॉट द्वारा ऑफसेट किए जाएंगे, और पहला तर्क ($ _ [0] या शिफ्ट) समकक्ष होगा। जावास्क्रिप्ट का "यह"। बदले में, आप कुछ हद तक जावास्क्रिप्ट के प्रोटोटाइप मॉडल का अनुकरण कर सकते हैं।
दुर्भाग्य से यह असंभव है (मेरी समझ में) रनटाइम पर "नई कक्षाएं" बनाने के लिए, जैसा कि आपको प्रत्येक "वर्ग" की आवश्यकता है कि उसका अपना पैकेज हो, जबकि जावास्क्रिप्ट में, आपको "नए" कीवर्ड के रूप में पैकेजों की आवश्यकता नहीं है रन-वे पर एक पैकेज के रूप में उपयोग करने के लिए एक अनाम हैशमैप बनाता है जिसमें आप नए फ़ंक्शंस जोड़ सकते हैं और फ़्लाई पर फ़ंक्शंस निकाल सकते हैं।
कुछ सीमाएँ लाइब्रेरी हैं जो अभिव्यक्ति में इस सीमा को भंग करने के अपने तरीके बनाते हैं, जैसे कि मूस।
भ्रम क्यों?:
पैकेज की वजह से। हमारा अंतर्ज्ञान हमें वस्तु को उसके 'प्रोटोटाइप' वाले हैशमैप से बांधने को कहता है। इससे हम जावास्क्रिप्ट जैसे रनटाइम पर "पैकेज" बना सकते हैं। पर्ल में ऐसा लचीलापन नहीं है (कम से कम में निर्मित नहीं है, आपको इसे आविष्कार करना होगा या इसे अन्य मॉड्यूल से प्राप्त करना होगा), और बदले में आपके रनटाइम की अभिव्यक्ति में बाधा होती है। इसे "आशीर्वाद" कहकर न तो यह बहुत एहसान करता है।
हम क्या करना चाहते हैं :
ऐसा कुछ है, लेकिन प्रोटोटाइप मैप के पुनरावर्ती के लिए बाध्यकारी है, और स्पष्ट रूप से ऐसा करने के बजाय प्रोटोटाइप से बाध्य होना चाहिए।
यहाँ इस पर एक भोली कोशिश है: मुद्दा यह है कि "कॉल" को "इसे क्या कहा जाता है" नहीं पता है, इसलिए यह एक सार्वभौमिक पर्ल फ़ंक्शन हो सकता है "objectInvokeMethod (ऑब्जेक्ट, विधि)" जो जाँचता है कि ऑब्जेक्ट की विधि है या नहीं , या इसके प्रोटोटाइप में यह है, या इसके प्रोटोटाइप में यह है, जब तक कि यह अंत तक नहीं पहुंचता और इसे पाता है या नहीं (प्रोटोटाइप इनहेरिटेंस)। पर्ल के पास इसे करने के लिए अच्छा स्पष्ट जादू है, लेकिन मैं बाद में कुछ करने की कोशिश कर सकता हूं।
वैसे भी यहाँ विचार है:
(sub {
my $Animal = (sub {
my $AnimalPrototype = {
'performSound' => sub {
return $_[0]->{'sound'};
}
};
my $call = sub {
my $this = $_[0];
my $proc = $_[1];
if (exists $this->{$proc}) {
return $this->{$proc}->();
} else {
return $this->{prototype}->{$proc}->($this, $proc);
}
};
return sub {
my $name = $_[0]->{name};
my $sound = $_[0]->{sound};
my $this = {
'this' => $this,
'name' => $name,
'sound' => $sound,
'prototype' => $AnimalPrototype,
'call' => $call
};
};
})->();
my $animal = $Animal->({
'name' => 'Jeff',
'sound'=> 'bark'
});
print($animal->{call}($animal, 'performSound'));
})->();
वैसे भी उम्मीद है कि किसी को यह पोस्ट उपयोगी लगेगी।