JavaScript
Материал для подготовки к собеседованию (Middle / Senior). На основе исходного конспекта; примеры кода перенесены из скриншотов исходного документа в текст (по правилу проекта картинки не вставляем). Материал переупорядочен по логическим блокам, дополнен и местами исправлен.
Содержание
- Типы данных
- Символы (Symbol)
- Объектные обёртки
- Объекты, сравнение и копирование
- Дескрипторы свойств, freeze и seal
- Переменные и области видимости
- Hoisting (поднятие)
- use strict
- Лексическое окружение и замыкания
- Контекст выполнения и this
- call, apply, bind
- Функции
- Стрелочные функции vs обычные
- Генераторы
- Прототипное наследование
- Классы
- Map, Set, WeakMap, WeakSet
- Деструктуризация
- Spread и rest
- Нововведения ES6
- Event Loop
- Промисы
- async / await
- AJAX и Fetch API
- Debounce, throttle, мемоизация
- Модули
- Загрузка скриптов: async и defer
- DOM
- События
- Хранение данных в браузере
- Shadow DOM
- Virtual DOM
- Web Workers
- WebAssembly
- Proxy и Reflect
- Сборка мусора и утечки памяти
- Обработка ошибок
- Регулярные выражения
- Вероятные вопросы
Типы данных
Примитивные типы: 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) — это объекты, которые предоставляют обёртку вокруг примитивных значений и дают методы/свойства для работы с ними:
- Number — обёртка для примитивного типа number.
- String — обёртка для примитивного типа string.
- 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 — это механизм, при котором объявления переменных и функций «поднимаются» в начало своей области видимости на этапе компиляции.
- Объявления переменных. Для
varподнимается только сама переменная (без значения):
console.log(x); // undefined
var x = 5;
console.log(x); // 5
- Объявления функций. Функции-объявления (function declaration) поднимаются целиком — их можно вызвать до объявления:
sayHello(); // "Hello!"
function sayHello() {
console.log("Hello!");
}
- Стрелочные функции и 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 «разворачивает» (распространяет) элементы массива/объекта.
- Разворачивание массива:
const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
const combined = [...arr1, ...arr2]; // [1, 2, 3, 4, 5, 6]
- Передача аргументов в функцию:
function sum(x, y, z) {
return x + y + z;
}
const numbers = [1, 2, 3];
console.log(sum(...numbers)); // 6
- Копирование/расширение объекта:
const obj1 = { a: 1, b: 2 };
const obj2 = { ...obj1, c: 3 }; // { a: 1, b: 2, c: 3 }
Rest собирает оставшиеся элементы/аргументы в массив.
- Сбор аргументов в массив:
function collect(...args) {
console.log(args); // Массив всех переданных аргументов
}
collect(1, 2, 3); // [1, 2, 3]
- Комбинирование с другими параметрами:
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:
- Сначала Event Loop проверяет, выполнились ли все синхронные задачи (очистить стек вызовов).
- Потом выполняются все задачи из микротасков.
- После выполнения всех микротасков очередь очищается.
- Затем берётся одна макрозадача из списка и выполняется.
- После выполнения проверяется, нужна ли перерисовка страницы.
- Если нужна — делается перерисовка (render).
- Всё снова начинается с первого пункта.
Классический пример на порядок вывода:
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, чужие — пробрасывать.