Что происходит при обращении к методу объекта которого нет в текущем объекте?

Механизм поиска метода: цепочка прототипов и протокол [[Get]]

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

Пошаговый алгоритм работы

1. Инициирование поиска через операцию [[Get]]: При выполнении obj.method(), сначала происходит вызов внутренней операции [[Get]] для свойства method. Эта операция описана в спецификации ECMAScript.
2. Поиск в собственном объекте: Движок проверяет, есть ли свойство method среди собственных свойств (own properties) объекта obj. Если свойство найдено, его значение возвращается.
3. Подъем по цепочке прототипов: Если свойство не найдено, движок обращается к внутреннему свойству [[Prototype]] объекта obj (доступному через __proto__ или Object.getPrototypeOf()). Поиск повторяется уже в объекте-прототипе.
4. Рекурсия до null: Шаг 3 повторяется рекурсивно для каждого следующего прототипа в цепочке.
5. Завершение поиска: Цепочка заканчивается, когда [[Prototype]] становится равным null. На этом этапе операция [[Get]] возвращает undefined.

// Пример: Демонстрация цепочки прототипов
const animal = {
  type: 'mammal',
  makeSound() {
    console.log(`${this.type} makes a sound`);
  }
};

const dog = {
  name: 'Rex',
  __proto__: animal // Устанавливаем явную связь (для примера, обычно используют Object.create или классы)
};

console.log(dog.name); // "Rex" - собственное свойство
dog.makeSound(); // "mammal makes a sound" - метод найден в прототипе
console.log(dog.age); // undefined - свойство не найдено ни в объекте, ни в цепочке

Важные нюансы и механизмы

• Контекст this: Когда метод вызывается и находится в прототипе, значение this внутри него всегда указывает на исходный объект, с которого начался поиск (в примере выше this внутри makeSound ссылается на dog, а не на animal). Это критически важно для понимания поведения прототипных методов.

• Переопределение (shadowing): Если добавить свойство с тем же именем в сам объект, оно «затенит» свойство прототипа. Поиск остановится на первом найденном совпадении.

  dog.type = 'canine'; // Создаем собственное свойство
  dog.makeSound(); // "canine makes a sound" - this.type теперь ссылается на dog.type
  

• Стандартная цепочка для объектов и функций:

    *   Для объекта, созданного с помощью литерала `{}`, прототипом является `Object.prototype`.
    *   Для массива `[]` — `Array.prototype`.
    *   Для функции `function(){}` — `Function.prototype`.
    Все эти цепочки в итоге ведут к `Object.prototype`, а затем к `null`.

• get-тер и Proxy: Механизм можно перехватить или модифицировать с помощью:

    *   **Геттера (getter)**: Свойство, при обращении к которому вызывается функция.

    ```javascript
    const objWithGetter = {
      get method() {
        return () => console.log('Это не метод, а геттер!');
      }
    };
    ```

    *   **Объекта Proxy**: Позволяет перехватывать и кастомизировать базовые операции, включая `[[Get]]`.

    ```javascript
    const handler = {
      get(target, prop) {
        if (prop === 'missingMethod') {
          return () => console.log('Динамически созданный метод!');
        }
        return Reflect.get(...arguments);
      }
    };
    const proxiedObj = new Proxy({}, handler);
    proxiedObj.missingMethod(); // "Динамически созданный метод!"
    ```

• Ошибка при вызове: Если в результате поиска возвращается не функция (например, undefined или другое значение), а мы пытаемся вызвать это как функцию (obj.method()), движок выбросит исключение TypeError: obj.method is not a function.

Практическое значение для разработчика

Понимание этого механизма необходимо для:

1. Отладки: Поиска «потерявшихся» методов или анализа неожиданного поведения из-за переопределения в цепочке.
2. Оптимизации производительности: Слишком длинная цепочка прототипов (например, из-за глубокого наследования) может негативно сказаться на производительности в «горячих» участках кода.
3. Создания эффективных архитектур: Использования композиции вместо глубокого наследования (принцип «Composition over Inheritance»), делегирования методов и паттернов вроде Миксинов (Mixins).
4. Работы с современным синтаксисом ES6: Классы (class) в JavaScript — это синтаксический сахар над существующей прототипной моделью. Методы класса хранятся в прототипе конструктора.

// Класс - это функция, его методы - в прототипе
class Animal {
  constructor(type) { this.type = type; }
  makeSound() { console.log('...'); }
}

const cat = new Animal('feline');
console.log(cat.hasOwnProperty('makeSound')); // false
console.log(cat.__proto__.hasOwnProperty('makeSound')); // true

Таким образом, обращение к отсутствующему методу — это не ошибка, а штатный сценарий, который запускает хорошо определенный алгоритм поиска по цепочке прототипов, что является краеугольным камнем гибкой и динамической природы JavaScript.