რა არის პროტოტიპული მემკვიდრეობა JavaScript-ში?

JavaScript ობიექტები მემკვიდრეობით იღებენ თვისებებს და მეთოდებს თავიანთი პროტოტიპებიდან. თითოეული ობიექტის პროტოტიპი სხვა ობიექტია, რომლის თვისებები და მეთოდები ხელმისაწვდომია პროტოტიპების ჯაჭვის მეშვეობით.

როდესაც მივმართავთ ობიექტის თვისებას, JavaScript პირველ რიგში ეძებს მას პირდაპირ ობიექტში. თუ ვერ პოულობს, ძიება გაგრძელდება ამ ობიექტის პროტოტიპში, შემდეგ პროტოტიპის პროტოტიპში და ასე შემდეგ, სანამ თვისება არ მოიძებნება ან ჯაჭვის ბოლო (null) არ მიაღწევს.

პროტოტიპული მემკვიდრეობა განსხვავდება კლასიკური მემკვიდრეობისგან (როგორიცაა Java ან C++), სადაც ობიექტები შექმნილია მათი სტრუქტურის და ქცევის აღწერით კლასებიდან. JavaScript-ში, სადაც ES6-ში გამოჩნდა კლასები, ისინი პროტოტიპული მემკვიდრეობის სინტაქსური შაქარია.

ძირითადი ასპექტები:

• __proto__: ობიექტის შიდა თვისება, რომელიც მიუთითებს მის პროტოტიპზე.
• prototype: კონსტრუქტორის (ფუნქცია, რომელიც გამოიყენება როგორც კონსტრუქტორი) თვისება, რომელიც მიუთითებს ობიექტზე, რომელიც იქნება შექმნილი ნიმუშებისთვის პროტოტიპად.
• Object.getPrototypeOf(obj): სტანდარტული გზა ობიექტის პროტოტიპის მისაღებად.
• Object.setPrototypeOf(obj, proto): სტანდარტული გზა ობიექტის პროტოტიპის განსაზღვრად.

მაგალითი:

// კონსტრუქტორული ფუნქცია
function Animal(name) {
  this.name = name;
}

// მეთოდის დამატება Animal-ის პროტოტიპზე
Animal.prototype.sayHello = function() {
  console.log(`Hello, my name is ${this.name}`);
};

// ნიმუშის შექმნა
const dog = new Animal("Buddy");

// პროტოტიპიდან მეთოდის გამოძახება
dog.sayHello(); // შედეგი: Hello, my name is Buddy

// dog-ის პროტოტიპი არის Animal.prototype
console.log(Object.getPrototypeOf(dog) === Animal.prototype); // შედეგი: true

// Animal.prototype-ის პროტოტიპი არის Object.prototype
console.log(Object.getPrototypeOf(Animal.prototype) === Object.prototype); // შედეგი: true

// პროტოტიპების ჯაჭვის ბოლო არის null
console.log(Object.getPrototypeOf(Object.prototype) === null); // შედეგი: true

შედარება კლასიკური მემკვიდრეობასთან (ES6 კლასების გამოყენებით):

class Animal {
  constructor(name) {
    this.name = name;
  }

  sayHello() {
    console.log(`Hello, my name is ${this.name}`);
  }
}

class Dog extends Animal {
  constructor(name, breed) {
    super(name); // მშობლის კლასის კონსტრუქტორის გამოძახება
    this.breed = breed;
  }

  bark() {
    console.log("Woof!");
  }
}

const buddy = new Dog("Buddy", "Golden Retriever");
buddy.sayHello(); // შედეგი: Hello, my name is Buddy (მემკვიდრეობით Animal-დან)
buddy.bark(); // შედეგი: Woof! (Dog-ის მეთოდი)

// ES6 კლასები შაქრია პროტოტიპებზე
console.log(Object.getPrototypeOf(Dog) === Animal); // შედეგი: true (კლასების მემკვიდრეობა)
console.log(Object.getPrototypeOf(Dog.prototype) === Animal.prototype); // შედეგი: true (მეთოდების მემკვიდრეობა პროტოტიპებით)
console.log(Object.getPrototypeOf(buddy) === Dog.prototype); // შედეგი: true (ინსტანცია მემკვიდრეობს კლასის პროტოტიპიდან)

პროტოტიპული მემკვიდრეობა JavaScript-ის ძირითადი კონცეფციაა, რომლის გაგება აუცილებელია ენის ეფექტური მუშაობისთვის.