Ներկայացրեք, թե ինչպես է աշխատում ժառանգությունը JavaScript-ում։

JavaScript- ում ժառանգությունը հիմնված է պրոտոտիպների վրա: Ամեն օբյեկտ ունի ներքին հատկություն [[Prototype]] (մասին հասանելի է __proto__ կամ Object.getPrototypeOf()), որը ցույց է տալիս մյուս օբյեկտին:

Երբ փորձում ենք մուտք գործել օբյեկտի հատկություն կամ մեթոդ, եթե այն անմիջապես չի գտնվել օբյեկտում, JavaScript- ը որոնում է այն [[Prototype]]-ում, ապա [[Prototype]]-ում պրոտոտիպի և այդպես շարունակ պրոտոտիպների շղթայում, մինչև հասնի վերջակետին (Object.prototype), որի [[Prototype]]-ը null է:

Սա պրոտոտիպային ժառանգություն է:

ECMAScript 2015 (ES6) դասերը սինտակսիկ շաքար են պրոտոտիպային ժառանգության վրա: Դրանք ապահովում են ավելի հարմար սինտակսիս պրոտոտիպների հետ աշխատելու և օբյեկտների հիերարխիաներ ստեղծելու համար:

Նմուշ ES6-ից առաջ պրոտոտիպային ժառանգության օգտագործման:

// Ծնող կոնստրուկտոր
function Animal(name) {
  this.name = name;
}

// Ծնողի մեթոդը պրոտոտիպում
Animal.prototype.sayHi = function() {
  console.log(`Բարև, ես ${this.name}`);
};

// Որդու կոնստրուկտոր
function Dog(name, breed) {
  // Կոչ ենք անում ծնողի կոնստրուկտորը
  Animal.call(this, name);
  this.breed = breed;
}

// Որդու պրոտոտիպը սահմանում ենք որպես ծնողի պրոտոտիպի օրինակ
Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;

// Որդու մեթոդ
Dog.prototype.bark = function() {
  console.log("Հա-հա!");
};

// Օրինակ ստեղծում
const myDog = new Dog("Բոբի", "Լաբրադոր");

// Օգտագործում ենք ծնողի և որդու մեթոդները
myDog.sayHi(); // Դուրս է գրվում: Բարև, ես Բոբի
myDog.bark();  // Դուրս է գրվում: Հա-հա!

ES6 դասերի օրինակ:

// Ծնող դաս
class Animal {
  constructor(name) {
    this.name = name;
  }

  sayHi() {
    console.log(`Բարև, ես ${this.name}`);
  }
}

// Որդի դաս, որը ժառանգում է Animal-ից
class Dog extends Animal {
  constructor(name, breed) {
    super(name); // ծնողի կոնստրուկտորին կանչում ենք
    this.breed = breed;
  }

  bark() {
    console.log("Հա-հա!");
  }
}

// Օրինակ ստեղծում
const myDog = new Dog("Ռեքս", "Գերմանական շպից")

// Օգտագործում ենք ծնողի և որդու մեթոդները
myDog.sayHi(); // Դուրս է գրվում: Բարև, ես Ռեքս
myDog.bark();  // Դուրս է գրվում: Հա-հա!

JavaScript ժառանգության հիմնական կետերը՝

• Պրոտոտիպներ: Ամեն օբյեկտ ունի պրոտոտիպ:
• Պրոտոտիպ շղթա: Երբ որոնում ենք հատկություն կամ մեթոդ, որոնում ենք վերև շղթայում:
• [[Prototype]]: ներքին հատկություն, որը ցույց է տալիս պրոտոտիպին:
• __proto__: հին, բայց հաճախ օգտագործվող միջոց՝ հասնելու [[Prototype]]-ին:
• Object.getPrototypeOf(): առաջարկվող միջոց՝ հասնելու [[Prototype]]-ին:
• Կոնստրուկտորներ և prototype: ES6-ից առաջ օգտագործվում էին օբյեկտներ ստեղծելու և նրանց պրոտոտիպերը սահմանելու համար:
• Դասեր (ES6): սինտակսիկ շաքար՝ պրոտոտիպային ժառանգության համար, օգտագործելով class, extends, super բառերը: