Зачем нужно прототипное наследование?

Зачем нужно прототипное наследование

Прототипное наследование — это механизм, позволяющий объектам наследовать свойства и методы друг от друга через прототипную цепочку (prototype chain). В отличие от классического наследования, это динамический и гибкий подход.

Основные причины использования

1. Экономия памяти

Методы могут быть определены один раз на прототипе и использоваться всеми объектами:

// Без прототипа: каждый объект имеет свою копию метода
function Animal_BadWay(name) {
  this.name = name;
  this.speak = function() {
    console.log(this.name + ' makes a sound');
  };
}

const dog1 = new Animal_BadWay('Dog1');
const dog2 = new Animal_BadWay('Dog2');
console.log(dog1.speak === dog2.speak); // false - разные функции в памяти

// С прототипом: метод в памяти один раз
function Animal(name) {
  this.name = name;
}

Animal.prototype.speak = function() {
  console.log(this.name + ' makes a sound');
};

const cat1 = new Animal('Cat1');
const cat2 = new Animal('Cat2');
console.log(cat1.speak === cat2.speak); // true - один метод на всех

2. Динамическое наследование

Можно изменять поведение всех объектов в рантайме, добавляя методы на прототип:

const user = { name: 'John' };

// Добавить метод на прототип Object
Object.prototype.greet = function() {
  return `Hello, ${this.name}`;
};

console.log(user.greet()); // Даже user получит новый метод!

3. Цепочка прототипов (Prototype Chain)

Объект ищет свойство сначала в себе, потом в цепочке прототипов:

const animal = {
  type: 'mammal',
  move() { return 'Moving...'; }
};

const dog = Object.create(animal);
dog.name = 'Rex';
dog.bark = function() { return 'Woof!'; };

console.log(dog.bark()); // Woof! - в самом dog
console.log(dog.move()); // Moving... - найдёт в animal
console.log(dog.type);   // mammal - найдёт в animal
console.log(dog.hasOwnProperty('move')); // false - метод не свой

Способы реализации наследования

Способ 1: Классический (функции-конструкторы)

function Vehicle(type) {
  this.type = type;
}

Vehicle.prototype.getType = function() {
  return this.type;
};

function Car(type, doors) {
  Vehicle.call(this, type); // Вызвать родительский конструктор
  this.doors = doors;
}

Car.prototype = Object.create(Vehicle.prototype);
Car.prototype.constructor = Car;

Car.prototype.openDoor = function() {
  return 'Door opened';
};

const myCar = new Car('sedan', 4);
console.log(myCar.getType()); // sedan
console.log(myCar.openDoor()); // Door opened

Способ 2: Object.create() - более чистый подход

const animalProto = {
  speak() {
    return `${this.name} says something`;
  }
};

const dog = Object.create(animalProto);
dog.name = 'Buddy';
console.log(dog.speak()); // Buddy says something

Способ 3: ES6 классы (синтаксический сахар над прототипами)

class Vehicle {
  constructor(type) {
    this.type = type;
  }
  
  getType() {
    return this.type;
  }
}

class Car extends Vehicle {
  constructor(type, doors) {
    super(type);
    this.doors = doors;
  }
  
  openDoor() {
    return 'Door opened';
  }
}

const car = new Car('SUV', 4);
console.log(car.getType()); // SUV

Преимущества прототипного наследования

Гибкость:

• Можно менять поведение в рантайме
• Не нужно определять всё в момент создания класса
• Простое добавление/удаление методов

Производительность:

• Методы хранятся один раз в памяти
• Экономия оперативной памяти для больших объёмов объектов
• Быстрый доступ через цепочку прототипов

Универсальность:

• Не требует предварительного определения структуры
• Можно наследовать от любого объекта
• Делегирование (delegation) вместо копирования

Практический пример: система логирования

const logger = {
  log(msg) {
    console.log(`[LOG] ${msg}`);
  }
};

const errorLogger = Object.create(logger);
errorLogger.error = function(msg) {
  console.log(`[ERROR] ${msg}`);
};

const warningLogger = Object.create(logger);
warningLogger.warn = function(msg) {
  console.log(`[WARN] ${msg}`);
};

warningLogger.log('System started'); // Унаследовано из logger
warningLogger.warn('Low memory');     // Собственный метод
errorLogger.log('Init completed');   // Унаследовано из logger
errorLogger.error('Failed to load');  // Собственный метод

Итог

Прототипное наследование нужно для:

• Экономии памяти через переиспользование методов
• Гибкой архитектуры объектов
• Динамического расширения поведения в рантайме
• Построения иерархий с минимальными издержками

Это основа, на которой работает JavaScript, и понимание прототипов критично для глубокого освоения языка.