दिलचस्प पोस्ट
जावास्क्रिप्ट में स्वयं निष्पादन समारोह का उद्देश्य क्या है? ASP.NET बटन पोस्टबैक के साथ jQuery UI संवाद AngularJs के साथ Jquery Datatable का उपयोग करना iPhone UITextField – प्लेसहोल्डर टेक्स्ट का रंग बदलें JTable नहीं दिखा रहा है कैसे करें: x86 में पाउ (असली, असली) मैं ScrollViewer को स्टैकपैनेल के अंदर कैसे काम कर सकता हूं? मैं Django / Python में एक पीडीएफ फॉर्म को कैसे स्वत: भरू सकता हूं? स्ट्रिंग बनाम स्ट्रिंगबिल्डर आईओएस में एक छवि का आकार बदलने के लिए कैसे? मैं SQL सर्वर के साथ कैस्केड हटाने का उपयोग कैसे करूं? अप्रमाणित स्ट्रिंग के सामान्य स्रोत कैसे नए आदेश को हटाने के लिए बास कमांड प्रतिस्थापन से बचें? एक से कई रिश्ते के साथ इकाई फ़्रेमवर्क ऑब्जेक्ट के सीरियललाइज़ेशन क्या मैं SQL सर्वर 2005 में मर्ज कथन का उपयोग कर सकता हूं?

कैसे जावास्क्रिप्ट में एक वर्ग से उत्तीर्ण करने के लिए?

PHP / Java में कोई भी कर सकता है:

class Sub extends Base { } 

और स्वचालित रूप से सुपर वर्ग के सभी सार्वजनिक / संरक्षित विधियों, गुणधर्म, क्षेत्र आदि उप वर्ग का एक हिस्सा बन जाते हैं जो आवश्यक होने पर ओवरराइड किया जा सकता है।

जावास्क्रिप्ट में उस के बराबर क्या है?

वेब के समाधान से एकत्रित समाधान "कैसे जावास्क्रिप्ट में एक वर्ग से उत्तीर्ण करने के लिए?"

मैंने यह कैसे बदल दिया है, अब मैं कन्स्ट्रक्टर फ़ंक्शंस और उनकी prototype प्रॉपर्टी का उपयोग करने से बचने की कोशिश करता हूं, लेकिन 2010 से मेरे पुराने उत्तर अभी भी नीचे हैं। अब मैं Object.create() पसंद करता Object.create() Object.create सभी आधुनिक ब्राउज़रों में उपलब्ध है।

मुझे ध्यान रखना चाहिए कि Object.create आम तौर पर फ़ंक्शन कन्स्ट्रक्टर के साथ new प्रयोग करने से बहुत धीमी है।

 //The prototype is just an object when you use `Object.create()` var Base = {}; //This is how you create an instance: var baseInstance = Object.create(Base); //If you want to inherit from "Base": var subInstance = Object.create(Object.create(Base)); //Detect if subInstance is an instance of Base: console.log(Base.isPrototypeOf(subInstance)); //True 

jsfiddle

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

 var Base = {}; function createBase() { return Object.create(Base, { doSomething: { value: function () { console.log("Doing something"); }, }, }); } var Sub = createBase(); function createSub() { return Object.create(Sub, { doSomethingElse: { value: function () { console.log("Doing something else"); }, }, }); } var subInstance = createSub(); subInstance.doSomething(); //Logs "Doing something" subInstance.doSomethingElse(); //Logs "Doing something else" console.log(Base.isPrototypeOf(subInstance)); //Logs "true" console.log(Sub.isPrototypeOf(subInstance)); //Logs "true 

jsfiddle

2010 से यह मेरा मूल जवाब है:

 function Base ( ) { this.color = "blue"; } function Sub ( ) { } Sub.prototype = new Base( ); Sub.prototype.showColor = function ( ) { console.log( this.color ); } var instance = new Sub ( ); instance.showColor( ); //"blue" 

जावास्क्रिप्ट में आपके पास वर्ग नहीं है, लेकिन आप कई तरह से विरासत और व्यवहार पुन: उपयोग प्राप्त कर सकते हैं:

छद्म-शास्त्रीय विरासत (प्रोटोटाइप के माध्यम से):

 function Super () { this.member1 = 'superMember1'; } Super.prototype.member2 = 'superMember2'; function Sub() { this.member3 = 'subMember3'; //... } Sub.prototype = new Super(); 

new ऑपरेटर के साथ उपयोग किया जाना चाहिए:

 var subInstance = new Sub(); 

फ़ंक्शन अनुप्रयोग या "कन्स्ट्रक्टर चेनिंग":

 function Super () { this.member1 = 'superMember1'; this.member2 = 'superMember2'; } function Sub() { Super.apply(this, arguments); this.member3 = 'subMember3'; } 

इस दृष्टिकोण का उपयोग new ऑपरेटर के साथ भी किया जाना चाहिए:

 var subInstance = new Sub(); 

पहला उदाहरण के साथ अंतर यह है कि जब हम Super ऑब्जेक्ट को Super ऑब्जेक्ट के अंदर Sub में लागू करते हैं, तो यह Super पर सीधे subInstance गुणों को जोड़ता है, सीधे नए इंस्टेंस पर, उदाहरण के लिए subInstance में member1 और member2 के गुण हैं (सब subInstance.hasOwnProperty('member1') == true; )

पहले उदाहरण में, उन गुणों को प्रोटोटाइप श्रृंखला के माध्यम से पहुंचाया जाता है, वे आंतरिक [[Prototype]] ऑब्जेक्ट पर मौजूद होते हैं।

परजीवी विरासत या पावर कन्स्ट्रक्टर्स:

 function createSuper() { var obj = { member1: 'superMember1', member2: 'superMember2' }; return obj; } function createSub() { var obj = createSuper(); obj.member3 = 'subMember3'; return obj; } 

यह दृष्टिकोण मूल रूप से "वस्तु वृद्धि" पर आधारित है, आपको new ऑपरेटर का उपयोग करने की आवश्यकता नहीं है, और जैसा कि आप देख सकते हैं, this कीवर्ड शामिल नहीं है।

 var subInstance = createSub(); 

ईसीमास्क्रिप्ट 5 वीं एड Object.create विधि:

 // Check if native implementation available if (typeof Object.create !== 'function') { Object.create = function (o) { function F() {} // empty constructor F.prototype = o; // set base object as prototype return new F(); // return empty object with right [[Prototype]] }; } var superInstance = { member1: 'superMember1', member2: 'superMember2' }; var subInstance = Object.create(superInstance); subInstance.member3 = 'subMember3'; 

उपरोक्त विधि क्रॉकफोर्ड द्वारा प्रस्तावित एक प्रोटोटाइप विरासत तकनीक है।

ऑब्जेक्ट उदाहरण अन्य ऑब्जेक्ट इंस्टेंसेस से प्राप्त होते हैं, ऐसा ही है।

यह तकनीक सरल "वस्तु वृद्धि" से बेहतर हो सकती है क्योंकि उत्तरार्द्ध गुण सभी नए ऑब्जेक्ट उदाहरणों पर प्रतिलिपि नहीं किए जाते हैं, चूंकि आधार ऑब्जेक्ट को विस्तारित ऑब्जेक्ट के [[Prototype]] के रूप में सेट किया गया है, उपर्युक्त उदाहरण subInstance में शारीरिक रूप से केवल member3 संपत्ति

उन लोगों के लिए जो इस पेज को 2015 या बाद में पहुंचते हैं

ईसीएमएस्क्रिप्ट मानक ( ईएस 6 ) के नवीनतम संस्करण के साथ, आप डे कीवर्क का extends कर सकते हैं

ध्यान दें कि कक्षा की परिभाषा एक नियमित object नहीं है, इसलिए वर्ग के सदस्यों के बीच कोई अल्पविराम नहीं है। एक क्लास का उदाहरण बनाने के लिए, आपको new कीवर्ड का उपयोग करना चाहिए। बेस क्लास से उत्तीर्ण करने के लिए, extends उपयोग करें:

 class Vehicle { constructor(name) { this.name = name; this.kind = 'vehicle'; } getName() { return this.name; } } // Create an instance var myVehicle = new Vehicle('rocky'); myVehicle.getName(); // => 'rocky' 

बेस क्लास से उत्तीर्ण करने के लिए, extends उपयोग करें:

 class Car extends Vehicle { constructor(name) { super(name); this.kind = 'car' } } var myCar = new Car('bumpy'); myCar.getName(); // => 'bumpy' myCar instanceof Car; // => true myCar instanceof Vehicle; // => true 

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

  • पैरेंट कन्स्ट्रक्टर को कॉल करने के लिए, super(). उपयोग करें
  • किसी अन्य सदस्य को कॉल करने के लिए, उदाहरण के लिए, super.getName()

वर्गों का उपयोग करने के लिए और भी बहुत कुछ है यदि आप इस विषय में गहराई से जाना चाहते हैं, तो मैं डॉ एक्सेल रौशमेयर द्वारा " ECMAScript 6 में कक्षाएं " की सलाह देता हूं। *

स्रोत

ठीक है, जावास्क्रिप्ट में "वर्ग विरासत" नहीं है, बस "प्रोटोटाइप इनहेरिटेंस" है तो आप एक क्लास "ट्रक" नहीं बनाते हैं और फिर इसे "ऑटोमोबाइल" के उप-वर्ग के रूप में चिह्नित करते हैं। इसके बजाय, आप एक वस्तु "जैक" बनाते हैं और कहते हैं कि यह एक प्रोटोटाइप के रूप में "जॉन" का उपयोग करता है। अगर जॉन जानता है, कितना "4 + 4" है, तो जैक इसे भी जानता है, भी।

मेरा सुझाव है कि आप डगलस क्रॉकफोर्ड के लेख को प्रोटोटाइप उत्तराधिकार के बारे में पढ़ते हैं: http://javascript.crockford.com/prototypal.html वह यह भी दिखाता है कि आप जावास्क्रिप्ट को अन्य ओओ भाषाओं के रूप में "एक जैसे" उत्तराधिकार कैसे बना सकते हैं और फिर बताते हैं कि यह वास्तव में जावास्क्रिप्ट को एक तरह से तोड़ने का अर्थ है, जिसका उपयोग इसका मतलब नहीं था।

मुझे इस उद्धरण को सबसे अधिक ज्ञान प्राप्त करने वाला लगता है:

संक्षेप में, एक जावास्क्रिप्ट "वर्ग" सिर्फ एक फ़ंक्शन ऑब्जेक्ट है जो कन्स्ट्रक्टर के साथ-साथ एक संलग्न प्रोटोटाइप ऑब्जेक्ट भी है। ( स्रोत: गुरु काटज़ )

मुझे ऑब्जेक्ट्स के बजाय कन्स्ट्रक्टर का उपयोग करना पसंद है, इसलिए मैं सीएमएस द्वारा वर्णित "छद्म शास्त्रीय विरासत" विधि का आंशिक हूं। यहां प्रोटोटाइप श्रृंखला के साथ कई विरासत का एक उदाहरण है:

 // Lifeform "Class" (Constructor function, No prototype) function Lifeform () { this.isLifeform = true; } // Animal "Class" (Constructor function + prototype for inheritance) function Animal () { this.isAnimal = true; } Animal.prototype = new Lifeform(); // Mammal "Class" (Constructor function + prototype for inheritance) function Mammal () { this.isMammal = true; } Mammal.prototype = new Animal(); // Cat "Class" (Constructor function + prototype for inheritance) function Cat (species) { this.isCat = true; this.species = species } Cat.prototype = new Mammal(); // Make an instance object of the Cat "Class" var tiger = new Cat("tiger"); console.log(tiger); // The console outputs a Cat object with all the properties from all "classes" console.log(tiger.isCat, tiger.isMammal, tiger.isAnimal, tiger.isLifeform); // Outputs: true true true true // You can see that all of these "is" properties are available in this object // We can check to see which properties are really part of the instance object console.log( "tiger hasOwnProperty: " ,tiger.hasOwnProperty("isLifeform") // false ,tiger.hasOwnProperty("isAnimal") // false ,tiger.hasOwnProperty("isMammal") // false ,tiger.hasOwnProperty("isCat") // true ); // New properties can be added to the prototypes of any // of the "classes" above and they will be usable by the instance Lifeform.prototype.A = 1; Animal.prototype.B = 2; Mammal.prototype.C = 3; Cat.prototype.D = 4; console.log(tiger.A, tiger.B, tiger.C, tiger.D); // Console outputs: 1 2 3 4 // Look at the instance object again console.log(tiger); // You'll see it now has the "D" property // The others are accessible but not visible (console issue?) // In the Chrome console you should be able to drill down the __proto__ chain // You can also look down the proto chain with Object.getPrototypeOf // (Equivalent to tiger.__proto__) console.log( Object.getPrototypeOf(tiger) ); // Mammal console.log( Object.getPrototypeOf(Object.getPrototypeOf(tiger)) ); // Animal // Etc. to get to Lifeform 

यहां एमडीएन से एक और अच्छा संसाधन है , और यहां एक जेएसफ़ील्ड है ताकि आप इसे बाहर की कोशिश कर सकें ।

जावास्क्रिप्ट इनहेरिटेंस जावा और पीएचपी से थोड़ा अलग है, क्योंकि इसमें क्लासेस नहीं हैं। इसके बजाय इसके प्रोटोटाइप ऑब्जेक्ट हैं जो तरीके और सदस्य चर प्रदान करते हैं। आप उन प्रोटोटाइप को वस्तु विरासत प्रदान करने के लिए चेन कर सकते हैं। इस प्रश्न पर शोध करते समय मैंने पाया सबसे आम पैटर्न मोज़िला डेवलपर नेटवर्क पर वर्णित है। मैंने उनके उदाहरण को अपडेट किया है ताकि सुपरक्लास विधि को कॉल शामिल किया जा सके और एक अलर्ट संदेश में प्रवेश दिखाया जा सके।

 // Shape - superclass function Shape() { this.x = 0; this.y = 0; } // superclass method Shape.prototype.move = function(x, y) { this.x += x; this.y += y; log += 'Shape moved.\n'; }; // Rectangle - subclass function Rectangle() { Shape.call(this); // call super constructor. } // subclass extends superclass Rectangle.prototype = Object.create(Shape.prototype); Rectangle.prototype.constructor = Rectangle; // Override method Rectangle.prototype.move = function(x, y) { Shape.prototype.move.call(this, x, y); // call superclass method log += 'Rectangle moved.\n'; } var log = ""; var rect = new Rectangle(); log += ('Is rect an instance of Rectangle? ' + (rect instanceof Rectangle) + '\n'); // true log += ('Is rect an instance of Shape? ' + (rect instanceof Shape) + '\n'); // true rect.move(1, 1); // Outputs, 'Shape moved.' alert(log); 

आप (शास्त्रीय अर्थ में) नहीं कर सकते जावास्क्रिप्ट एक प्रोटोटाइपिकल भाषा है आप देखेंगे कि आप जावास्क्रिप्ट में कभी भी "वर्ग" नहीं घोषित करते हैं; आप केवल राज्य और एक वस्तु के तरीकों को परिभाषित करते हैं। विरासत का निर्माण करने के लिए, आप कुछ वस्तु लेते हैं और प्रोटोटाइप करते हैं। प्रोटोटाइप को नई कार्यक्षमता के साथ बढ़ाया गया है।

आप उपयोग कर सकते हैं .inheritWith और .fastClass लाइब्रेरी यह सबसे लोकप्रिय पुस्तकालयों की तुलना में तेज़ है और कभी-कभी मूल संस्करण की तुलना में भी तेज़ है।

उपयोग करने के लिए बहुत आसान है:

 function Super() { this.member1 = "superMember";//instance member }.define({ //define methods on Super's prototype method1: function() { console.log('super'); } //prototype member }.defineStatic({ //define static methods directly on Super function staticMethod1: function() { console.log('static method on Super'); } }); var Sub = Super.inheritWith(function(base, baseCtor) { return { constructor: function() {//the Sub constructor that will be returned to variable Sub this.member3 = 'subMember3'; //instance member on Sub baseCtor.apply(this, arguments);//call base construcor and passing all incoming arguments }, method1: function() { console.log('sub'); base.method1.apply(this, arguments); //call the base class' method1 function } } 

प्रयोग

 var s = new Sub(); s.method1(); //prints: //sub //super 

कई पदों को पढ़ने के बाद, मैं इस समाधान ( jsfiddle यहाँ ) के साथ आया था। ज्यादातर समय में मुझे और अधिक परिष्कृत की ज़रूरत नहीं है

 var Class = function(definition) { var base = definition.extend || null; var construct = definition.construct || definition.extend || function() {}; var newClass = function() { this._base_ = base; construct.apply(this, arguments); } if (definition.name) newClass._name_ = definition.name; if (definition.extend) { var f = function() {} f.prototype = definition.extend.prototype; newClass.prototype = new f(); newClass.prototype.constructor = newClass; newClass._extend_ = definition.extend; newClass._base_ = definition.extend.prototype; } if (definition.statics) for (var n in definition.statics) newClass[n] = definition.statics[n]; if (definition.members) for (var n in definition.members) newClass.prototype[n] = definition.members[n]; return newClass; } var Animal = Class({ construct: function() { }, members: { speak: function() { console.log("nuf said"); }, isA: function() { return "animal"; } } }); var Dog = Class({ extend: Animal, construct: function(name) { this._base_(); this.name = name; }, statics: { Home: "House", Food: "Meat", Speak: "Barks" }, members: { name: "", speak: function() { console.log( "ouaf !"); }, isA: function(advice) { return advice + " dog -> " + Dog._base_.isA.call(this); } } }); var Yorkshire = Class({ extend: Dog, construct: function(name,gender) { this._base_(name); this.gender = gender; }, members: { speak: function() { console.log( "ouin !"); }, isA: function(advice) { return "yorkshire -> " + Yorkshire._base_.isA.call(this,advice); } } }); var Bulldog = function() { return _class_ = Class({ extend: Dog, construct: function(name) { this._base_(name); }, members: { speak: function() { console.log( "OUAF !"); }, isA: function(advice) { return "bulldog -> " + _class_._base_.isA.call(this,advice); } } })}(); var animal = new Animal("Maciste"); console.log(animal.isA()); animal.speak(); var dog = new Dog("Sultan"); console.log(dog.isA("good")); dog.speak(); var yorkshire = new Yorkshire("Golgoth","Male"); console.log(yorkshire.isA("bad")); yorkshire.speak(); var bulldog = new Bulldog("Mike"); console.log(bulldog.isA("nice")); bulldog.speak(); 

सीएमएस के उत्तर के लिए धन्यवाद और प्रोटोटाइप और ऑब्जेक्ट के साथ थोड़ी देर के लिए नगण्य के बाद। बनाएं और क्या नहीं, मैं अपने विरासत के लिए एक साफ हल से यहां पर दिखाए गए आवेदन के साथ आने में सक्षम था:

 var myNamespace = myNamespace || (function() { return { BaseClass: function(){ this.someBaseProperty = "someBaseProperty"; this.someProperty = "BaseClass"; this.someFunc = null; }, DerivedClass:function(someFunc){ myNamespace.BaseClass.apply(this, arguments); this.someFunc = someFunc; this.someProperty = "DerivedClass"; }, MoreDerivedClass:function(someFunc){ myNamespace.DerivedClass.apply(this, arguments); this.someFunc = someFunc; this.someProperty = "MoreDerivedClass"; } }; })(); 

जावास्क्रिप्ट में कोई वर्ग नहीं है, क्योंकि आप जावास्क्रिप्ट में एक वर्ग से वारिस नहीं कर सकते।

 function Person(attr){ this.name = (attr && attr.name)? attr.name : undefined; this.birthYear = (attr && attr.birthYear)? attr.birthYear : undefined; this.printName = function(){ console.log(this.name); } this.printBirthYear = function(){ console.log(this.birthYear); } this.print = function(){ console.log(this.name + '(' +this.birthYear+ ')'); } } function PersonExt(attr){ Person.call(this, attr); this.print = function(){ console.log(this.name+ '-' + this.birthYear); } this.newPrint = function(){ console.log('New method'); } } PersonExt.prototype = new Person(); // Init object and call methods var p = new Person({name: 'Mr. A', birthYear: 2007}); // Parent method p.print() // Mr. A(2007) p.printName() // Mr. A var pExt = new PersonExt({name: 'Mr. A', birthYear: 2007}); // Overwriten method pExt.print() // Mr. A-2007 // Extended method pExt.newPrint() // New method // Parent method pExt.printName() // Mr. A 

ES2015 से, यह ठीक है कि आप JavaScript में विरासत कैसे करते हैं

 class Sub extends Base { } 
  1. https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Classes
  2. http://exploringjs.com/es6/ch_classes.html
 function Base() { this.doSomething = function () { } } function Sub() { Base.call(this); } var sub = new Sub(); sub.doSomething();