TeoreticQuiz

JavaScript

Материал для подготовки к собеседованию (Middle / Senior). На основе исходного конспекта; примеры кода перенесены из скриншотов исходного документа в текст (по правилу проекта картинки не вставляем). Материал переупорядочен по логическим блокам, дополнен и местами исправлен.

Содержание


Типы данных

Примитивные типы: Number (безопасный диапазон целых ±(2^53 − 1)), String, Boolean, Null, Undefined, BigInt, Symbol. Отдельно стоит Object (не примитив).

typeof x или typeof(x) — вернёт строку, например "string".

Для null возвращается "object" — это ошибка (баг) в языке, на самом деле это не объект.

BigInt — для целых чисел произвольной длины (когда не хватает точности Number):

const bigInt = 1234567890123456789012345678901234567890n;

Обычно null используется для присвоения переменной «пустого» или «неизвестного» значения, а undefined — значение по умолчанию для объявленных, но неинициализированных переменных (обращение к необъявленной переменной — ReferenceError; typeof для неё вернёт "undefined").

null vs undefined и особые значения (дополнение)

  • null — намеренное «пусто», задаётся разработчиком; undefined — «значения нет» (переменная объявлена, но не присвоена; отсутствующее свойство; функция без return).
  • NaN — «не число», результат некорректной математической операции; NaN !== NaN (проверять через Number.isNaN()).
  • Проверка «есть ли значение»: value == null истинно и для null, и для undefined.

== vs === и приведение типов (дополнение)

  • === — строгое сравнение (без приведения типов), == — нестрогое (с приведением). На собеседовании почти всегда рекомендуют ===.
  • Приведение типов (type coercion) происходит в ==, арифметике, шаблонных строках. Примеры-ловушки: 0 == '' → true, 0 == '0' → true, null == undefined → true, [] == false → true.

Optional chaining и nullish coalescing (дополнение)

const city = user?.address?.city;      // не упадёт, если address undefined → вернёт undefined
const port = config.port ?? 8080;      // 8080, только если port === null или undefined

?? отличается от || тем, что не считает «пустыми» 0, '', false.


Символы (Symbol)

«Символ» представляет собой уникальный идентификатор.

// Создаём новый символ - id
let id = Symbol("id");

Символы позволяют создавать «скрытые» свойства объектов, к которым нельзя нечаянно обратиться или перезаписать из другого кода:

let user = {
  name: "Вася"
};

let id = Symbol("id");
user[id] = 1;

alert( user[id] );

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

let id = Symbol("id");

let user = {
  name: "Вася",
  [id]: 123 // просто "id: 123" не сработает
};

Почему же лучше использовать Symbol("id"), а не строку "id"? Так как объект user принадлежит стороннему коду, и этот код тоже работает с ним, то нам не следует добавлять в него свои поля с обычными строковыми ключами — можно случайно перезаписать чужое свойство. А к символу сторонний код случайно не обратится. Кроме того, если другой скрипт захочет записать своё свойство с таким же смыслом, он создаст свой собственный Symbol("id") — конфликта не будет.

Символы игнорируются циклом for…in (и Object.keys).

Глобальный реестр символов

// читаем символ из глобального реестра и записываем его в переменную
let id = Symbol.for("id"); // если символа не существует, он будет создан

// читаем его снова и записываем в другую переменную (возможно, из другого места кода)
let idAgain = Symbol.for("id");

// проверяем -- это один и тот же символ
alert( id === idAgain ); // true

Symbol.for(key) возвращает один и тот же символ для одного ключа (в отличие от Symbol(), который всегда уникален).


Объектные обёртки

Объектные обёртки (Wrapper Objects) — это объекты, которые предоставляют обёртку вокруг примитивных значений и дают методы/свойства для работы с ними:

  1. Number — обёртка для примитивного типа number.
  2. String — обёртка для примитивного типа string.
  3. Boolean — обёртка для примитивного типа boolean.

Автоматическая обёртка: JavaScript автоматически создаёт объектную обёртку для примитива на момент вызова метода (например, "abc".toUpperCase()), а затем сразу её удаляет. Поэтому у примитивов «есть методы», хотя сами они не объекты.


Объекты, сравнение и копирование

Почему в JS массив — это объект

В JavaScript массивы являются подтипом объектов. Это означает, что массивы имеют все свойства объектов, плюс дополнительные (индексы, length, методы массива):

const arr = [1, 2, 3];
console.log(typeof arr);            // "object"
console.log(arr instanceof Array);  // true
console.log(arr instanceof Object); // true

Сравнение примитивов и объектов

В JS объекты и примитивы сравниваются по-разному. Примитивы сравниваются по значению. Объекты сравниваются по ссылке — два разных объекта с одинаковым содержимым не равны, равны только ссылки на один и тот же объект.

1 === 1;                       // true (по значению)
({}) === ({});         // false (разные ссылки; без скобок `{}` в начале инструкции — блок → SyntaxError)
const o = {a: 1}; o === o;     // true (та же ссылка)

Определение наличия свойства в объекте

Существует три способа.

Первый — оператор in:

const o = {
  'prop': 'bwahahah',
  'prop2': 'hweasa'
};
console.log('prop' in o)  // true
console.log('prop1' in o) // false

Второй — метод hasOwnProperty:

console.log(o.hasOwnProperty('prop2')) // true
console.log(o.hasOwnProperty('prop1')) // false

Третий — индексная (скобочная) нотация:

console.log(o['prop'])  // bwahahah
console.log(o['prop1']) // undefined

Отличие: оператор in проверяет наличие свойства не только в самом объекте, но и во всей цепочке прототипов; hasOwnProperty — только собственные свойства объекта.

Способы создания глубокой копии

  • JSON.parse(JSON.stringify(obj)) — простой, но теряет функции, undefined, Date превращает в строку, не работает с циклами.
  • structuredClone(obj) — встроенный современный способ (поддерживает многое, включая циклы).
  • _.cloneDeep(obj) из Lodash.
  • Своя рекурсивная функция.

Поверхностная копия (shallow): {...obj}, Object.assign({}, obj), arr.slice() — копируют только верхний уровень.


Дескрипторы свойств, freeze и seal

Дескрипторы свойств у объектов описывают поведение каждого свойства:

  • enumerable — отвечает за то, будет ли свойство перечисляться в циклах (for...in, Object.keys).
  • writable — можно ли изменять значение свойства.
  • configurable — можно ли изменять другие дескрипторы свойства, удалять свойство, менять его тип.

Object.freeze делает объект неизменяемым. После применения:

  • Нельзя добавлять новые свойства.
  • Нельзя удалять существующие свойства.
  • Нельзя изменять значения существующих свойств.
  • Нельзя изменять прототип объекта.

Object.seal «запечатывает» объект:

  • Нельзя добавлять новые свойства.
  • Нельзя удалять существующие свойства.
  • Можно изменять значения существующих свойств.
  • Нельзя изменять прототип объекта.

Важно: оба метода делают поверхностную заморозку (вложенные объекты остаются изменяемыми).


Переменные и области видимости

Отличия var и let

let:

  • Имеет блочную область видимости (block scope).
  • Переменные, объявленные через let, тоже поднимаются, но не инициализируются: попытка обратиться к ним до объявления даёт ReferenceError (это называется «временная мёртвая зона», TDZ).
  • Не позволяет повторно объявлять переменную в той же области видимости.

var:

  • Имеет функциональную область видимости (function scope).
  • Поднятие (hoisting): переменные var поднимаются в верхнюю часть области и инициализируются значением undefined.
  • Позволяет повторно объявлять переменную в той же области видимости.

const — как let (блочная область), но значение нельзя переприсвоить (сама ссылка постоянна; содержимое объекта/массива при этом менять можно).


Hoisting (поднятие)

Hoisting — это механизм, при котором объявления переменных и функций «поднимаются» в начало своей области видимости на этапе компиляции.

  1. Объявления переменных. Для var поднимается только сама переменная (без значения):
console.log(x); // undefined
var x = 5;
console.log(x); // 5
  1. Объявления функций. Функции-объявления (function declaration) поднимаются целиком — их можно вызвать до объявления:
sayHello(); // "Hello!"
function sayHello() {
  console.log("Hello!");
}
  1. Стрелочные функции и let/const не поднимаются так же: обращение до инициализации даёт ошибку:
console.log(y); // ReferenceError: Cannot access 'y' before initialization
let y = 10;

Важные моменты: hoisting может привести к путанице, если разработчик не осознаёт его существование. Использование let и const вместо var помогает избежать связанных с этим проблем.


use strict

"use strict" — это директива ES5, которая заставляет весь код или код отдельной функции выполняться в «строгом режиме».

Ограничения строгого режима:

  • Нельзя присваивать значения или обращаться к необъявленным переменным.
  • Запрещено присваивать значения глобальным переменным, доступным только для чтения, или защищённым.
  • Нельзя удалить «неудаляемое» свойство объекта.
  • Запрещено дублирование параметров функции.
  • Значением this по умолчанию является undefined (а не глобальный объект).

В модулях (ES-модулях) строгий режим включён всегда автоматически.


Лексическое окружение и замыкания

Замыкание — это функция, у которой есть доступ к области видимости, сформированной внешней функцией, даже после того как внешняя функция завершила выполнение.

Что такое лексическое окружение? Понятие «лексическое окружение» (или «статическое окружение») — это внутренний объект, связанный с каждым выполняемым блоком/функцией.

Лексическое окружение содержит два компонента:

  • Запись окружения (environment record) — место, где хранятся объявления переменных и функций.
  • Ссылка на внешнее окружение (reference to the outer environment) — ссылка, позволяющая обращаться к переменным родительского окружения.

Пример из конспекта (image2): при вызове функции создаётся своё лексическое окружение, у которого есть ссылка на внешнее (глобальное) окружение — так функция видит переменные снаружи:

const x = 1;

const logToConsole = function() {
  console.log(x)
}

logToConsole()

Схема окружений:

1. ГЛОБАЛЬНОЕ:
{
  ссылка на внешнее: -> null
  переменные: {
    x: 1,
    logToConsole: function
  }
}

2. ЛОКАЛЬНОЕ (logToConsole):
{
  ссылка на внешнее: -> глобальное лексическое окружение
  переменные: { } // пусто, x берётся из внешнего окружения
}

Именно ссылка на внешнее окружение и делает возможным замыкание: logToConsole «помнит» x, потому что видит глобальное окружение.


Контекст выполнения и this

Контекст выполнения (execution context) создаётся при запуске функции: создание лексического окружения, области видимости и установка this (в браузере глобальный this — window).

this в обычных функциях получает своё значение в зависимости от способа вызова функции:

var name = "Oleksii";

function getName() {
  return this.name;
}

getName(); // "Oleksii"  (вызов как функция → this = window/global; window.getName)
var name = "Oleksii";

const student = {
  name: "John",
  getName: function () {
    return this.name;
  }
};

student.getName(); // "John"  (вызов как метод → this = объект перед точкой)
class Human {
  constructor(name) {
    this.name = name;
  }
}

const human1 = new Human("Nick"); // при new this = новый объект

this в стрелочных функциях. Стрелочные функции не имеют своего this — они берут его от родителя (из места объявления):

var name = "Oleksii";

const student = {
  name: "John",
  getName: () => {
    return this.name;
  }
};

student.getName(); // "Oleksii"  (this взят из внешнего контекста, а не из student)

call, apply, bind

Методы call, apply и bind используются для управления контекстом (this) при вызове функций.

call вызывает функцию с указанным this и аргументами, переданными по отдельности:

function greet(greeting) {
  console.log(greeting + ', ' + this.name);
}
const person = { name: 'Alice' };
greet.call(person, 'Hello'); // Вывод: Hello, Alice

apply аналогичен call, но принимает аргументы в виде массива (или массивоподобного объекта):

function greet(greeting) {
  console.log(greeting + ', ' + this.name);
}
const person = { name: 'Bob' };
greet.apply(person, ['Hi']); // Вывод: Hi, Bob

bind создаёт новую функцию, которая при вызове будет иметь заданный контекст this (и, при желании, предустановленные аргументы). Сразу не вызывает:

function greet(greeting) {
  console.log(greeting + ', ' + this.name);
}
const person = { name: 'Charlie' };
const boundGreet = greet.bind(person);
boundGreet('Hey'); // Вывод: Hey, Charlie

Мнемоника: call — comma (через запятую), apply — array (массив), bind — возвращает функцию.


Функции

Объявление функции vs функциональное выражение

Это два способа определения функций.

Объявление функции (function declaration) — традиционный способ; поднимается (hoisting), можно вызвать до объявления:

console.log(typeof myFunction); // Вывод: function

function myFunction() {
  console.log('Привет, админ!');
}

Функциональное выражение (function expression) — функция присваивается переменной; НЕ поднимается как объявление, вызвать до определения нельзя:

let greet = function() {
  console.log('Привет, админ!');
};

greet(); // Привет, админ!

Пример разницы через hoisting:

hoistedFunc();     // работает
notHoistedFunc();  // ошибка: notHoistedFunc is not a function

function hoistedFunc(){
  console.log('I am hoisted')
}

var notHoistedFunc = function(){
  console.log('I will not be hoisted!')
}

Вызов notHoistedFunc приведёт к ошибке, а hoistedFunc — нет, потому что объявление функции «всплывает».

Функциональные выражения могут: быть анонимными; формировать замыкания; передаваться как аргументы другим функциям; использоваться как немедленно вызываемые (IIFE).

IIFE

IIFE (Immediately Invoked Function Expression) — функция, которая вызывается сразу же после её определения:

(function () {
  // код инициализации
})();

Лучшее применение IIFE — выполнение функций настройки/инициализации и предотвращение загрязнения глобальной области видимости (переменные внутри IIFE не «утекают» наружу).

Функции высшего порядка (Higher Order Functions)

Функция высшего порядка — это функция, которая возвращает другую функцию или принимает другую функцию в качестве аргумента:

function higherOrderFunction(param, callback) {
  return callback(param)
}

Примеры встроенных HOF: map, filter, reduce, forEach, sort.

Функции — объекты первого класса (First-class Objects)

Функции называют объектами первого класса, потому что они обрабатываются так же, как любое другое значение: их можно присваивать переменным, передавать в аргументы, возвращать из функций, хранить в структурах данных.

arguments

arguments — это коллекция аргументов, переданных функции. Это объект, подобный массиву (array-like), но не настоящий массив (нет методов массива). Доступен только в обычных функциях (в стрелочных его нет — там используют rest ...args).

Основные методы массивов (дополнение)

[1,2,3].map(x => x * 2);              // [2,4,6]  — преобразование
[1,2,3,4].filter(x => x % 2 === 0);   // [2,4]    — фильтрация
[1,2,3,4].reduce((acc, x) => acc + x, 0); // 10  — свёртка
[1,2,3].forEach(x => console.log(x)); // перебор
[1,2,3].find(x => x > 1);             // 2
[1,2,3].some(x => x > 2);             // true
[1,2,3].every(x => x > 0);            // true

Стрелочные функции vs обычные

Стрелочная Обычная
Отсутствует свой this — берётся из родителя (и не может быть конструктором) Присутствует свой this
Отсутствует arguments Присутствует arguments
Нет hoisting Есть hoisting (для function declaration)
Неявный return (иногда) Явный return

Стрелочную функцию нельзя вызвать с new, у неё нет prototype, нет собственного arguments (используют rest-параметры). this определяется лексически — местом объявления.


Генераторы

Генераторы — специальный тип функций, которые генерируют последовательность значений «лениво», по одному за раз. Объявляются синтаксисом function*, значения отдаются через yield.

function* generateNumbers() {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
  return 5;
}

let gen = generateNumbers();
console.log(gen.next()); // { value: 1, done: false }
console.log(gen.next()); // { value: 2, done: false }
console.log(gen.next()); // { value: 3, done: false }
console.log(gen.next()); // { value: 4, done: false }
console.log(gen.next()); // { value: 5, done: true }

Генератор возвращает итератор, который можно использовать для контроля над выполнением функции: каждый вызов next() выполняет код до следующего yield и «замораживает» функцию до следующего вызова. Применение — ленивые/бесконечные последовательности, потоковая обработка, кастомные итераторы.


Прототипное наследование

Каждый объект в JavaScript имеет внутреннее свойство [[Prototype]], которое ссылается на другой объект (прототип). Если свойство не найдено в самом объекте, движок ищет его в прототипе, затем в прототипе прототипа — и так по всей цепочке прототипов.

Явное задание прототипа через Object.create:

const animal = {
  speak() {
    console.log('Animal speaks');
  }
};

const dog = Object.create(animal);
dog.speak(); // Animal speaks

Здесь dog наследует метод speak от animal. Прототипное наследование позволяет строить цепочки объектов.

Пример с функцией-конструктором:

function Animal(name) {
  this.name = name;
}
Animal.prototype.speak = function() {
  console.log(`${this.name} says hello`);
};

const dog = new Animal('Dog');
dog.speak(); // Dog says hello

Проверка, наследует ли объект от другого — метод isPrototypeOf:

console.log(Animal.prototype.isPrototypeOf(dog)); // true

Установка прототипа через __proto__:

let animal = {
  eats: true
};
let rabbit = {
  jumps: true
};
rabbit.__proto__ = animal;

Или сразу в литерале:

let animal = {
  eats: true,
  walk() {
    alert("Animal walk");
  }
};
let rabbit = {
  jumps: true,
  __proto__: animal
};

// walk взят из прототипа
rabbit.walk(); // Animal walk

Если унаследованные свойства нам не нужны (например, при переборе), их можно отфильтровать встроенным методом hasOwnProperty (проверяет только собственные свойства).

Примечание: __proto__ — устаревший (хоть и рабочий) способ; современные — Object.getPrototypeOf / Object.setPrototypeOf и Object.create.


Классы

Синтаксис class — «синтаксический сахар» над прототипным наследованием.

class User {
  family = "Аноним";       // поле класса

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

  sayHi() {
    alert(this.name);
  }

  get name() {
    return this._name;
  }

  set name(value) {
    if (value.length < 4) {
      alert("Имя слишком короткое.");
      return;
    }
    this._name = value;
  }
}

// Использование:
let user = new User("Иван");
user.sayHi();

super. У классов есть ключевое слово super:

  • super.method(...) вызывает родительский метод.
  • super(...) вызывает родительский конструктор (работает только внутри своего конструктора).

Статические методы и свойства — принадлежат самому классу, а не его экземплярам:

class User {
  static publisher = "Илья Кантор";

  static staticMethod() {
    alert(this === User);
  }
}

User.staticMethod(); // true

Защищённые свойства обычно начинаются с префикса _. Это не синтаксис языка, а соглашение между программистами: такие свойства и методы не следует трогать извне.

Приватные свойства и методы должны начинаться с #. Они доступны только внутри класса (это уже синтаксис языка):

class Bank {
  #balance = 0;
  deposit(sum) { this.#balance += sum; }
}

Map, Set, WeakMap, WeakSet

1. Map — коллекция пар «ключ-значение», где ключи могут быть любого типа (включая объекты и функции). Сохраняет порядок вставки. Методы:

  • set(key, value) — добавить пару.
  • get(key) — получить значение по ключу.
  • has(key) — проверить наличие ключа.
  • delete(key) — удалить пару.
  • clear() — очистить всё.
  • size — количество пар.

2. Set — коллекция уникальных значений (дубликаты не хранятся). Методы:

  • add(value) — добавить значение.
  • has(value) — проверить наличие.
  • delete(value) — удалить.
  • clear() — очистить.
  • size — количество значений.

3. WeakMap — коллекция пар «ключ-значение», где ключи могут быть только объектами (с ES2023 — ещё и незарегистрированными символами, не из Symbol.for) и хранятся по слабой ссылке (если на объект-ключ больше нет ссылок, он может быть удалён сборщиком мусора вместе с записью). Методы: set, get, has, delete. Не итерируется, нет size.

4. WeakSet — коллекция уникальных объектов со слабой ссылкой. Методы: add, has, delete. Не итерируется.

Зачем Weak-версии: не мешают сборке мусора — удобно хранить служебные/кэш-данные, привязанные к объектам, без риска утечек памяти.


Деструктуризация

С помощью деструктуризации объектов можно извлекать свойства в отдельные переменные:

const person = {
  name: 'Alice',
  age: 25,
  city: 'New York'
};

const { name, age } = person;
console.log(name); // Alice
console.log(age);  // 25

Переименование переменных и значения по умолчанию при деструктуризации:

const { name: fullName = 123, age: yearsOld } = person;
console.log(fullName); // Alice
console.log(yearsOld); // 25

Деструктуризация массивов извлекает элементы по их индексу (можно пропускать элементы):

const colors = ['red', 'green', 'blue'];
const [firstColor, , thirdColor] = colors;
console.log(firstColor); // red
console.log(thirdColor); // blue

Вложенная деструктуризация:

const user = {
  id: 1,
  info: {
    name: 'Bob',
    age: 30
  }
};

const { info: { name, age } } = user;
console.log(name); // Bob
console.log(age);  // 30

Остаток в массив через rest:

let [name1, name2, ...rest] = ["Julius", "Caesar", "Consul", "of the Roman Republic"];
// rest это массив элементов, начиная с 3-го
alert(rest[0]);      // Consul
alert(rest[1]);      // of the Roman Republic
alert(rest.length);  // 2

Spread и rest

Операторы spread и rest имеют схожий синтаксис (...), но выполняют разные функции.

Spread «разворачивает» (распространяет) элементы массива/объекта.

  1. Разворачивание массива:
const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
const combined = [...arr1, ...arr2]; // [1, 2, 3, 4, 5, 6]
  1. Передача аргументов в функцию:
function sum(x, y, z) {
  return x + y + z;
}
const numbers = [1, 2, 3];
console.log(sum(...numbers)); // 6
  1. Копирование/расширение объекта:
const obj1 = { a: 1, b: 2 };
const obj2 = { ...obj1, c: 3 }; // { a: 1, b: 2, c: 3 }

Rest собирает оставшиеся элементы/аргументы в массив.

  1. Сбор аргументов в массив:
function collect(...args) {
  console.log(args); // Массив всех переданных аргументов
}
collect(1, 2, 3); // [1, 2, 3]
  1. Комбинирование с другими параметрами:
function myFunction(a, b, ...rest) {
  console.log(a);    // 1
  console.log(b);    // 2
  console.log(rest); // [3, 4, 5]
}
myFunction(1, 2, 3, 4, 5);

Проще говоря: spread разворачивает, rest собирает.


Нововведения ES6

Что нового привнёс стандарт ES6 (ECMAScript 2015):

  • Стрелочные функции (Arrow Functions).
  • Классы (Classes).
  • Шаблонные строки (Template Strings).
  • Расширенные объектные литералы (Enhanced Object Literals).
  • Деструктуризация (Object Destructuring).
  • Промисы (Promises).
  • Генераторы (Generators).
  • Модули (Modules).
  • Symbol.
  • Прокси (Proxies).
  • Множества (Sets).
  • Параметры по умолчанию.
  • Операторы rest и spread.
  • Блочная область видимости (let и const).

Шаблонные литералы — например `Hello ${user.name}` (подстановка выражений в строку и многострочные строки).


Event Loop

Идея событийного цикла проста: есть бесконечный цикл, в котором движок JavaScript ожидает задачи, выполняет их, затем снова ждёт.

Порядок работы Event Loop:

  1. Сначала Event Loop проверяет, выполнились ли все синхронные задачи (очистить стек вызовов).
  2. Потом выполняются все задачи из микротасков.
  3. После выполнения всех микротасков очередь очищается.
  4. Затем берётся одна макрозадача из списка и выполняется.
  5. После выполнения проверяется, нужна ли перерисовка страницы.
  6. Если нужна — делается перерисовка (render).
  7. Всё снова начинается с первого пункта.

Классический пример на порядок вывода:

setTimeout(() => {
  console.log(1);
}, 0);

Promise.resolve().then(() => {
  console.log(2);
});

console.log(3);
// Вывод: 3, 2, 1
// 3 — синхронно; 2 — микротаска (промис); 1 — макротаска (setTimeout)

Микрозадачи (микротаски):

promise.then(() => { /* ... */ });
promise.catch(() => { /* ... */ });
promise.finally(() => { /* ... */ });
async () => { /* ... */ };
queueMicrotask(() => { /* ... */ });

Макрозадачи:

setTimeout(() => { /* ... */ }, delay);
setInterval(() => { /* ... */ }, delay);
setImmediate(() => { /* ... */ });        // Node.js
window.addEventListener("ev", () => { /* ... */ });

Web API — то, что предоставляет браузер (движок JS сам этого не содержит): setTimeout, fetch, XMLHttpRequest, localStorage, sessionStorage, document и многое другое. Асинхронные операции выполняются через Web API, а их колбэки попадают в очереди задач.

Ключевая мысль: все микротаски выполняются раньше следующей макротаски.


Промисы

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

У объекта promise, возвращаемого конструктором new Promise, есть внутренние свойства:

  • state («состояние») — вначале "pending" («ожидание»), потом меняется на "fulfilled" («выполнено успешно») или "rejected" («выполнено с ошибкой»).
  • result («результат») — вначале undefined, далее изменяется на value при вызове resolve(value) или на error при вызове reject(error).

Создание промиса — успешное завершение (resolve):

let promise = new Promise(function(resolve, reject) {
  // эта функция выполнится автоматически, при вызове new Promise
  // через 1 секунду сигнализировать, что задача выполнена с результатом "done"
  setTimeout(() => resolve("done"), 1000);
});

Завершение с ошибкой (reject):

let promise = new Promise(function(resolve, reject) {
  // спустя одну секунду будет сообщено, что задача выполнена с ошибкой
  setTimeout(() => reject(new Error("Whoops!")), 1000);
});

Цепочка промисов

Каждый then возвращает новый промис — результат передаётся дальше по цепочке:

new Promise(function(resolve, reject) {

  setTimeout(() => resolve(1), 1000); // (*)

}).then(function(result) { // (**)
  alert(result); // 1
  return result * 2;
}).then(function(result) { // (***)
  alert(result); // 2
  return result * 2;
}).then(function(result) {
  alert(result); // 4
  return result * 2;
});

Если из then вернуть промис, следующий then дождётся его:

new Promise(function(resolve, reject) {
  setTimeout(() => resolve(1), 1000);
}).then(function(result) {
  alert(result); // 1
  return new Promise((resolve, reject) => { // (*)
    setTimeout(() => resolve(result * 2), 1000);
  });
}).then(function(result) { // (**)
  alert(result); // 2
  return new Promise((resolve, reject) => {
    setTimeout(() => resolve(result * 2), 1000);
  });
}).then(function(result) {
  alert(result); // 4
});

Неявный try...catch

Вокруг функции промиса и обработчиков находится «невидимый try..catch». Если происходит исключение, оно перехватывается, и промис считается отклонённым с этой ошибкой. Эти два кода работают одинаково:

new Promise((resolve, reject) => {
  throw new Error("Ошибка!");
}).catch(alert); // Error: Ошибка!
new Promise((resolve, reject) => {
  reject(new Error("Ошибка!"));
}).catch(alert); // Error: Ошибка!

Promise.all

Запускает множество промисов параллельно и ждёт, пока выполнятся все. Результат — массив результатов в порядке исходных промисов (даже если какой-то выполнился быстрее):

Promise.all([
  new Promise(resolve => setTimeout(() => resolve(1), 3000)), // 1
  new Promise(resolve => setTimeout(() => resolve(2), 2000)), // 2
  new Promise(resolve => setTimeout(() => resolve(3), 1000))  // 3
]).then(alert); // когда все промисы выполнятся, результат будет 1,2,3

Пример со списком запросов:

Promise.all([
  fetch('/template.html'),
  fetch('/style.css'),
  fetch('/data.json')
]).then(render); // методу render нужны результаты всех fetch

Если любой из промисов завершится с ошибкой, то промис, возвращённый Promise.all, немедленно завершается с этой ошибкой (принцип «всё или ничего»).

Promise.allSettled

Всегда ждёт завершения всех промисов. В массиве результатов будет:

  • {status:"fulfilled", value:результат} для успешных;
  • {status:"rejected", reason:ошибка} для ошибок.
let urls = [
  'https://api.github.com/users/iliakan',
  'https://api.github.com/users/remy',
  'https://no-such-url'
];

Promise.allSettled(urls.map(url => fetch(url)))
  .then(results => { // (*)
    results.forEach((result, num) => {
      if (result.status == "fulfilled") {
        alert(`${urls[num]}: ${result.value.status}`);
      }
      if (result.status == "rejected") {
        alert(`${urls[num]}: ${result.reason}`);
      }
    });
  });

Promise.race

Похож на Promise.all, но ждёт только первый выполнившийся промис (успех или ошибка) и берёт его результат:

Promise.race([
  new Promise((resolve, reject) => setTimeout(() => resolve(1), 1000)),
  new Promise((resolve, reject) => setTimeout(() => reject(new Error("Ошибка!")), 2000)),
  new Promise((resolve, reject) => setTimeout(() => resolve(3), 3000))
]).then(alert); // 1

Promise.any

Похож на Promise.race, но ждёт только первый успешно выполненный промис (ошибки игнорирует, пока есть шанс на успех):

Promise.any([
  new Promise((resolve, reject) => setTimeout(() => reject(new Error("Ошибка!")), 1000)),
  new Promise((resolve, reject) => setTimeout(() => resolve(1), 2000)),
  new Promise((resolve, reject) => setTimeout(() => resolve(3), 3000))
]).then(alert); // 1

Promise.resolve и Promise.reject

Promise.resolve(value) создаёт успешно выполненный промис с результатом value:

let promise = new Promise(resolve => resolve(value));

Promise.reject(error) создаёт промис, завершённый с ошибкой error:

let promise = new Promise((resolve, reject) => reject(error));

async / await

У слова async один простой смысл: такая функция всегда возвращает промис. Значения других типов автоматически оборачиваются в успешно выполненный промис.

await можно использовать только внутри async-функции — он «ждёт» выполнения промиса и возвращает его результат (не блокируя основной поток):

async function getUser() {
  try {
    const response = await fetch('/api/user');   // ждём ответ
    const user = await response.json();           // ждём разбор JSON
    return user;
  } catch (error) {
    console.error('Ошибка:', error);              // ловим и отклонённые промисы
  }
}

getUser().then(user => console.log(user));

По сути async/await — это более читаемая запись цепочек промисов; ошибки ловятся обычным try/catch.


AJAX и Fetch API

AJAX (Asynchronous JavaScript and XML) и Fetch API — технологии для выполнения асинхронных HTTP-запросов без перезагрузки страницы.

AJAX — техника, использующая объект XMLHttpRequest для обмена данными с сервером:

const xhr = new XMLHttpRequest();
xhr.open('GET', 'https://api.example.com/data', true);

xhr.onload = function () {
    if (xhr.status >= 200 && xhr.status < 300) {
        const response = JSON.parse(xhr.responseText);
        console.log(response);
    } else {
        console.error('Ошибка:', xhr.statusText);
    }
};

xhr.onerror = function () {
    console.error('Ошибка сети');
};

xhr.send();

Fetch API — современный интерфейс для HTTP-запросов, основанный на промисах:

const data = { name: 'John', age: 30 };

fetch('https://api.example.com/data', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data) // Преобразуем объект в строку JSON
})
.then(response => {
    if (!response.ok) {
        throw new Error('Сеть ответила с ошибкой: ' + response.statusText);
    }
    return response.json();
})
.then(data => {
    console.log('Успех:', data);
})
.catch(error => {
    console.error('Ошибка:', error);
});

Важный нюанс fetch: он отклоняет промис только при сетевой ошибке — HTTP-статусы 4xx/5xx считаются «успешным» ответом, поэтому проверяют response.ok вручную.


Debounce, throttle, мемоизация

Мемоизация — оптимизационная техника: кэширование результатов функции для одинаковых аргументов, чтобы не вычислять повторно.

Debounce и throttle управляют частотой вызова функции.

Debounce гарантирует, что функция будет вызвана только после того, как пройдёт заданное время с момента последнего вызова (например, поиск по вводу — ждём, пока пользователь перестанет печатать):

function debounce(f, delay){
  var lastTimeout;
  return function(){
    if(lastTimeout){
      clearTimeout(lastTimeout);
    }
    var args = Array.from(arguments);
    lastTimeout = setTimeout(function(){
      f.apply(null, args);
    }, delay);
  }
}

function sacrifice(name){
  console.log(name + " была принесена в жертву *демонический смех*");
}

const sacrificeDebounced = debounce(sacrifice, 500);

sacrificeDebounced("Катя");
sacrificeDebounced("Света");
sacrificeDebounced("Лена"); // сработает только этот вызов, спустя 500мс

Примечание: в исходнике здесь была опечатка function sacrificeDebounced = .... Корректно — const sacrificeDebounced = ... (присваивание результата функции переменной).

Throttle ограничивает количество вызовов функции за определённый промежуток времени (например, обработчик scroll/resize — не чаще раза в N мс):

export default function throttle(func, wait) {
  let shouldThrottle = false
  return function (...args) {
    if(!shouldThrottle){
      func.apply(this, args);
      shouldThrottle = true;
      setTimeout(() => {
        shouldThrottle = false;
      }, wait);
    }
  }
}

Разница «на пальцах»: debounce — «подожди, пока перестанут дёргать, потом сделай один раз»; throttle — «делай, но не чаще, чем раз в N мс».


Модули

По мере роста приложения его разделяют на много файлов — «модули». Исторические модульные системы:

  • AMD — одна из самых старых модульных систем, изначально реализована библиотекой require.js.
  • CommonJS — модульная система, созданная для сервера Node.js (require/module.exports).
  • ES-модули (ESM) — стандарт языка (import/export).

Модуль — это просто файл. Один скрипт — один модуль. Модули могут загружать друг друга и использовать директивы export и import, чтобы обмениваться функциональностью:

  • export отмечает переменные и функции, которые должны быть доступны вне текущего модуля.
  • import позволяет импортировать функциональность из других модулей.

Например, файл sayHi.js экспортирует функцию:

export function sayHi(user) {
  alert(`Hello, ${user}!`);
}

…Тогда другой файл может импортировать её и использовать:

import {sayHi} from './sayHi.js';

alert(sayHi); // function...
sayHi('John'); // Hello, John!

Особенности модулей

В модулях всегда используется режим use strict. Например, присваивание необъявленной переменной вызовет ошибку.

Код в модуле выполняется только один раз при импорте. Если один модуль импортируется в нескольких местах, его код выполнится единожды, результат разделяется между импортёрами:

// 📁 alert.js
alert("Модуль выполнен!");

// 📁 1.js
import './alert.js'; // Модуль выполнен!

// 📁 2.js
import './alert.js'; // (ничего не покажет — модуль уже выполнен)

import.meta содержит информацию о текущем модуле. Содержимое зависит от окружения; в браузере — ссылка на скрипт/страницу:

<script type="module">
  alert(import.meta.url); // ссылка на html страницу для встроенного скрипта
</script>

В модуле this не определён (равен undefined), в отличие от обычных скриптов (где this === window).

Модули всегда выполняются в отложенном (deferred) режиме, как скрипты с атрибутом defer.

Синтаксис import/export

import {sayHi, sayBye} from './say.js';         // именованный импорт
import * as say from './say.js';                 // импорт всего в объект
import {sayHi as hi, sayBye as bye} from './say.js'; // с переименованием
export {sayHi as hi, sayBye as bye};             // экспорт с переименованием
import * as say from './say.js';
say.hi('John'); // Hello, John!
say.bye('John'); // Bye, John!

Реэкспорт (пробросить наружу из другого модуля):

export {login, logout} from './helpers.js';

Динамический импорт

Загрузка модуля во время выполнения (возвращает промис):

let modulePath = prompt("Какой модуль загружать?");

import(modulePath)
  .then(obj => {/* <объект модуля> */})
  .catch(err => {/* <ошибка загрузки, например если нет такого модуля> */});

Загрузка скриптов: async и defer

Скрипт без async или defer:

  • Загрузка: скрипт загружается и выполняется во время парсинга HTML.
  • Выполнение: браузер останавливает рендеринг страницы, пока загружается и выполняется скрипт (блокирует парсинг).
  • Порядок: скрипты выполняются в порядке их появления в документе.

Скрипт с async:

  • Загрузка: асинхронно, параллельно с загрузкой HTML.
  • Выполнение: сразу после загрузки, не дожидаясь завершения парсинга HTML (может прервать парсинг).
  • Порядок: не гарантируется — какой раньше загрузился, тот раньше и выполнится.

Скрипт с defer:

  • Загрузка: асинхронно, параллельно с загрузкой HTML.
  • Выполнение: только после завершения парсинга HTML-документа.
  • Порядок: сохраняется (в порядке появления в документе).

Кратко: async — для независимых скриптов (аналитика), defer — когда важен порядок и полный DOM.


DOM

Document Object Model (DOM) — это программный интерфейс для работы с HTML и XML документами. Он представляет документ в виде дерева объектов, которыми можно управлять из JavaScript.

Структура DOM

  • Узлы (Nodes): каждый элемент документа представлен как узел в дереве. Основные типы узлов:
    • Элемент (Element): узел, представляющий HTML-тег.
    • Текст (Text): узел, содержащий текст внутри элемента.
    • Атрибут (Attribute): узел, представляющий атрибут элемента.
  • Корневой узел: веб-страница начинается с корневого узла, обычно это элемент <html>.

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

Изменения в DOM могут быть затратными по времени. Чтобы улучшить производительность:

  • Минимизируйте количество операций с DOM.
  • Используйте фрагменты документа (DocumentFragment) для пакетного добавления элементов.
  • Избегайте частых обращений к стилям и размерам элементов (это вызывает reflow/repaint).

DocumentFragment — контейнер, который может содержать произвольное количество элементов:

let fragment = document.createDocumentFragment();

Сам фрагмент не является DOM-элементом, он лишь контейнер для DOM-элементов. Когда мы добавляем элемент в DocumentFragment, это не вызывает reflow (перерасчёт макета), потому что фрагмент не находится в «живом» дереве документа. Мы собираем элементы во фрагменте, а затем вставляем весь фрагмент в DOM одной операцией.


События

Класс Event — объект события, который передаётся обработчику.

  • event.target — элемент, на который мы кликнули (или другой источник события), в т.ч. вложенный.
  • event.currentTarget — элемент, на который мы повесили обработчик события.
  • event.isTrusted — реально ли пользователь кликнул, или это сделал скрипт/бот.

Добавление и удаление обработчиков:

element.addEventListener('event', handler);
element.removeEventListener('event', handler);

Фазы события: погружение (capturing) — от корня к цели, и всплытие (bubbling) — от цели к корню. По умолчанию обработчик срабатывает на всплытии; для фазы погружения передают {capture: true}:

element.addEventListener('click', () => {}, {capture: true}); // отлов на фазе погружения

window — корневой (глобальный) объект в браузере. Содержит document, navigator и т.д.

Делегирование событий (дополнение)

Вместо навешивания обработчика на каждый дочерний элемент вешают один на родителя и используют event.target, чтобы понять, по какому потомку кликнули. Это работает благодаря всплытию и экономит память (особенно для динамических списков).


Хранение данных в браузере

Есть 3 основных механизма хранения данных в браузере (+ Cookie):

LocalStorage и SessionStorage используются для хранения пар «ключ-значение». Данные хранятся как строки. localStorage — постоянно (пока не удалят); sessionStorage — только на время вкладки/сессии.

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

IndexedDB — встроенная база данных, более мощная, чем localStorage. Это NoSQL-хранилище, поддерживает большие объёмы, индексы, транзакции, работу с объектами.

// LocalStorage
localStorage.setItem('фрукт', 'апельсин');
console.log(localStorage.getItem('фрукт')); // Выводит: апельсин

// SessionStorage
sessionStorage.setItem('тема', 'dark');
console.log(sessionStorage.getItem('тема')); // Выводит: dark

// Cookie
document.cookie = "username=Вася Пупкин; SameSite=None; Secure";
console.log(document.cookie); // Выводит: username=Вася Пупкин

// IndexedDB
let indexedDB =
  window.indexedDB ||
  window.mozIndexedDB ||
  window.webkitIndexedDB ||
  window.msIndexedDB;

if (!indexedDB) {
  console.log("IndexedDB не поддерживается");
} else {
  let open = indexedDB.open("myDatabase");

  open.onupgradeneeded = function() {
    let db = open.result;
    db.createObjectStore("notes", {keyPath: "id"});
  };
  open.onsuccess = function() {
    console.log("База данных создана");
  };
  open.onerror = function() {
    console.log("Ошибка!");
  };
}

Кратко: localStorage (~5-10 МБ, постоянно), sessionStorage (на сессию), cookie (~4 КБ, шлётся на сервер), IndexedDB (большие структурированные данные).


Shadow DOM

Теневой DOM («Shadow DOM») используется для инкапсуляции: благодаря ему у компонента есть своё скрытое дерево DOM и стили, изолированные от основной страницы.

Многие сложные встроенные элементы браузера устроены на shadow DOM. Например, <input type="range"> — браузер рисует его своими силами, а внутренняя DOM-структура скрыта (в Chrome DevTools её можно увидеть, включив «Show user agent shadow DOM»):

<input type="range">
  #shadow-root (user-agent)
    <div>
      <div pseudo="-webkit-slider-runnable-track" id="track">
        <div id="thumb"></div>
      </div>
    </div>

То, что находится под #shadow-root, и называется shadow DOM.

Свой веб-компонент прячет внутренний DOM в теневом дереве:

<script>
customElements.define('show-hello', class extends HTMLElement {
  connectedCallback() {
    const shadow = this.attachShadow({mode: 'open'});
    shadow.innerHTML = `<p>
      Hello, ${this.getAttribute('name')}
    </p>`;
  }
});
</script>

<show-hello name="John"></show-hello>

В DevTools результат виден так — контент внутри #shadow-root:

<show-hello name="John">
  #shadow-root (open)
    <p>Hello, John</p>
</show-hello>

Свойство mode задаёт уровень инкапсуляции, всего два значения:

  • "open" — корень теневого дерева доступен как elem.shadowRoot; любой код может получить теневое дерево.
  • "closed" — elem.shadowRoot всегда возвращает null; добраться до теневого DOM можно только по ссылке, которую вернул attachShadow (обычно она спрятана в классе). Встроенные браузерные теневые деревья (как у <input type="range">) закрыты.

Virtual DOM

В React для каждого объекта настоящего DOM (RDOM) существует соответствующий объект VDOM — легковесная копия-представление RDOM в памяти. VDOM содержит те же свойства, но не может напрямую влиять на то, что отображается на экране.

Виртуальный DOM (VDOM) — концепция программирования, где идеальное («виртуальное») представление UI хранится в памяти и синхронизируется с «реальным» DOM (этим занимаются библиотеки вроде ReactDOM). Процесс синхронизации называется согласованием (reconciliation).

Манипуляции с RDOM медленные; манипуляции с VDOM намного быстрее, поскольку не отрисовываются на экране (аналогия — работа с проектом здания перед стройкой).

Почему VDOM быстрее. Когда в UI добавляются элементы, создаётся VDOM в виде дерева, каждый элемент — узел. При изменении состояния создаётся новое дерево, которое сравнивается (diffing) со старым. Затем вычисляется наиболее эффективный способ внести изменения в RDOM — цель в минимизации операций с реальным DOM (снижение накладных расходов на обновление).

Пример с setState: при смене состояния (например, isOpen: true → false) сравниваются старое и новое виртуальные деревья; неизменённые узлы остаются, а удаляются/добавляются только отличающиеся (например, узлы section и text). Перестраивается всё виртуальное дерево, но в реальный DOM применяются лишь точечные (атомарные) изменения.


Web Workers

Web Workers предоставляют средство для запуска скриптов в фоновом потоке. Поток воркера может выполнять задачи, не блокируя пользовательский интерфейс (главный поток).

Имеет доступ к: Navigator, XMLHttpRequest, Array, Date, Math, String, setTimeout(), setInterval().

Ограничения: нет доступа к DOM; вместо window — глобальный объект self; нет доступа к cookies/localStorage/sessionStorage; недоступна часть браузерных API (например, камера/микрофон); есть ограничения по ресурсам от браузера.

У Web Workers свой event loop (работает немного иначе, чем в главном потоке). Глобальный контекст воркера — WorkerGlobalScope; он работает асинхронно и выполняет код в ответ на сообщения и события.

Обмен сообщениями между главным потоком и воркером — через postMessage / onmessage.

Главный поток (создание воркера, отправка данных, приём результата):

// index.js
const imageProcessingWorker = new Worker('worker.js');
const imageSelect = document.getElementById('image-select');

imageSelect.addEventListener('change', function(event) {
  const selectedImage = event.target.files[0];
  imageProcessingWorker.postMessage(selectedImage);
});

imageProcessingWorker.onmessage = function(event) {
  const processedImage = event.data;
  const imageContainer = document.getElementById('image-container');
  imageContainer.appendChild(processedImage);
};

Код воркера (worker.js):

self.onmessage = function(event) {
  const image = event.data;
  // Функция, которая производит преобразования с картинкой, например сжатие
  const processedImage = processImage(image);
  self.postMessage(processedImage);
};

Dedicated Worker и Shared Worker

Dedicated Worker — создаёт отдельный, изолированный контекст выполнения, работающий параллельно с основным потоком. Используется для вычислений, обработки данных и долгих задач, не блокирующих основной поток. Доступен только тому скрипту, который его создал.

Shared Worker — создаёт общий контекст выполнения, доступный для нескольких окон, вкладок или фреймов. Обеспечивает общий доступ к данным и состоянию между разными частями приложения. Общение идёт через порты (port).

Страница 1 (отправляет и принимает сообщения через порт):

<!DOCTYPE html>
<html>
  <head><title>Shared Worker 1</title></head>
  <body>
    <div class="message-container"></div>
    <input type="text" class="message-input" />
    <button class="send-message-button">Send</button>
    <script>
      const messageContainer = document.querySelector('.message-container');
      const messageInput = document.querySelector('.message-input');
      const sendMessageButton = document.querySelector('.send-message-button');

      const worker = new SharedWorker('worker.js');
      const port = worker.port;

      sendMessageButton.addEventListener('click', () => {
        const message = messageInput.value;
        port.postMessage(message);
        messageInput.value = '';
      });

      port.onmessage = (e) => {
        messageContainer.innerHTML += e.data + '<br>';
      };
    </script>
  </body>
</html>

Страница 2 (только принимает — данные общие для обеих вкладок):

<!DOCTYPE html>
<html>
  <head><title>Shared Worker 2</title></head>
  <body>
    <div class="message-container"></div>
    <script>
      const messageContainer = document.querySelector('.message-container');

      const worker = new SharedWorker('worker.js');
      const port = worker.port;

      port.onmessage = (e) => {
        messageContainer.innerHTML += e.data + '<br>';
      };
    </script>
  </body>
</html>

Код Shared Worker (worker.js) — рассылает сообщение всем подключённым портам:

const ports = [];

self.onconnect = (event) => {
  // Достаём порт, с которого подключились, и сохраняем его, чтобы потом отправить ему
  const port = event.ports[0];
  ports.push(port);

  port.onmessage = (e) => {
    const message = e.data;
    for (const client of ports) {
      client.postMessage(`Message: ${message}`);
    }
  };
};

WebAssembly

WebAssembly (WASM) — бинарный формат исполняемого кода, созданный для обеспечения высокой производительности в браузере (близкой к нативной). Позволяет запускать код, скомпилированный из C/C++/Rust и др.

Несмотря на высокую производительность, WebAssembly не заменяет JavaScript, а лишь дополняет его (для тяжёлых вычислений: игры, обработка видео/изображений, крипта).

Пример: простейшая программа на C (файл hello.c):

int add(int a, int b)
{
    return a + b;
}

После компиляции в hello.wasm загрузка и вызов из JS:

WebAssembly.instantiateStreaming(fetch("hello.wasm"))
  .then(result =>
    document.getElementById("container").innerHTML =
      "Result: " + result.instance.exports._add(2, 5)
  ).catch(console.error);

Proxy и Reflect

Proxy — объект-обёртка, который перехватывает операции над другим объектом (чтение, запись, удаление свойств, вызов и т.д.) через «ловушки» (traps). Это то, на чём построена реактивность Vue 3, валидаторы, наблюдаемые объекты, моки.

const target = { name: "Вася", age: 30 };

const proxy = new Proxy(target, {
  get(obj, prop) {
    console.log(`read ${prop}`);
    return prop in obj ? obj[prop] : `нет свойства ${prop}`;
  },
  set(obj, prop, value) {
    if (prop === "age" && typeof value !== "number") {
      throw new TypeError("age должен быть числом");   // валидация при записи
    }
    obj[prop] = value;
    return true;   // set обязан вернуть true при успехе
  },
});

proxy.name;        // "read name" → "Вася"
proxy.age = 31;    // ок
proxy.age = "x";   // TypeError

Частые ловушки: get, set, has (оператор in), deleteProperty, apply (вызов функции), construct (new), ownKeys. Применение: реактивность/наблюдение за изменениями, валидация, значения по умолчанию, логирование доступа, «виртуальные» свойства, защита объекта.

Reflect — встроенный объект с методами, повторяющими внутренние операции над объектами (Reflect.get, set, has, deleteProperty, ownKeys, apply, construct). Используется вместе с Proxy — чтобы вызвать «поведение по умолчанию» внутри ловушки корректно (с правильным this/receiver):

const proxy = new Proxy(target, {
  get(obj, prop, receiver) {
    return Reflect.get(obj, prop, receiver);   // поведение по умолчанию + верный receiver
  },
});

Reflect делает код в ловушках чище и правильнее, чем ручной obj[prop] (особенно с геттерами и наследованием). Кратко: Proxy перехватывает операции, Reflect выполняет их «как обычно».


Сборка мусора и утечки памяти

JavaScript управляет памятью автоматически — есть сборщик мусора (garbage collector, GC). Основной принцип современных движков (V8) — достижимость (reachability): объект жив, пока до него можно «дотянуться» по ссылкам от корней (глобальный объект, стек вызовов, замыкания). Как только объект становится недостижим — он кандидат на удаление.

Алгоритм — mark-and-sweep («пометь и подмети»): GC обходит граф от корней, помечает достижимое, остальное освобождает. (Устаревший подход «подсчёт ссылок» не справлялся с циклами; mark-and-sweep справляется.) V8 использует поколенческий GC (молодые/старые объекты) для эффективности.

Утечки памяти — объекты остаются достижимыми, хотя уже не нужны, и GC не может их убрать. Частые причины:

// 1. Забытые таймеры/интервалы — держат ссылки на переменные из замыкания
const timer = setInterval(() => use(bigData), 1000);
// нужно clearInterval(timer), иначе bigData живёт вечно

// 2. Необорванные слушатели событий
element.addEventListener("click", handler);
// при удалении элемента — removeEventListener, иначе утечка

// 3. Замыкания, держащие большие объекты дольше нужного
// 4. Растущие глобальные структуры (кэш без ограничения размера, массивы-логи)
// 5. Ссылки на удалённые DOM-узлы, хранящиеся в JS

Как избегать: снимать слушатели и таймеры при уничтожении (cleanup), не хранить лишние глобальные ссылки, ограничивать кэши (LRU), обнулять ссылки (obj = null) когда объект больше не нужен.

WeakMap / WeakSet — держат объекты по слабой ссылке: если на объект-ключ больше нет других ссылок, он может быть собран GC вместе с записью. Идеально для метаданных/кэша, привязанных к объектам, без риска утечки (обычный Map держал бы объект «сильной» ссылкой и мешал бы сборке).

Поиск утечек: вкладка Memory в DevTools — heap snapshots (сравнить два снимка, найти растущие объекты), Allocation timeline; в Node — --inspect + Chrome DevTools, process.memoryUsage().


Обработка ошибок

try / catch / finally — перехват синхронных ошибок и ошибок в await:

try {
  const data = await loadData();     // ловит и reject промиса (при await)
  process(data);
} catch (err) {
  logger.error(err.message);
  // можно пробросить дальше: throw err;
} finally {
  cleanup();   // выполнится всегда — и при успехе, и при ошибке
}

Важно: try/catch не ловит ошибки в асинхронных колбэках без await (например, внутри setTimeout или в необёрнутом .then) — они уходят мимо. Для промисов без await — .catch().

throw — бросить можно что угодно, но правильно — объект Error (у него есть message, name, stack):

throw new Error("Что-то пошло не так");

Кастомные классы ошибок — наследуют Error, позволяют различать типы в catch и нести доп. данные:

class ValidationError extends Error {
  constructor(message, field) {
    super(message);
    this.name = "ValidationError";   // важно для идентификации
    this.field = field;
  }
}

try {
  throw new ValidationError("Email некорректен", "email");
} catch (err) {
  if (err instanceof ValidationError) {
    console.log(err.field);          // "email" — обрабатываем по-своему
  } else {
    throw err;                       // чужие ошибки пробрасываем
  }
}

Промисы: ошибки ловятся .catch(); в цепочке один .catch в конце ловит ошибку из любого предыдущего .then (аналог try/catch для цепочки).

Глобальные обработчики (последняя линия — логирование, не штатная обработка):

// Браузер
window.addEventListener("error", (e) => log(e.error));
window.addEventListener("unhandledrejection", (e) => log(e.reason)); // необработанный промис

// Node.js
process.on("uncaughtException", (err) => { log(err); process.exit(1); });
process.on("unhandledRejection", (reason) => log(reason));

Практика: не «глотать» ошибки пустым catch {}; бросать/ловить специфичные типы; чужие ошибки пробрасывать; всегда логировать; необработанный unhandledrejection — частый баг при забытом await/.catch.


Регулярные выражения

Регулярные выражения (regex) — это паттерны для поиска и замены текста.

Основные методы:

  • test() — проверка на соответствие шаблону.
  • match() — поиск соответствий.
  • replace() — замена по шаблону.
  • search() — поиск индекса.

Регулярные выражения могут иметь флаги, влияющие на поиск. В JavaScript их семь, основные:

  • i — поиск не зависит от регистра (нет разницы между A и a).
  • g — поиск ищет все совпадения, без него — только первое.
  • (также: m — многострочный, s — точка соответствует переводу строки, u — юникод, y — «липкий», d — индексы совпадений).
"Hello World".match(/o/g);          // ['o', 'o']
/hello/i.test("HELLO");             // true
"a1b2".replace(/\d/g, "#");         // "a#b#"

Вероятные вопросы

Сколько примитивных типов в JS и какие? Семь: Number, String, Boolean, Null, Undefined, BigInt, Symbol. Плюс Object (не примитив).

Почему typeof null === "object"? Историческая ошибка (баг) языка; null не является объектом.

Чем null отличается от undefined? null — намеренное «пусто» (задаёт разработчик); undefined — «значения нет» (неинициализированная переменная, отсутствующее свойство, функция без return).

== vs ===? === — без приведения типов; == — с приведением. Рекомендуется ===.

Как сравниваются объекты и примитивы? Примитивы — по значению; объекты — по ссылке.

Что такое hoisting? Поднятие объявлений в начало области видимости. var инициализируется undefined; function declaration поднимается целиком; let/const — в TDZ (ошибка при обращении до объявления).

Отличия var, let, const? var — функциональная область, hoisting с undefined, можно переобъявлять. let — блочная область, TDZ, нельзя переобъявлять. const — как let, но без переприсваивания.

Что такое замыкание? Функция, сохраняющая доступ к переменным внешней области, даже после завершения внешней функции (за счёт ссылки на внешнее лексическое окружение).

Как определяется this? По способу вызова: как функция → global/undefined (strict); как метод → объект перед точкой; с new → новый объект; через call/apply/bind → заданный. У стрелочных this берётся из места объявления.

Разница call, apply, bind? call — аргументы через запятую, вызывает сразу; apply — аргументы массивом, вызывает сразу; bind — возвращает новую функцию с зафиксированным this.

Чем стрелочная функция отличается от обычной? Нет своего this (берётся из родителя), нет arguments, нельзя new, нет prototype, нет hoisting.

Что такое прототипное наследование? Поиск свойств/методов по цепочке [[Prototype]]: если нет в объекте — ищем в прототипе и дальше.

Микротаски vs макротаски? Микротаски (промисы, queueMicrotask) выполняются полностью перед следующей макротаской (setTimeout, события). Порядок: синхронный код → все микротаски → одна макротаска → рендер → повтор.

Что выведет setTimeout(…,0) vs Promise.then? Сначала промис (микротаска), потом setTimeout (макротаска).

Разница Promise.all / allSettled / race / any? all — ждёт все, падает при первой ошибке; allSettled — ждёт все, отдаёт статусы; race — первый завершившийся (успех/ошибка); any — первый успешный.

Что делает async? Функция всегда возвращает промис; await внутри ждёт результат промиса; ошибки ловят try/catch.

Чем Map отличается от объекта? У Map ключи любого типа (в т.ч. объекты), сохраняется порядок, есть size, удобная итерация. Weak-версии не мешают сборке мусора.

Spread vs rest? Один синтаксис ...: spread разворачивает (в вызове/литерале), rest собирает (в параметрах/деструктуризации).

Как работает Virtual DOM? Лёгкая копия DOM в памяти; при изменении создаётся новое дерево, сравнивается со старым (diffing), в реальный DOM вносятся только минимальные изменения.

Что такое Shadow DOM? Инкапсулированное скрытое DOM-дерево и стили компонента (open/closed), изолированные от страницы.

Зачем Web Worker? Выполнять тяжёлые задачи в фоновом потоке, не блокируя UI. Нет доступа к DOM; общение через postMessage.

localStorage vs sessionStorage vs cookie? localStorage — постоянно (~5-10МБ); sessionStorage — на вкладку; cookie (~4КБ) — шлётся на сервер с каждым запросом.

async vs defer у скриптов? Оба грузятся параллельно с HTML; async выполняется сразу по загрузке (порядок не гарантирован), defer — после парсинга HTML (порядок сохраняется).

Debounce vs throttle? Debounce — вызов после паузы в дёрганьях; throttle — не чаще раза в N мс.

Что такое IIFE и зачем? Немедленно вызываемая функция; изолирует переменные от глобальной области.

Функции — объекты первого класса. Что это? Их можно присваивать, передавать в аргументы, возвращать, хранить в структурах — как обычные значения.

Что такое генератор? Функция function* с yield, отдающая значения лениво; возвращает итератор, next() продвигает выполнение.

Что такое Proxy и зачем? Обёртка, перехватывающая операции над объектом (get/set/has/delete/apply) через ловушки. Основа реактивности Vue 3, валидации, наблюдения, моков.

Что такое Reflect и как связан с Proxy? Объект с методами внутренних операций (Reflect.get/set/...); в ловушках Proxy вызывает поведение «по умолчанию» с правильным receiver. Proxy перехватывает — Reflect выполняет.

Как работает сборка мусора в JS? По достижимости (reachability) от корней; алгоритм mark-and-sweep; недостижимое освобождается. Подсчёт ссылок не справлялся с циклами.

Частые причины утечек памяти? Забытые таймеры/интервалы, необорванные слушатели событий, растущие глобальные кэши, замыкания с большими объектами, ссылки на удалённые DOM-узлы. Решение — cleanup, ограничение кэшей, WeakMap.

Зачем WeakMap для памяти? Держит ключи-объекты слабой ссылкой — не мешает сборке мусора; удобно для метаданных/кэша, привязанных к объектам.

Ловит ли try/catch асинхронные ошибки? Синхронные и ошибки в await — да; ошибки в колбэках без await (setTimeout, необёрнутый .then) — нет. Для промисов — .catch(); глобально — unhandledrejection.

Как сделать свой тип ошибки? Класс extends Error с this.name (и доп. полями); в catch различать через instanceof, чужие — пробрасывать.