आपके प्रश्न में आपके द्वारा दिखाए गए दोनों कोड नमूने प्रोटोटाइपिक विरासत का उपयोग करते हैं। वास्तव में आप जावास्क्रिप्ट में जो भी ऑब्जेक्ट-ओरिएंटेड कोड लिखते हैं, वह प्रोटोटाइप इनहेरिटेंस का एक प्रतिमान है। जावास्क्रिप्ट केवल शास्त्रीय विरासत नहीं है। यह चीजों को थोड़ा स्पष्ट करना चाहिए:
Inheritance
|
+-----------------------------+
| |
v v
Prototypal Classical
|
+------------------------------+
| |
v v
Prototypal Pattern Constructor Pattern
जैसा कि आप देख सकते हैं कि प्रोटोटाइप विरासत और शास्त्रीय विरासत विरासत के दो अलग-अलग प्रतिमान हैं। सेल्फ, लुआ और जावास्क्रिप्ट जैसी कुछ भाषाएँ प्रोटोटाइप विरासत का समर्थन करती हैं। हालाँकि अधिकांश भाषाएँ जैसे C ++, Java और C # शास्त्रीय विरासत का समर्थन करती हैं।
ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग का एक त्वरित अवलोकन
दोनों प्रोटोटाइप विरासत और शास्त्रीय विरासत वस्तु उन्मुख प्रोग्रामिंग प्रतिमान हैं (यानी वे वस्तुओं से निपटते हैं)। वस्तुएं केवल अमूर्तताएं हैं जो एक वास्तविक विश्व इकाई के गुणों को कूटबद्ध करती हैं (अर्थात वे कार्यक्रम में वास्तविक शब्द चीजों का प्रतिनिधित्व करते हैं)। इसे अमूर्तन के रूप में जाना जाता है।
अमूर्तता: कंप्यूटर प्रोग्राम में वास्तविक दुनिया की चीजों का प्रतिनिधित्व।
सैद्धांतिक रूप से एक अमूर्तता को "विशिष्ट उदाहरणों से सामान्य विशेषताओं को निकालने के द्वारा गठित एक सामान्य अवधारणा" के रूप में परिभाषित किया गया है। हालांकि इस स्पष्टीकरण के लिए हम इसके बजाय उपरोक्त परिभाषा का उपयोग करने जा रहे हैं।
अब कुछ वस्तुओं में बहुत सी चीजें होती हैं। उदाहरण के लिए एक मिट्टी की बाइक और हार्ले डेविडसन में बहुत कुछ है।
एक मिट्टी बाइक:
एक हार्ले डेविडसन:
एक मिट्टी की बाइक और एक हार्ले डेविडसन दोनों बाइक हैं। इसलिए एक बाइक एक मिट्टी की बाइक और हार्ले डेविडसन दोनों का सामान्यीकरण है।
Bike
|
+---------------------------------+
| |
v v
Mud Bike Harley Davidson
उपरोक्त उदाहरण में बाइक, मिट्टी की बाइक और हार्ले डेविडसन सभी सार हैं। हालाँकि, बाइक मड बाइक और हार्ले डेविडसन (यानी कीचड़ बाइक और हार्ले डेविडसन दोनों विशिष्ट प्रकार की बाइक हैं) का अधिक सामान्य अमूर्त है।
सामान्यीकरण: एक अधिक विशिष्ट अमूर्तता का एक अमूर्तन।
ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में हम ऑब्जेक्ट्स बनाते हैं (जो वास्तविक विश्व संस्थाओं का सार हैं) और हम इन वस्तुओं के सामान्यीकरण बनाने के लिए या तो कक्षाओं या प्रोटोटाइप का उपयोग करते हैं। सामान्यीकरण विरासत के माध्यम से बनाया जाता है। एक बाइक एक कीचड़ बाइक का सामान्यीकरण है। इसलिए कीचड़ बाइक से विरासत में मिली है।
शास्त्रीय वस्तु-उन्मुख प्रोग्रामिंग
शास्त्रीय वस्तु-उन्मुख प्रोग्रामिंग में हमारे पास दो प्रकार के सार हैं: कक्षाएं और ऑब्जेक्ट। एक वस्तु, जैसा कि पहले उल्लेख किया गया है, एक वास्तविक विश्व इकाई का अमूर्त है। दूसरी ओर एक वर्ग एक वस्तु या अन्य वर्ग का सार है (यानी यह एक सामान्यीकरण है)। उदाहरण के लिए, विचार करें:
+----------------------+----------------+---------------------------------------+
| Level of Abstraction | Name of Entity | Comments |
+----------------------+----------------+---------------------------------------+
| 0 | John Doe | Real World Entity. |
| 1 | johnDoe | Variable holding object. |
| 2 | Man | Class of object johnDoe. |
| 3 | Human | Superclass of class Man. |
+----------------------+----------------+---------------------------------------+
जैसा कि आप शास्त्रीय वस्तु-उन्मुख प्रोग्रामिंग भाषाओं में देख सकते हैं कि वस्तुएं केवल अमूर्त हैं (अर्थात सभी वस्तुओं में एक एब्स्ट्रैक्शन स्तर 1 है) और कक्षाएं केवल सामान्यीकरण हैं (यानी सभी वर्गों में एब्सट्रैक्शन स्तर 1 से अधिक है)।
शास्त्रीय वस्तु-उन्मुख प्रोग्रामिंग भाषाओं में ऑब्जेक्ट केवल तात्कालिक कक्षाओं द्वारा बनाए जा सकते हैं:
class Human {
// ...
}
class Man extends Human {
// ...
}
Man johnDoe = new Man();
शास्त्रीय वस्तु-उन्मुख प्रोग्रामिंग भाषाओं में संक्षेप में वस्तुएं वास्तविक दुनिया की संस्थाओं का सार हैं और कक्षाएं सामान्यीकरण हैं (अर्थात या तो वस्तुओं या अन्य वर्गों का सार)।
इसलिए जैसे-जैसे अमूर्तता का स्तर बढ़ता है, वैसे-वैसे इकाइयाँ अधिक सामान्य होती जाती हैं और जैसे-जैसे अमूर्तता का स्तर घटता जाता है, वैसे-वैसे संस्थाएँ और अधिक विशिष्ट होती जाती हैं। इस अर्थ में अमूर्तता का स्तर अधिक विशिष्ट संस्थाओं से लेकर सामान्य संस्थाओं तक के पैमाने के अनुरूप है।
प्रोटोटाइप ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग
प्रोटोटाइप ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग लैंग्वेज क्लासिकल ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग लैंग्वेज की तुलना में बहुत सरल हैं क्योंकि प्रोटोटाइप ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में हमारे पास केवल एक प्रकार का एब्सट्रैक्शन (यानी ऑब्जेक्ट्स) होता है। उदाहरण के लिए, विचार करें:
+----------------------+----------------+---------------------------------------+
| Level of Abstraction | Name of Entity | Comments |
+----------------------+----------------+---------------------------------------+
| 0 | John Doe | Real World Entity. |
| 1 | johnDoe | Variable holding object. |
| 2 | man | Prototype of object johnDoe. |
| 3 | human | Prototype of object man. |
+----------------------+----------------+---------------------------------------+
जैसा कि आप प्रोटोटाइप ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग लैंग्वेज में देख सकते हैं कि ऑब्जेक्ट्स या तो वास्तविक विश्व संस्थाओं के सार हैं (जिस स्थिति में उन्हें बस ऑब्जेक्ट्स कहा जाता है) या अन्य ऑब्जेक्ट्स (जिस स्थिति में वे उन ऑब्जेक्ट्स के प्रोटोटाइप कहे जाते हैं जो वे अमूर्त होते हैं)। इसलिए एक प्रोटोटाइप एक सामान्यीकरण है।
प्रोटोटाइप ऑब्जेक्ट ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषाओं में ऑब्जेक्ट्स को पूर्व-निहिलो (यानी कुछ भी नहीं) या किसी अन्य ऑब्जेक्ट से बनाया जा सकता है (जो नए बनाए गए ऑब्जेक्ट का प्रोटोटाइप बन जाता है):
var human = {};
var man = Object.create(human);
var johnDoe = Object.create(man);
मेरी विनम्र राय में प्रोटोटाइप ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग लैंग्वेज शास्त्रीय ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषाओं की तुलना में अधिक शक्तिशाली हैं क्योंकि:
- केवल एक प्रकार का अमूर्तता है।
- सामान्यीकरण केवल वस्तुएं हैं।
अब तक आप शास्त्रीय विरासत और प्रोटोटाइप विरासत के बीच अंतर का एहसास कर चुके होंगे। शास्त्रीय विरासत अन्य वर्गों से विरासत में मिली कक्षाओं तक सीमित है। हालांकि प्रोटोटाइप विरासत में केवल अन्य प्रोटोटाइप से प्राप्त प्रोटोटाइप शामिल नहीं हैं, बल्कि प्रोटोटाइप से विरासत में मिली वस्तुएं भी हैं।
प्रोटोटाइप-क्लास Isomorphism
आपने देखा होगा कि प्रोटोटाइप और कक्षाएं बहुत समान हैं। यह सच है। वो हैं। वास्तव में वे इतने समान हैं कि आप वास्तव में प्रोटोटाइप का उपयोग मॉडल कक्षाओं में कर सकते हैं:
function CLASS(base, body) {
if (arguments.length < 2) body = base, base = Object.prototype;
var prototype = Object.create(base, {new: {value: create}});
return body.call(prototype, base), prototype;
function create() {
var self = Object.create(prototype);
return prototype.hasOwnProperty("constructor") &&
prototype.constructor.apply(self, arguments), self;
}
}
उपरोक्त CLASSफ़ंक्शन का उपयोग करके आप कक्षाओं की तरह दिखने वाले प्रोटोटाइप बना सकते हैं:
var Human = CLASS(function () {
var milliseconds = 1
, seconds = 1000 * milliseconds
, minutes = 60 * seconds
, hours = 60 * minutes
, days = 24 * hours
, years = 365.2425 * days;
this.constructor = function (name, sex, dob) {
this.name = name;
this.sex = sex;
this.dob = dob;
};
this.age = function () {
return Math.floor((new Date - this.dob) / years);
};
});
var Man = CLASS(Human, function (Human) {
this.constructor = function (name, dob) {
Human.constructor.call(this, name, "male", dob);
if (this.age() < 18) throw new Error(name + " is a boy, not a man!");
};
});
var johnDoe = Man.new("John Doe", new Date(1970, 0, 1));
हालांकि रिवर्स सच नहीं है (यानी आप कक्षाओं को मॉडल प्रोटोटाइप का उपयोग नहीं कर सकते हैं)। इसका कारण यह है कि प्रोटोटाइप ऑब्जेक्ट हैं लेकिन क्लास ऑब्जेक्ट नहीं हैं। वे एक पूरी तरह से अलग प्रकार के अमूर्त हैं।
निष्कर्ष
संक्षेप में हमने सीखा कि एक अमूर्तता "विशिष्ट उदाहरणों से सामान्य विशेषताओं को निकालने के द्वारा बनाई गई एक सामान्य अवधारणा है" और यह सामान्यीकरण "अधिक विशिष्ट अमूर्तता का अमूर्त" है । हमने प्रोटोटाइप और शास्त्रीय विरासत के बीच अंतर के बारे में भी सीखा और कैसे दोनों एक ही सिक्के के दो चेहरे हैं।
एक बिदाई नोट पर, मैं यह कहना चाहूंगा कि प्रोटोटाइप के दो प्रकार हैं वंशानुक्रम: प्रोटोटाइप पैटर्न और निर्माण पैटर्न। प्रोटोोटाइपल पैटर्न, प्रोटोटाइपल इनहेरिटेंस का विहित पैटर्न है, जबकि कंस्ट्रक्टर पैटर्न का उपयोग प्रोटोटाइप की विरासत को शास्त्रीय विरासत की तरह देखने के लिए किया जाता है। व्यक्तिगत रूप से मैं प्रोटोटाइप पैटर्न पसंद करता हूं।
PS मैं वह व्यक्ति हूं जिसने ब्लॉग पोस्ट " Why Prototypal Inheritance Matters " लिखी है और इस सवाल का जवाब दिया " शास्त्रीय पर प्रोटोटाइप विरासत के लाभ? "। मेरा उत्तर स्वीकृत उत्तर है।