জাভাস্ক্রিপ্টে কোনও শ্রেণি থেকে উত্তরাধিকারী কীভাবে?

Question 1

পিএইচপি / জাভাতে যে কেউ এটি করতে পারেন:

class Sub extends Base
{
}

এবং স্বয়ংক্রিয়ভাবে সুপার বর্গের সমস্ত পাবলিক / সুরক্ষিত পদ্ধতি, বৈশিষ্ট্য, ক্ষেত্রগুলি ইত্যাদি সাব ক্লাসের একটি অংশ হয়ে যায় যা প্রয়োজনে ওভাররাইড করা যায়।

জাভাস্ক্রিপ্টে এর সমতুল্য কি?

Question 2

আমি এখন এটি কীভাবে করব তা পরিবর্তন করেছি, আমি কনস্ট্রাক্টর ফাংশন এবং তাদের prototypeসম্পত্তি ব্যবহার এড়াতে চেষ্টা করি , তবে ২০১০ সালের আমার পুরানো উত্তরটি এখনও নীচে রয়েছে। আমি এখন পছন্দ 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"

Question 3

জাভাস্ক্রিপ্টে আপনার ক্লাস নেই তবে আপনি উত্তরাধিকার এবং আচরণের পুনরায় ব্যবহার বিভিন্ন উপায়ে পেতে পারেন:

সিউডো-শাস্ত্রীয় উত্তরাধিকার (প্রোটোটাইপিংয়ের মাধ্যমে):

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();

প্রথম উদাহরণ সঙ্গে পার্থক্য যে, যখন আমরা হয় করতে কন্সট্রাকটর অবজেক্টের অভ্যন্তরে , এটা নির্ধারিত বৈশিষ্ট্য যোগ করা উপর সরাসরি নতুন দৃষ্টান্ত উপর, যেমন বৈশিষ্ট্য উপস্থিত রয়েছে এবং সরাসরি ( )।applySuperthisSubthisSupersubInstancemember1member2subInstance.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();

ECMAScript 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';

উপরের পদ্ধতিটি ক্রকফোর্ড দ্বারা প্রস্তাবিত একটি নমুনা উত্তরাধিকার কৌশল ।

বস্তুর দৃষ্টান্তগুলি অন্য অবজেক্টের উদাহরণ থেকে উত্তরাধিকারী হয়, এটি that's

এই কৌশলটি সহজ "বস্তু বৃদ্ধি" চেয়ে ভাল হতে পারে না, কারণ উত্তরাধিকারসূত্রে বৈশিষ্ট্য সর্বাঙ্গে নতুন অবজেক্ট দৃষ্টান্ত, যেহেতু অনুলিপি করা হয়নি বেস অবজেক্ট হিসেবে সেট করা হয় [[Prototype]]এর বর্ধিত বস্তু, মধ্যে উপরের উদাহরণে subInstanceশারীরিকভাবে শুধুমাত্র রয়েছে member3সম্পত্তি।

Question 4

যারা 2019 বা তার পরে এই পৃষ্ঠায় পৌঁছেছেন তাদের জন্য

ECMAScript স্ট্যান্ডার্ড (ES6) এর সর্বশেষতম সংস্করণ সহ , আপনি কীওয়ার্ডটি ব্যবহার করতে পারেন class।

লক্ষ করুন যে শ্রেণি সংজ্ঞাটি নিয়মিত নয় 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 এ ক্লাস " করার পরামর্শ দিচ্ছি *

সূত্র

Question 5

ঠিক আছে, জাভাস্ক্রিপ্টে কোনও "শ্রেণীর উত্তরাধিকার" নেই, কেবল "প্রোটোটাইপ উত্তরাধিকার" রয়েছে। সুতরাং আপনি একটি ক্লাস "ট্রাক" তৈরি করবেন না এবং তারপরে এটিকে "অটোমোবাইল" এর সাবক্লাস হিসাবে চিহ্নিত করুন। পরিবর্তে, আপনি একটি বস্তু "জ্যাক" তৈরি করুন এবং বলবেন যে এটি "জন" কে প্রোটোটাইপ হিসাবে ব্যবহার করে। জন যদি জানেন, "4 + 4" কত, তবে জ্যাক এটিও জানেন।

আমি আপনাকে প্রোটোটাইপাল উত্তরাধিকার সম্পর্কে ডগলাস ক্রকফোর্ডের নিবন্ধটি এখানে পড়ার পরামর্শ দিচ্ছি: http://javascript.crockford.com/prototypal.html তিনি আরও দেখান যে কীভাবে আপনি জাভাস্ক্রিপ্টকে অন্যান্য ওও ভাষার মতো "চেহারার মতো" উত্তরাধিকারী করে তুলতে পারেন এবং তারপরে ব্যাখ্যা করেছেন যে এটি আসলে জাভা স্ক্রিপ্টটি এমনভাবে ভাঙ্গার অর্থ এটি ব্যবহার করা হয়নি।

Question 6

আমি এই উদ্ধৃতিটিকে সবচেয়ে আলোকিত বলে মনে করি:

সংক্ষেপে, একটি জাভাস্ক্রিপ্ট "ক্লাস" কেবল একটি ফাংশন অবজেক্ট যা কনস্ট্রাক্টর প্লাস একটি সংযুক্ত প্রোটোটাইপ অবজেক্ট হিসাবে কাজ করে। ( সূত্র: গুরু কাটজ )

আমি অবজেক্টগুলির চেয়ে কনস্ট্রাক্টর ব্যবহার করতে পছন্দ করি, তাই আমি এখানে সিএমএস দ্বারা বর্ণিত "ছদ্ম-ধ্রুপদী উত্তরাধিকার" পদ্ধতির আংশিক । প্রোটোটাইপ চেইন সহ একাধিক উত্তরাধিকারের উদাহরণ এখানে :

// 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

এখানে MDN থেকে অন্য একটি ভাল উত্স , এবং এখানে একটি jsfiddle যাতে আপনি এটি চেষ্টা করে দেখতে পারেন ।

Question 7

জাভাস্ক্রিপ্টের উত্তরাধিকারটি জাভা এবং পিএইচপি থেকে কিছুটা আলাদা, কারণ এর আসলে ক্লাস নেই। পরিবর্তে এটিতে প্রোটোটাইপ অবজেক্ট রয়েছে যা পদ্ধতি এবং সদস্য ভেরিয়েবলগুলি সরবরাহ করে। অবজেক্টের উত্তরাধিকার প্রদানের জন্য আপনি সেই প্রোটোটাইপগুলি চেইন করতে পারেন। এই প্রশ্নটি গবেষণা করার সময় আমি সবচেয়ে সাধারণ প্যাটার্নটি মজিলা বিকাশকারী নেটওয়ার্কে বর্ণিত । একটি সুপারক্লাস পদ্ধতিতে একটি কল অন্তর্ভুক্ত করতে এবং একটি সতর্কতা বার্তায় লগটি দেখানোর জন্য আমি তাদের উদাহরণ আপডেট করেছি:

// 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);

স্নিপেট প্রসারিত করুন

ব্যক্তিগতভাবে, আমি জাভাস্ক্রিপ্টে উত্তরাধিকারটি বিশ্রীভাবে খুঁজে পাই, তবে এটি আমি খুঁজে পেয়েছি সেরা সংস্করণ।

Question 8

আপনি পারবেন না (শাস্ত্রীয় অর্থে)। জাভাস্ক্রিপ্ট একটি মূল ভাষা। আপনি লক্ষ্য করবেন যে আপনি জাভাস্ক্রিপ্টে কখনই "শ্রেণি" ঘোষণা করেন না; আপনি কেবল কোনও বস্তুর অবস্থা এবং পদ্ধতিগুলি সংজ্ঞায়িত করেন। উত্তরাধিকার উত্পাদনের জন্য, আপনি কিছু অবজেক্ট নেন এবং এটি প্রোটোটাইপ করেন। প্রোটোটাইপটি নতুন কার্যকারিতা সহ প্রসারিত।

Question 9

আপনি ব্যবহার .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

Question 10

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

Question 11

অনেকগুলি পোস্ট পড়ার পরে আমি এই সমাধানটি নিয়ে এসেছি ( এখানে 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();

Question 12

সিএমএসের উত্তরের জন্য এবং প্রোটোটাইপ এবং অবজেক্ট.ক্রিয়েট দিয়ে কিছুক্ষণ বিস্ফোরক হওয়ার পরে এবং কী না, আমি এখানে প্রয়োগ হিসাবে প্রয়োগ করে আমার উত্তরাধিকারের জন্য একটি ঝরঝরে সমাধান করতে সক্ষম হয়েছি:

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";
        }
    };
})();

Question 13

ES2015 থেকে আপনি ঠিক জাভাস্ক্রিপ্টে উত্তরাধিকার করেন

class Sub extends Base {

}

Question 14

function Base() {
    this.doSomething = function () {
    }
}

function Sub() {
    Base.call(this); // inherit Base's method(s) to this instance of Sub
}

var sub = new Sub();
sub.doSomething();

Question 15

ES6 ক্লাস:

জাভাস্ক্রিপ্টের ক্লাস নেই। জাভাস্ক্রিপ্টের ক্লাসগুলি প্রোটোটাইপাল উত্তরাধিকারের প্যাটার্নের উপরে জাভা স্ক্রিপ্টের উপরে কেবল সিনট্যাক্টিকাল চিনি বিল্ড । classপ্রোটোটাইপাল উত্তরাধিকার প্রয়োগের জন্য আপনি জেএস ব্যবহার করতে পারেন তবে এটি উপলব্ধি করা গুরুত্বপূর্ণ যে আপনি প্রকৃতপক্ষে এখনও হুডের নীচে কনস্ট্রাক্টর ফাংশন ব্যবহার করছেন।

আপনি es6বর্ধিত কীওয়ার্ড ব্যবহার করে কোনও 'শ্রেণি' থেকে প্রসারিত করার সময় এই ধারণাগুলিও প্রয়োগ হয় । এটি কেবল প্রোটোটাইপ চেইনে একটি অতিরিক্ত লিঙ্ক তৈরি করে। দ্য__proto__

উদাহরণ:

class Animal {
  makeSound () {
    console.log('animalSound');
  }
}

class Dog extends Animal {
   makeSound () {
    console.log('Woof');
  }
}


console.log(typeof Dog)  // classes in JS are just constructor functions under the hood

const dog = new Dog();

console.log(dog.__proto__ === Dog.prototype);   
// First link in the prototype chain is Dog.prototype

console.log(dog.__proto__.__proto__ === Animal.prototype);  
// Second link in the prototype chain is Animal.prototype
// The extends keyword places Animal in the prototype chain
// Now Dog 'inherits' the makeSound property from Animal

স্নিপেট প্রসারিত করুন

অবজেক্ট.ক্রিয়েট ()

Object.create()জাভাস্ক্রিপ্টে জেএসে উত্তরাধিকার তৈরি করারও একটি উপায়। Object.create()একটি ফাংশন যা একটি নতুন অবজেক্ট তৈরি করে, একটি বিদ্যমান বস্তুকে আর্গুমেন্ট হিসাবে গ্রহণ করে। এটি সেই বস্তুকে বরাদ্দ করবে যা __proto__সদ্য নির্মিত বস্তুর সম্পত্তির আর্গুমেন্ট হিসাবে প্রাপ্ত হয়েছিল । আবার এটি উপলব্ধি করা জরুরী যে আমরা জেএস মূর্তিযুক্ত প্রোটোটাইপাল উত্তরাধিকারের দৃষ্টিতে আবদ্ধ।

উদাহরণ:

const Dog = {
  fluffy: true,
  bark: () => {
      console.log('woof im a relatively cute dog or something else??');
  }
};

const dog = Object.create(Dog);

dog.bark();

স্নিপেট প্রসারিত করুন

Question 16

আপনি জাভাস্ক্রিপ্টের কোনও শ্রেণি থেকে উত্তরাধিকারী হতে পারবেন না, কারণ জাভাস্ক্রিপ্টে কোনও ক্লাস নেই।