JavaScript: популярные вопросы на собеседовании

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

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

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

В JavaScript существуют два основных типа данных: примитивные (например, Number, String, Boolean, Undefined, Null, Symbol) и объектные (например, Object, Array, Function, Date, RegExp), где примитивы представляют собой неизменяемые значения, а объекты могут содержать сложные структуры и изменяться.

var, let и const различаются по области видимости и возможности переназначения: var имеет функциональную область видимости и позволяет переназначение, let и const имеют блочную область видимости, при этом let позволяет переназначение, а const — нет.

В JavaScript ложные значения (falsy) включают false, 0, -0, 0n, "", null, undefined и NaN, которые интерпретируются как false в логических операциях и условных конструкциях.

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

Поднятие — это поведение JavaScript, при котором объявления переменных и функций перемещаются в верхнюю часть их области видимости, позволяя использовать их до фактического объявления в коде. Переменные, объявленные с помощью var, поднимаются и инициализируются как undefined, тогда как переменные, созданные с let и const, поднимаются, но не инициализируются, что может привести к ошибкам.

null указывает на явное отсутствие значения, тогда как undefined означает, что переменная объявлена, но не инициализирована. Они имеют разные применения и типы данных: typeof null возвращает "object", а typeof undefined - "undefined".

NaN (Not a Number) — это специальное значение в JavaScript, обозначающее недопустимый или неопределённый числовой результат, при этом его тип — number; NaN не равно самому себе, поэтому для проверки его наличия используется функция isNaN().

В JavaScript тип переменной можно определить с помощью оператора typeof, который возвращает строку с типом, а также с помощью instanceof для проверки экземпляров, метода Array.isArray для массивов и Object.prototype.toString для более точного определения типов объектов.

В JavaScript строки можно преобразовать в числа с помощью методов Number(), parseInt(), parseFloat() и унарного оператора +, каждый из которых имеет свои особенности: Number() подходит для любых чисел, parseInt() — для целых, parseFloat() — для дробных, а + — для быстрого преобразования.

В JavaScript числа можно преобразовать в строки с помощью методов String(), toString(), конкатенации со строкой или шаблонных строк. Каждый метод имеет свои особенности, и выбор зависит от контекста, например, String() подходит для явного преобразования, а шаблонные строки удобны для создания строк с переменными.

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

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

JSON — это легкий текстовый формат обмена данными, основанный на JavaScript, который используется для передачи и хранения данных между клиентом и сервером в веб-приложениях благодаря своей простоте и читаемости.

Конвертация объекта JavaScript в JSON-строку осуществляется с помощью метода JSON.stringify(), который преобразует объект в строку формата JSON, игнорируя несериализуемые значения, такие как функции и undefined. Этот процесс особенно полезен для передачи данных между клиентом и сервером, а также для их хранения в текстовом формате.

Для преобразования JSON-строки в объект JavaScript используется метод JSON.parse(), который принимает корректно сформированную строку в формате JSON и возвращает соответствующий объект. Важно проверять формат данных и обрабатывать возможные ошибки с помощью конструкции try...catch.

Документная Объектная Модель (DOM) представляет структуру HTML и XML документов в виде иерархического дерева, позволяя разработчикам взаимодействовать и изменять содержимое страниц в реальном времени с помощью JavaScript.

Для получения элемента на странице по его id в JavaScript используется метод getElementById, который возвращает объект элемента, если он найден, или null, если нет. Этот метод эффективен и надежен благодаря уникальности id в HTML-документе.

document.getElementById используется для получения элемента по уникальному идентификатору id, тогда как document.querySelector позволяет выбирать элементы с использованием CSS-селекторов, что делает его более гибким, но чуть менее производительным.

Объект в JavaScript — это коллекция свойств, состоящих из ключей и значений, что позволяет организовывать данные и методы. Существует несколько способов создания объектов: литералы, функции-конструкторы и метод Object.create(), каждый из которых подходит для различных сценариев использования. Объекты являются основным типом данных и играют ключевую роль в разработке приложений.

Свойство innerHTML позволяет работать с HTML-содержимым элемента, интерпретируя теги, тогда как textContent возвращает только текст, игнорируя HTML, что делает его более безопасным и производительным для работы с текстом.

Для добавления CSS-класса к элементу в JavaScript используется объект classList, который предлагает методы add(), remove(), toggle() и contains(), обеспечивая удобное и безопасное управление классами без риска дублирования.

Удаление CSS-класса у элемента в JavaScript осуществляется с помощью метода classList.remove(), который позволяет удобно управлять классами, в то время как использование свойства className менее безопасно и может привести к ошибкам.

Назначение обработчика события в JavaScript позволяет реагировать на действия пользователя, такие как нажатия кнопок. Это делается с помощью метода addEventListener, который связывает функцию-обработчик с определённым событием, обеспечивая гибкость и возможность назначения нескольких обработчиков.

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

Фаза захвата в JavaScript — это этап обработки событий, когда событие проходит сверху вниз по дереву DOM от корневого элемента к целевому, позволяя перехватить его до обработки на самом элементе. Использование этой фазы позволяет управлять поведением событий и предотвращать нежелательные действия.

Метод event.preventDefault() в JavaScript используется для предотвращения стандартного поведения браузера при срабатывании событий, позволяя разработчикам управлять действиями элементов, такими как отправка форм или переход по ссылкам, и создавать более интерактивные интерфейсы.

Обработка исключений в JavaScript позволяет управлять ошибками и повышать стабильность приложений с помощью конструкций try...catch, finally и throw, что помогает выявлять и обрабатывать ошибки, а также освобождать ресурсы.

Строгий режим в JavaScript улучшает качество кода, предотвращая ошибки и запрещая потенциально опасные действия, такие как использование необъявленных переменных. Его можно включить, добавив строку "use strict"; в начале файла или функции.

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

Promise в JavaScript — это объект для работы с асинхронными операциями, который позволяет избежать сложных вложенных коллбэков и делает код более понятным. Он может находиться в трех состояниях: ожидает, исполнен или отклонен, и предоставляет методы then и catch для обработки результатов.

Async/await — это синтаксический сахар в JavaScript для упрощения работы с асинхронным кодом, основанный на промисах, который улучшает читаемость и структуру кода, позволяя использовать более линейный стиль и удобную обработку ошибок с помощью try/catch.

Синхронный код выполняется последовательно и может блокировать выполнение, в то время как асинхронный код позволяет выполнять операции параллельно, не останавливая основной поток, что повышает отзывчивость приложения.

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

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

ES6 ввёл множество новых возможностей в JavaScript, включая блочную область видимости с let и const, стрелочные функции, шаблонные строки, деструктуризацию, параметры по умолчанию, поддержку модулей и промисы, что значительно улучшает читаемость и структуру кода.

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

Function Declaration — это объявление функции с подъемом, позволяющее вызывать её до определения, тогда как Function Expression создаёт функцию как часть выражения, не позволяя вызывать её до определения и поддерживая анонимные функции.

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

Объект arguments в JavaScript представляет собой массивоподобный объект, доступный внутри функций, который содержит все переданные в них аргументы и позволяет работать с переменным числом аргументов. Хотя он позволяет динамически обрабатывать аргументы, с введением остаточных параметров его использование стало менее актуальным.

В JavaScript примитивные типы данных передаются по значению, создавая копию, тогда как ссылочные типы передаются по ссылке, что позволяет изменять оригинальные объекты.

Обращение к несуществующей переменной в JavaScript приводит к ошибке ReferenceError. Чтобы избежать этого, всегда следует объявлять переменные с помощью var, let или const и использовать строгий режим.

Оператор typeof для массива возвращает строку "object", так как массивы в JavaScript являются подтипом объектов; для точной проверки, является ли переменная массивом, рекомендуется использовать метод Array.isArray().

Метод Array.map() в JavaScript используется для трансформации элементов массива, создавая новый массив на основе результатов выполнения заданной функции для каждого элемента, при этом оригинальный массив остается неизменным.

Метод Array.filter() в JavaScript создает новый массив, содержащий элементы исходного массива, которые соответствуют заданному условию, и не изменяет оригинальный массив. Он используется для фильтрации данных с помощью функции обратного вызова, которая определяет, какие элементы включать в результат.

Метод Array.reduce() в JavaScript используется для преобразования массива в одно значение, применяя коллбек-функцию к каждому элементу и аккумулируя результат. Он позволяет выполнять различные операции, такие как суммирование, создание объектов и фильтрацию уникальных значений, и требует указания начального значения для корректной работы.

Метод Array.forEach() в JavaScript выполняет заданную функцию для каждого элемента массива, позволяя удобно итерировать и обрабатывать данные. Он не возвращает значения и не подходит для асинхронных операций, но позволяет писать более чистый и лаконичный код.

Array.forEach() используется для выполнения действий над элементами массива без возвращения нового массива, тогда как Array.map() преобразует элементы и возвращает новый массив с результатами.

Для удаления пробелов в начале и конце строки в JavaScript можно использовать метод trim(), который является простым и эффективным способом, или регулярные выражения для более гибкой обработки строк.

В JavaScript для проверки наличия подстроки в строке можно использовать метод includes(), который возвращает true или false, метод indexOf(), который возвращает индекс подстроки или -1, и регулярные выражения для более сложных условий поиска.

Метод split() в JavaScript позволяет разделить строку на массив подстрок по указанному разделителю, будь то символ или регулярное выражение. Этот метод полезен для обработки данных, поскольку он может эффективно разбивать строки на части, учитывая различные сценарии, такие как наличие пустых элементов или ограничение количества возвращаемых элементов.

Метод join() в JavaScript объединяет элементы массива в строку с указанным разделителем, по умолчанию — запятой. Он упрощает код и позволяет контролировать форматирование результата, не изменяя исходный массив.

В JavaScript округление числа до ближайшего целого можно выполнить с помощью функций Math.round(), Math.floor() и Math.ceil(), каждая из которых имеет свои особенности: Math.round() округляет до ближайшего целого, Math.floor() всегда округляет вниз, а Math.ceil() — вверх.

Math.floor() округляет число вниз до ближайшего меньшего целого, а Math.ceil() — вверх до ближайшего большего целого; их выбор зависит от необходимости избавиться от дробной части или гарантировать целочисленный результат при вычислениях.

В JavaScript для получения случайного числа используется функция Math.random(), которая возвращает значение от 0 до 1. Для генерации случайных чисел в заданном диапазоне можно масштабировать результат, а для целых чисел применять Math.floor() или Math.ceil().

Для проверки, является ли значение конечным числом в JavaScript, лучше всего использовать метод Number.isFinite(), который не выполняет преобразование типов и возвращает true только для конечных чисел, исключая NaN, Infinity и строки.

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

Метод fetch в JavaScript используется для выполнения асинхронных сетевых запросов к удалённым ресурсам, таким как API, и основан на промисах, что упрощает обработку результатов. Он поддерживает все основные HTTP-методы и позволяет легко настраивать запросы с помощью параметров.

AJAX — это технология, позволяющая веб-приложениям асинхронно обмениваться данными с сервером, что улучшает пользовательский опыт за счет динамического обновления контента без перезагрузки страницы. Главным компонентом является объект XMLHttpRequest, который отправляет запросы и обрабатывает ответы, поддерживая различные форматы данных, такие как JSON.

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

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

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

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

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

Promise в JavaScript может находиться в трех состояниях: "ожидание" (Pending), когда операция еще не завершена, "исполнено" (Fulfilled), когда операция завершилась успешно, и "отклонено" (Rejected), когда произошла ошибка. Эти состояния позволяют эффективно управлять асинхронными операциями и обрабатывать ошибки.

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

"Ад колбеков" — это ситуация с глубокой вложенностью колбеков, делающая код трудночитаемым и сложным для отладки. Чтобы избежать этого, рекомендуется использовать промисы или синтаксис async/await, что улучшает читаемость и управление ошибками.

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

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

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

Создание объекта без прототипа в JavaScript возможно с помощью Object.create(null) или new Object(null), что позволяет создать "чистый" объект без унаследованных свойств и методов, что полезно для хранения данных, но требует осторожности в использовании стандартных методов.

Для проверки наличия свойства в объекте в JavaScript можно использовать оператор in, метод hasOwnProperty(), доступ к свойству напрямую или метод Object.keys(). Каждый из этих методов имеет свои особенности: in проверяет свойства в цепочке прототипов, hasOwnProperty() — только собственные свойства, а доступ через !== определяет, установлено ли значение.

Сравнение двух объектов в JavaScript возвращает false, поскольку объекты сравниваются по ссылке, а не по значению, и даже идентичные по содержимому объекты находятся по разным адресам в памяти.

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

Модули CommonJS используются в основном в серверной среде, предоставляя синхронную загрузку и экспорт с помощью require() и module.exports, в то время как ES6 модули предназначены для браузеров, поддерживают асинхронную загрузку и используют ключевые слова import и export, что делает их более современными и удобными для фронтенд-разработки.

Клонирование объектов в JavaScript может быть выполнено как поверхностно с помощью Object.assign() или оператора расширения, так и глубоко с использованием JSON.parse() и JSON.stringify(), а также сторонних библиотек, таких как Lodash для сложных структур; выбор метода зависит от требований к глубине клонирования и содержимому объекта.

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

Rest-параметр в JavaScript позволяет функциям принимать неопределенное количество аргументов в виде массива, что делает код более гибким и удобным. Он обозначается многоточием перед именем параметра и может быть только одним в функции, находясь в конце списка параметров.

Spread-оператор в JavaScript (три точки ...) позволяет разворачивать и копировать итерируемые объекты, упрощая операции с массивами и объектами, такие как копирование, слияние и передача аргументов в функции, при этом обеспечивая иммутабельность данных.

WeakMap — это структура данных для хранения пар "ключ-значение", где ключами могут быть только объекты, а значения могут быть любого типа; ключи имеют слабые ссылки, что позволяет сборщику мусора автоматически удалять их, если на них нет других ссылок, что помогает избежать утечек памяти.

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

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

IIFE (Immediately Invoked Function Expression) — это функция, которая выполняется сразу после определения, что позволяет создать локальную область видимости и избежать загрязнения глобального пространства имен. Она используется для изоляции переменных, создания модулей и инициализации кода, особенно в старых браузерах, где нет поддержки ES6.

event.preventDefault() предотвращает стандартное поведение элемента, например, отправку формы, в то время как event.stopPropagation() останавливает дальнейшее распространение события вверх по иерархии DOM, предотвращая его обработку родительскими элементами.

Debounce и throttle – это техники оптимизации выполнения функций в JavaScript, которые помогают контролировать частоту их вызова. Debounce откладывает выполнение функции до тех пор, пока не прекратится ввод, а throttle позволяет вызывать функцию с фиксированным интервалом, даже если событие продолжается.

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

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

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

Цикл for...in используется для перебора свойств объектов, включая унаследованные, тогда как for...of предназначен для работы с значениями итерируемых объектов, таких как массивы, и не затрагивает унаследованные свойства.

Стрелочные функции в JavaScript не могут использоваться как конструкторы, так как они не создают собственного контекста this и при попытке использования с оператором new возникают ошибки. Для создания объектов следует использовать обычные функции или классы.

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

Обработка ошибок в асинхронном JavaScript осуществляется с помощью методов .catch() для Promise и блоков try/catch для async/await, что позволяет эффективно управлять возможными исключениями и улучшать стабильность приложения.

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

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

Оператор typeof возвращает строку, описывающую тип переменной, и подходит для проверки примитивов, тогда как instanceof проверяет, является ли объект экземпляром определённого класса или конструктора, возвращая логическое значение.

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

Map в JavaScript позволяет использовать ключи любого типа, сохраняет порядок вставки элементов и предоставляет удобные методы для работы с данными, что делает его более гибким и интуитивным по сравнению с обычными объектами.

Использование eval() в JavaScript считается плохой практикой из-за рисков безопасности, снижения производительности и трудностей в поддерживаемости кода; лучше избегать его и использовать альтернативные подходы, такие как функции и объекты для динамического выполнения кода.

Для параллельного выполнения нескольких промисов в JavaScript используется метод Promise.all(), который принимает массив промисов и возвращает новый промис, разрешающийся, когда все исходные промисы успешно завершены. Если хотя бы один промис отклоняется, возвращается ошибка первого из них. Альтернативами являются Promise.allSettled() и Promise.race(), которые обеспечивают различные подходы...

Promise.all ожидает выполнения всех Promise и возвращает массив их результатов, отклоняясь при ошибке хотя бы одного, тогда как Promise.race возвращает результат первого завершившегося Promise, независимо от его состояния, что полезно в ситуациях, когда важна скорость выполнения.

Метод Promise.finally() выполняет указанный код после завершения промиса, независимо от его результата, что позволяет избежать дублирования кода в блоках then и catch, и удобно использовать для выполнения завершающих действий, таких как очистка ресурсов или сброс состояния интерфейса.

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

Свойство event.target указывает на элемент, который фактически вызвал событие, тогда как event.currentTarget указывает на элемент, который обрабатывает это событие. Это различие важно для корректной обработки событий, особенно при использовании делегирования.

Операторы break и continue в JavaScript управляют выполнением циклов: break завершает цикл, а continue пропускает текущую итерацию и переходит к следующей, что позволяет оптимизировать и упрощать логику кода.

Событие DOMContentLoaded срабатывает, когда структура HTML документа полностью загружена и готова к манипуляциям, в то время как событие load срабатывает только после полной загрузки всех ресурсов страницы, включая изображения и стили.

Изменение прототипов встроенных объектов в JavaScript может привести к проблемам с производительностью, совместимостью и читаемостью кода, поэтому лучше использовать альтернативные подходы, такие как создание утилитарных функций или использование классов для расширения функциональности.

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

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

parseInt() преобразует строку в целое число, игнорируя десятичные знаки, в то время как parseFloat() возвращает число с плавающей точкой, учитывая дробную часть.

isNaN() - это глобальная функция, которая проверяет на NaN с неявным приведением типов, тогда как Number.isNaN() - это метод объекта Number, который строго проверяет, является ли значение именно NaN, без приведения типов, что делает его более надежным.

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

Промисы и async/await предпочтительнее колбеков, так как они улучшают читаемость и структуру кода, упрощают обработку ошибок и позволяют легче управлять сложными асинхронными операциями.

XMLHttpRequest и fetch — это способы выполнения HTTP-запросов в JavaScript, при этом fetch предлагает более современный и лаконичный синтаксис с поддержкой промисов, упрощённой обработкой ошибок и потоковой передачей данных, что делает его предпочтительным выбором для разработки современных веб-приложений.

CORS (Cross-Origin Resource Sharing) — это механизм, обеспечивающий безопасность веб-приложений, позволяющий контролировать доступ к ресурсам между разными доменами, предотвращая атаки, такие как XSS. Он работает через HTTP-заголовки, которые указывают, какие домены могут обращаться к данным, и какие методы разрешены.

Чтобы преобразовать NodeList в массив, можно использовать методы Array.from(), оператор расширения (...) или Array.prototype.slice.call(), так как NodeList не поддерживает массивные методы. Эти способы позволяют легко работать с элементами, полученными, например, через document.querySelectorAll().

Оператор typeof в JavaScript возвращает строку "function" для функций, что позволяет проверять тип переменной перед вызовом и упрощает отладку кода.

Опциональная цепочка (?.) в JavaScript позволяет безопасно обращаться к свойствам вложенных объектов, предотвращая ошибки при наличии null или undefined, что упрощает код и улучшает его читаемость.

Оператор ?? (нулевое слияние) в JavaScript используется для задания значения по умолчанию, когда переменная равна null или undefined, что позволяет избежать проблем, связанных с другими ложными значениями, такими как 0 или пустая строка.

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

Утечка памяти в JavaScript возникает, когда неосвобожденные ссылки на объекты мешают сборщику мусора удалять их, что ухудшает производительность приложения. Основные причины включают глобальные переменные, замыкания и неосвобожденные обработчики событий, а для предотвращения утечек рекомендуется использовать локальные переменные, удалять события и применять WeakMap или WeakSet.

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

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

В JavaScript свойства объектов можно сделать неперечисляемыми с помощью метода Object.defineProperty(), установив атрибут enumerable в false, что позволяет контролировать их видимость в циклах и методах, таких как Object.keys().

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

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

Чтобы сделать объект итерируемым в JavaScript, необходимо реализовать метод Symbol.iterator, который возвращает итератор с методом next(), позволяющим перебор значений, что упрощает использование объекта в циклах и других конструкциях, работающих с итерациями.

Сложение 0.1 и 0.2 в JavaScript не равно 0.3 из-за особенностей представления чисел с плавающей запятой в формате IEEE 754, что приводит к ошибкам округления. Чтобы избежать таких проблем, лучше использовать целые числа или методы округления, а также учитывать допуск при сравнении.

Значение undefined указывает на то, что переменная объявлена, но не инициализирована, тогда как ошибка "is not defined" возникает, когда вы пытаетесь обратиться к несуществующей переменной.

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

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

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

const предотвращает переопределение переменной, но не ограничивает изменения свойств объекта, в то время как Object.freeze() делает объект полностью неизменяемым, не позволяя изменять, добавлять или удалять свойства.

Генераторная функция в JavaScript, определяемая с помощью function*, позволяет приостанавливать и возобновлять выполнение через оператор yield, возвращая значения поэтапно. Это создает итераторы, которые полезны для работы с асинхронными операциями и последовательностями данных.

Функция, объявленная с async, всегда возвращает промис, который оборачивает возвращаемое значение или отклоняется при ошибке, что упрощает работу с асинхронным кодом в JavaScript.

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

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

XSS-атака — это уязвимость, позволяющая злоумышленникам внедрять вредоносные скрипты на веб-страницы, что может привести к краже данных пользователей. Защита от XSS включает очистку и валидацию пользовательского ввода, использование Content Security Policy и флагов для куки, а также применение современных фреймворков с встроенными механизмами защиты.

Атрибуты async и defer в теге <script> позволяют оптимизировать загрузку JavaScript-кода: async загружает и выполняет скрипты параллельно с рендерингом, без гарантии порядка, а defer загружает их в фоне и выполняет только после полной загрузки документа, сохраняя порядок выполнения.

Метод event.stopPropagation() предотвращает распространение события вверх по иерархии DOM, позволяя выполнять другие обработчики на текущем элементе, в то время как event.stopImmediatePropagation() останавливает как распространение, так и выполнение всех остальных обработчиков на текущем элементе.

setTimeout(func, 0) позволяет отложить выполнение функции до следующего цикла событий, что помогает разделить тяжелые задачи и обеспечивает асинхронность, улучшая отзывчивость приложения и предотвращая блокировку основного потока.

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

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

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

Глобальный объект в браузере называется window и предоставляет доступ к API для работы с DOM и BOM, тогда как в Node.js он называется global и используется для работы с серверными модулями и функциями, не имея доступа к DOM.

Метод Promise.allSettled() позволяет обрабатывать результаты нескольких промисов одновременно, возвращая массив с их статусами и значениями, независимо от того, завершились ли они успешно или с ошибкой. Это полезно для асинхронных операций, когда нужно получить результаты всех запросов, даже если некоторые из них провалились.

При вызове функции-конструктора с использованием new, если она явно возвращает объект, этот объект будет возвращён вместо автоматически созданного, а если возвращается примитив, то вернётся созданный объект.

В строгом режиме значение this при вызове функции без контекста равно undefined, тогда как в нестрогом режиме оно ссылается на глобальный объект, например, window в браузере. Понимание этого различия помогает избежать ошибок и делает код более предсказуемым.

Нестрогое сравнение в JavaScript (оператор ==) приводит операнды к одному типу перед сравнением, что может привести к неожиданным результатам, поэтому рекомендуется использовать строгое сравнение (===) для повышения предсказуемости и читаемости кода.

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

Object.seal() предотвращает добавление и удаление свойств объекта, но позволяет изменять их значения, в то время как Object.freeze() полностью блокирует любые изменения, включая модификацию существующих значений.

Temporal Dead Zone (TDZ) — это область в JavaScript, где нельзя обратиться к переменным, объявленным с помощью let и const, до их инициализации, что предотвращает ошибки, связанные с поднятием переменных.

В JavaScript объекты преобразуются к примитивным значениям через метод toPrimitive, который в зависимости от контекста вызывает методы valueOf и toString для получения соответствующего значения. Это позволяет управлять представлением объектов в различных ситуациях, таких как арифметические операции или конкатенация строк.

Использование объектов в качестве ключей в обычных объектах JavaScript приводит к их преобразованию в строку "[object Object]", что делает ключи неуникальными. Для сохранения уникальности ключей следует использовать структуру данных Map, которая поддерживает объекты в качестве уникальных ключей.

Выражение [] == ![] возвращает true, поскольку оператор == выполняет неявное приведение типов: пустой массив преобразуется в пустую строку, которая равна числу 0, а false также приводится к 0.