ФАЗА 35. БРАУЗЕР И CSS Контекст вызова

this зависит от способа вызова

Call site · bind · Arrow functions

Значение this определяется в точке вызова, а стрелочная функция берёт его из внешней лексической области.

1. Обычный вызов смотрит на call site

1 / 5

Метод объекта получает объект перед точкой, отдельная функция в strict mode получает undefined, new создаёт экземпляр, call и apply задают receiver явно.

  • Важна форма вызова.
  • obj.method и method ведут себя различно.
  • new связывает this с экземпляром.
thisМетод объектаОтдельная функцияnew и call

2. Strict mode убирает неявный глобальный объект

2 / 5

Без receiver обычная функция в strict mode видит undefined, в нестрогом режиме this может стать globalThis.

  • Модули строгие по умолчанию.
  • Глобальное случайное состояние опасно.
  • Ошибка доступа помогает найти потерю.
strict: undefinednon-strict: globalThis

3. Стрелка не имеет собственного this

3 / 5

Она захватывает значение внешней области при создании и не меняет его через call, apply или bind.

  • Колбэк сохраняет внешний контекст.
  • У стрелки нет своего prototype.
  • new со стрелкой не используют.
Внешняя областьСтрелочная функцияТот же this

4. Передача метода отрывает receiver

4 / 5

const fn = obj.method сохраняет функцию без объекта. bind возвращает связанную функцию, обёртка вызывает метод на obj явно.

  • Callback теряет точку вызова.
  • bind фиксирует receiver.
  • Повторный bind не заменяет первый.
obj.methodПередать как callback

5. React функции не требуют bind методов класса

5 / 5

Функциональный компонент использует замыкания и стрелки, а не экземплярный this. В классах контекст по-прежнему важен.

  • Props доступны из области.
  • Handler захватывает render.
  • Зависимости остаются явными.
Функция и замыканиеКласс и this

this: контекст вызова

← назад к разделу

this — один из самых частых источников неожиданных багов в JavaScript. В большинстве языков this — просто ссылка на текущий объект. В JavaScript всё иначе: значение this определяется не тем, где написана функция, а тем, как она вызвана. Одна и та же функция при разных вызовах получит разный this.

Четыре правила определения this

1. Вызов как метод объекта. this — объект слева от точки.

живой пример

const user = {
  name: "Алиса",
  greet() {
    console.log(this.name); // "Алиса"
  },
};
user.greet();
Запустить

Запуск примеров доступен в платном доступе. Там этот же код выполняется прямо в статье: редактор, запуск и проверка рядом с абзацем. Три дня бесплатно →

2. Обычный вызов функции. this — глобальный объект (window в браузере) или undefined в строгом режиме.

живой пример

function greet() {
  console.log(this); // window или undefined
}
greet();
Запустить

Запуск примеров доступен в платном доступе. Там этот же код выполняется прямо в статье: редактор, запуск и проверка рядом с абзацем. Три дня бесплатно →

3. call, apply, bind. Явное задание this.

живой пример

function greet(greeting) {
  console.log(`${greeting}, ${this.name}`);
}
const user = { name: "Алиса" };

greet.call(user, "Привет");      // "Привет, Алиса"
greet.apply(user, ["Привет"]);   // то же, аргументы массивом
const bound = greet.bind(user);
bound("Привет");                 // "Привет, Алиса"
Запустить

Запуск примеров доступен в платном доступе. Там этот же код выполняется прямо в статье: редактор, запуск и проверка рядом с абзацем. Три дня бесплатно →

4. Конструктор (new). this — новый создаваемый объект.

живой пример

function User(name) {
  this.name = name;
}
const alice = new User("Алиса");
console.log(alice.name); // "Алиса"
Запустить

Запуск примеров доступен в платном доступе. Там этот же код выполняется прямо в статье: редактор, запуск и проверка рядом с абзацем. Три дня бесплатно →

как вызвана функция this = obj obj.fn() window или undefined fn() this = x fn.call(x, …) новый объект new Fn()

Один и тот же код даёт разный this: решает форма вызова, а не место объявления.

Строгий режим: this без объекта

В нестрогом режиме обычный вызов функции даёт this === window. В строгом ("use strict") — this === undefined. Модули ES и тело класса всегда работают в строгом режиме.

живой пример

"use strict";
function greet() {
  console.log(this); // undefined, не window
}
greet();
Запустить

Запуск примеров доступен в платном доступе. Там этот же код выполняется прямо в статье: редактор, запуск и проверка рядом с абзацем. Три дня бесплатно →

Стрелочные функции: лексический this

Стрелочные функции не имеют собственного this. Они захватывают его из окружающего лексического контекста — из того места, где стрелочная функция написана, а не откуда вызвана.

const counter = {
  count: 0,
  start() {
    setInterval(() => {
      this.count++; // this = counter, захвачен из start()
      console.log(this.count);
    }, 1000);
  },
};
counter.start();

Если заменить стрелку на обычную функцию — this внутри setInterval станет window (или undefined), и count потеряется.

Потеря this при передаче метода как колбэка

Это классическая ловушка. Передача метода как колбэка «отрывает» его от объекта.

const user = {
  login: "alice",
  greet() {
    console.log(this.login);
  },
};

setTimeout(user.greet, 100); // undefined: this здесь window, а не user
document.querySelector("button").addEventListener("click", user.greet); // undefined: this здесь кнопка

Метод передаётся как голая функция, и объекта слева от точки при вызове нет: таймер вызовет её с this, равным window, а обработчик события подставит саму кнопку. Правило 1 не сработало, и user в this не попал.

Способы фиксации:

// bind — создаёт новую функцию с зафиксированным this
setTimeout(user.greet.bind(user), 100);

// стрелочная обёртка — this берётся лексически
setTimeout(() => user.greet(), 100);

this в классах

В классах методы работают по правилу метода объекта, но при передаче в колбэк — те же грабли. Решение: стрелочное свойство класса.

class Button {
  label = "Нажми меня";

  // Обычный метод — this теряется при передаче как колбэка
  handleClick() {
    console.log(this.label); // может быть undefined
  }

  // Стрелочное свойство — this зафиксирован навсегда
  handleClickArrow = () => {
    console.log(this.label); // всегда "Нажми меня"
  };
}

this в React-компонентах

В классовых компонентах потеря this в обработчиках была повседневной проблемой: нужно было вызывать this.handleClick = this.handleClick.bind(this) в конструкторе или писать стрелочные свойства.

В функциональных компонентах проблемы с this нет совсем. Обработчики событий пишутся как замыкания — переменные берутся из области видимости функции, а не через this.

function Counter() {
  const [count, setCount] = React.useState(0);
  return (
    <button onClick={() => setCount(count + 1)}>
      {count}
    </button>
  );
}

Это одна из причин, по которым функциональные компоненты стали стандартом.

Ловушки: что выведет код

живой пример

const obj = {
  val: 42,
  getVal() { return this.val; },
};

const fn = obj.getVal;
console.log(fn());          // undefined в нестрогом режиме, в модуле TypeError: this не obj
console.log(obj.getVal());  // 42
console.log(fn.call(obj));  // 42
Запустить

Запуск примеров доступен в платном доступе. Там этот же код выполняется прямо в статье: редактор, запуск и проверка рядом с абзацем. Три дня бесплатно →

живой пример

const obj = {
  val: 1,
  outer() {
    const inner = function () {
      return this.val; // this потерян — обычная функция
    };
    return inner();
  },
};
console.log(obj.outer()); // undefined, в модуле TypeError: this потерян; стрелка вместо function исправит
Запустить

Запуск примеров доступен в платном доступе. Там этот же код выполняется прямо в статье: редактор, запуск и проверка рядом с абзацем. Три дня бесплатно →

Коротко

  • this определяется способом вызова, а не местом объявления функции.
  • Четыре правила: метод (obj.fn()) → объект; обычный вызов → window/undefined; call/apply/bind → заданный объект; new → новый объект.
  • В строгом режиме (модули, классы) обычный вызов без объекта даёт undefined, не window.
  • Стрелочные функции не имеют своего this — берут его лексически из окружающего кода.
  • Передача метода как колбэка — потеря this. Фиксируют через .bind() или стрелочную обёртку.
  • В функциональных React-компонентах this не нужен: обработчики работают как замыкания.

Что почитать дальше