coding-interview-university
A complete computer science study plan to become a software engineer.
- 365k
- CC-BY-SA-4.0
- 2 wk ago
Most popular JavaScript interview questions and answers -> https://www.devlovers.net
Repo DevLoversTeam/javascript-interview-questions, read from GitHub 1 min ago. DevLoversTeam has not joined Take My Repo.
DevLoversTeam/javascript-interview-questions is a public repo on GitHub by DevLoversTeam. Most popular JavaScript interview questions and answers -> https://www.devlovers.net. It declares the MIT license on GitHub. It has 305 stars and last changed on 2025-12-13. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-21.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
JavaScript - це динамічна, прототипно-орієнтована мова програмування, яка використовується для створення інтерактивного контенту на вебсторінках. Вона підтримує подієве програмування, асинхронність і працює в браузері, а також на сервері через Node.js.
varvar x = 10;
letlet y = 20; y = 30; // Можна змінити значення
constconst z = 40; // z = 50; // Помилка
const для змінних, які не змінюються.let для змінних, які змінюють значення.var уникати, якщо це не потрібно для специфічної підтримки старих браузерів.stringnumberbooleannullundefinedbigintsymbolobject (включаючи масиви, функції, дати тощо).Функціональне програмування:
map, reduce, filter).Подієве програмування:
click, hover, async responses).event listeners) та обробники подій (callbacks).Перший реліз JavaScript відбувся в 1995 році. Він був вперше реалізований у браузері Netscape Navigator.
Масив:
Обʼєкт:
Використання:
Event Propagation - це процес, при якому подія, що сталася на елементі, "поширюється" через DOM дерево. Є два основні етапи:
Bubbling (Спливання): Подія спочатку викликається на найбільш вкладеному елементі, потім вона спливає до батьківських елементів (від внутрішнього до зовнішнього). Наприклад, якщо клікнути на кнопку всередині контейнера, подія спочатку буде оброблятися кнопкою, потім контейнером, і так далі, поки не досягне кореневого елемента (document).
Capturing (Ловлення): Подія спочатку обробляється на найвищому рівні DOM дерева (наприклад, document), а потім спускається вниз до цільового елемента.
Event Delegation - це техніка обробки подій, коли ви додаєте один обробник подій на батьківський елемент, а не на кожен окремий дочірній елемент. Це дозволяє зменшити кількість обробників і є ефективним способом обробки подій на динамічно створених елементах.
Preventing Default Behavior (Запобігання стандартній поведінці):
stopPropagation() vs. stopImmediatePropagation():
constНі, значення, оголошене через const, не можна змінити. Це означає, що ви не можете переназначити змінну, оголошену з const, на нове значення. Однак, якщо const використовується для оголошення обʼєкта або масиву, ви все ще можете змінювати його вміст (наприклад, додавати властивості до обʼєкта або елементи до масиву). Тобто, const гарантує, що сама змінна не може бути переназначена, але не захищає від змін всередині складних типів даних (масивів, обʼєктів).
Так, ці принципи широко використовуються в програмуванні для забезпечення чистого, підтримуваного і ефективного коду.
DRY (Don't Repeat Yourself) - уникайте дублювання коду. Якщо одна й та сама логіка зустрічається в кількох місцях, варто створити спільну функцію або метод, щоб зробити код більш зручним для підтримки.
KISS (Keep It Simple, Stupid) - підтримуйте код простим і зрозумілим. Уникайте надмірної складності і зайвих абстракцій. Простота покращує підтримуваність і знижує ймовірність помилок.
YAGNI (You Aren't Gonna Need It) - не додавайте функціональність, яку наразі не потрібно. Створювати код тільки для майбутніх можливостей може призвести до зайвих витрат часу і складності.
SOLID - набір принципів для об'єктно-орієнтованого програмування, що допомагають створювати гнучкий, зрозумілий і підтримуваний код:
LocalStorage:
SessionStorage:
Основні відмінності:
Замикання (closure) - це функція, яка "запам'ятовує" оточення, в якому була створена. Це дозволяє функції доступ до змінних, навіть після того, як зовнішня функція, в якій вона була оголошена, завершила своє виконання.
Як це працює:
Приклад:
function outer() { let counter = 0; // локальна змінна зовнішньої функції return function inner() { // внутрішня функція counter++; // доступ до змінної outer() console.log(counter); }; } const increment = outer(); // викликаємо outer, що повертає функцію inner increment(); // виведе 1 increment(); // виведе 2
Кукі (cookies) - це невеликі фрагменти даних, які вебсайт зберігає в браузері користувача. Вони використовуються для зберігання інформації, яка може бути використана для ідентифікації користувача, збереження налаштувань, відслідковування сесій тощо.
Як працюють кукі в JavaScript:
Зчитування кукі: Веб-браузер автоматично додає всі кукі для поточного домену до заголовка запиту, і JavaScript може отримати їх через document.cookie.
const cookies = document.cookie; console.log(cookies); // виведе всі кукі у вигляді рядка
Запис кукі: Кукі встановлюються за допомогою властивості document.cookie. Формат для встановлення кукі виглядає так:
document.cookie = 'name=value; expires=Thu, 31 Dec 2025 23:59:59 UTC; path=/';
У цьому прикладі:
Видалення кукі: Щоб видалити кукі, потрібно встановити її термін придатності в минуле:
document.cookie = 'name=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/';
Особливості:
Використання кукі:
Область видимості змінної - це частина коду, в межах якої до змінної можна отримати доступ. У JavaScript існують три основні типи області видимості:
var globalVar = 'I am global'; // доступна у всьому коді function test() { console.log(globalVar); // доступ до глобальної змінної } test();
function test() { var localVar = 'I am local'; console.log(localVar); // доступна всередині функції } test(); console.log(localVar); // помилка: localVar не визначена
{ let blockVar = 'I am block scoped'; const blockConst = 'I am also block scoped'; console.log(blockVar); // доступна } console.log(blockVar); // помилка: blockVar не визначена
Вкладені області видимості:
function outer() { let outerVar = 'outer'; function inner() { console.log(outerVar); // доступ до змінної зовнішньої функції } inner(); } outer();
Hoisting (Підняття):
У JavaScript змінні, оголошені через var, "піднімаються" на початок своєї області видимості, але без ініціалізації.
Змінні, оголошені через let і const, також піднімаються, але недоступні до моменту їхньої ініціалізації (це називається "Temporal Dead Zone").
console.log(a); // undefined var a = 10; console.log(b); // помилка let b = 20;
Анонімна функція - це функція, яка не має імені. Вона часто використовується там, де функцію потрібно створити швидко і немає необхідності використовувати її повторно.
Приклади анонімних функцій у JavaScript:
Функція як аргумент: Анонімні функції часто передаються як аргументи до
інших функцій (наприклад, у методах map, filter, forEach).
const numbers = [1, 2, 3]; const doubled = numbers.map(function (num) { return num * 2; }); console.log(doubled); // [2, 4, 6]
Функціональний вираз: Анонімна функція може бути присвоєна змінній.
const greet = function () { console.log('Hello'); }; greet(); // Hello
Самовиконувана функція (IIFE): Анонімна функція може бути негайно виконана.
(function () { console.log('I am an IIFE'); })();
У стрілкових функціях: Стрілкові функції - це синтаксично скорочений варіант анонімних функцій.
const add = (a, b) => a + b; console.log(add(2, 3)); // 5
Переваги анонімних функцій:
Недоліки:
<anonymous>.Стрілкова функція (arrow function) - це скорочений синтаксис для оголошення
функцій у JavaScript, введений в ES6. Вона має компактну форму і поводиться
інакше, ніж звичайна функція, особливо щодо контексту this.
Синтаксис:
const functionName = (param1, param2) => { // тіло функції return param1 + param2; };
Приклад однорядкової функції:
const add = (a, b) => a + b; // автоматично повертає результат console.log(add(2, 3)); // 5
Основні відмінності:
Контекст this:
this. Вони успадковують this із
зовнішнього оточення.this залежить від способу виклику (динамічно
прив'язується).const obj = { value: 10, regularFunction: function () { console.log(this.value); // 10 }, arrowFunction: () => { console.log(this.value); // undefined (успадковує this із глобального контексту) }, }; obj.regularFunction(); obj.arrowFunction();
Конструктор:
const Arrow = () => {}; const Regular = function () {}; new Arrow(); // Помилка new Regular(); // Працює
Синтаксис:
// Звичайна функція function multiply(a, b) { return a * b; } // Стрілкова функція const multiplyArrow = (a, b) => a * b;
arguments:
arguments. Щоб отримати
аргументи, слід використовувати оператор rest (...).arguments.const regularFunc = function () { console.log(arguments); // Псевдомасив }; const arrowFunc = (...args) => { console.log(args); // Справжній масив }; regularFunc(1, 2, 3); arrowFunc(1, 2, 3);
Ключове слово super:
super із зовнішнього контексту.super визначається залежно від їх виклику.Коли використовувати:
map, filter, reduce), а також там, де важливе
збереження контексту this.this, arguments або можливості виклику через new.Основні методи перебору масивів у JavaScript:
forEach
const arr = [1, 2, 3]; arr.forEach(num => console.log(num)); // Виведе: 1, 2, 3
map
const arr = [1, 2, 3]; const doubled = arr.map(num => num * 2); console.log(doubled); // [2, 4, 6]
filter
const arr = [1, 2, 3, 4]; const even = arr.filter(num => num % 2 === 0); console.log(even); // [2, 4]
reduce
const arr = [1, 2, 3]; const sum = arr.reduce((acc, num) => acc + num, 0); console.log(sum); // 6
some
const arr = [1, 2, 3]; console.log(arr.some(num => num > 2)); // true
every
const arr = [2, 4, 6]; console.log(arr.every(num => num % 2 === 0)); // true
find
const arr = [1, 2, 3]; console.log(arr.find(num => num > 1)); // 2
findIndex
const arr = [1, 2, 3]; console.log(arr.findIndex(num => num > 1)); // 1
flatMap
const arr = [1, 2, 3]; console.log(arr.flatMap(num => [num, num * 2])); // [1, 2, 2, 4, 3, 6]
keys, values, entries
const arr = ['a', 'b', 'c']; for (let key of arr.keys()) console.log(key); // 0, 1, 2 for (let value of arr.values()) console.log(value); // 'a', 'b', 'c' for (let [index, value] of arr.entries()) console.log(index, value); // 0 'a', 1 'b', 2 'c'
for...of
const arr = [1, 2, 3]; for (const num of arr) console.log(num); // Виведе: 1, 2, 3
sort
const arr = [3, 1, 2]; arr.sort((a, b) => a - b); console.log(arr); // [1, 2, 3]
reverse
const arr = [1, 2, 3]; arr.reverse(); console.log(arr); // [3, 2, 1]
slice
const arr = [1, 2, 3]; const subArr = arr.slice(1); console.log(subArr); // [2, 3]
splice
const arr = [1, 2, 3]; arr.splice(1, 1, 4); // Видаляє 1 елемент із позиції 1, додає 4 console.log(arr); // [1, 4, 3]
Вибір методу залежить від задачі:
filter.map.find / findIndex.forEach / for...of.JSON (JavaScript Object Notation) - це текстовий формат обміну даними, що легко читається як людиною, так і комп'ютером. Його використовують для передачі даних між клієнтом і сервером. Формат базується на синтаксисі об'єктів JavaScript, але підтримується в багатьох мовах програмування.
Основні особливості JSON:
Ключі:
Значення:
Приклад JSON:
{
"name": "Alice",
"age": 25,
"isStudent": false,
"courses": ["Math", "Physics"],
"address": { "city": "Kyiv", "zip": "01001" }
}
Як працювати з JSON у JavaScript?
Перетворення об'єкта у JSON (JSON.stringify):
const user = { name: 'Alice', age: 25, isStudent: false, }; const jsonString = JSON.stringify(user); console.log(jsonString); // Виведе: '{"name":"Alice","age":25,"isStudent":false}'
Перетворення JSON у об'єкт (JSON.parse):
const jsonString = '{"name":"Alice","age":25,"isStudent":false}'; const user = JSON.parse(jsonString); console.log(user); // Виведе: { name: 'Alice', age: 25, isStudent: false }
Робота з сервером:
Передача даних у форматі JSON:
Надсилання даних:
const data = { name: 'Alice', age: 25 }; fetch('https://example.com/api', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(data), });
Отримання даних:
fetch('https://example.com/api') .then(response => response.json()) .then(data => console.log(data));
Типові помилки:
Неправильний формат JSON:
const invalidJson = "{ name: 'Alice' }"; // Помилка: ключі та рядки без подвійних лапок JSON.parse(invalidJson); // Викине помилку
Перетворення циклічного об'єкта:
const obj = {}; obj.self = obj; JSON.stringify(obj); // Викине помилку: Converting circular structure to JSON
Застосування JSON:
Асинхронний код у JavaScript виконується за допомогою подій, колбеків, промісів
і async/await. Виконання базується на подійному циклі (Event Loop), що
дозволяє обробляти асинхронні задачі поза основним потоком виконання.
Механізми асинхронного виконання:
setTimeout(() => { console.log('Асинхронно через 1 секунду'); }, 1000); console.log('Цей код виконається першим'); // Виведе: // Цей код виконається першим // Асинхронно через 1 секунду
Проміси (Promises)
Promise представляє операцію, яка виконується асинхронно та може
завершитися успішно або з помилкою..then і .catch для обробки результату.const promise = new Promise((resolve, reject) => { setTimeout(() => resolve('Дані отримано'), 1000); }); promise .then(data => console.log(data)) // Виведе: Дані отримано .catch(err => console.error(err));
async/await
const fetchData = async () => { try { const response = await fetch( 'https://jsonplaceholder.typicode.com/posts/1' ); const data = await response.json(); console.log(data); } catch (error) { console.error('Помилка:', error); } }; fetchData();
Ключові поняття:
Основний механізм, що дозволяє виконувати асинхронний код.
Розподіляє задачі між:
setTimeout, DOM-подій.async/await.console.log('Початок'); setTimeout(() => console.log('Macrotask'), 0); Promise.resolve().then(() => console.log('Microtask')); console.log('Кінець'); // Виведе: // Початок // Кінець // Microtask // Macrotask
Приклади:
Асинхронний ланцюжок:
fetch('https://jsonplaceholder.typicode.com/posts/1') .then(response => response.json()) .then(data => console.log(data)) .catch(err => console.error('Помилка:', err));
Паралельне виконання:
const promise1 = fetch('https://jsonplaceholder.typicode.com/posts/1'); const promise2 = fetch('https://jsonplaceholder.typicode.com/posts/2'); Promise.all([promise1, promise2]) .then(responses => Promise.all(responses.map(r => r.json()))) .then(data => console.log(data));
Асинхронний код дозволяє виконувати тривалі операції без блокування головного потоку.
Event Loop - це механізм в JavaScript, який відповідає за обробку асинхронних операцій.
Процес:
Якщо Call Stack порожній, Event Loop бере завдання з Microtask Queue (пріоритетно) або Task Queue й переміщує їх у Call Stack для виконання.
Call Stack - це структура даних, яка працює за принципом LIFO (Last In, First Out) і використовується для відстеження виконання функцій у JavaScript.
Call Stack обробляє тільки синхронний код. Якщо стек переповнюється
(наприклад, через рекурсію без базового випадку), це спричиняє помилку
RangeError: Maximum call stack size exceeded.
Task Queue - це черга, яка зберігає асинхронні завдання, готові до
виконання, наприклад, колбеки з setTimeout, setInterval, або події DOM.
Коли Call Stack порожній, Event Loop бере завдання з Task Queue і додає його до стеку викликів для виконання.
Task Queue має нижчий пріоритет порівняно з Microtask Queue, тому
мікрозавдання (наприклад, з Promises) обробляються першими, навіть якщо в
Task Queue вже є готові завдання.
Microtask Queue - це черга для завдань з високим пріоритетом, наприклад:
Promise (наприклад, .then, .catch, .finally).MutationObserver.Після виконання кожної операції в Call Stack, Event Loop перевіряє Microtask Queue і виконує всі мікрозавдання, перш ніж перейти до Task Queue.
Це забезпечує швидку обробку мікрозавдань і робить їх пріоритетними над звичайними асинхронними завданнями.
async/await асинхронний код у JavaScript можна обробляти такими підходами:Callbacks (Колбеки):
Передача функції як аргумент для обробки результату.
Мінус: створює "callback hell", ускладнюючи читабельність.
setTimeout(() => { console.log('Дані завантажені'); }, 1000);
Promises:
Використання then, catch, finally для обробки асинхронності.
Більш читабельний, ніж колбеки, але може бути громіздким для складних сценаріїв.
fetch('/api/data') .then(response => response.json()) .then(data => console.log(data)) .catch(error => console.error(error));
Event Listeners (Слухачі подій):
Реагування на асинхронні події через обробники, наприклад, addEventListener.
Використовується для роботи з DOM чи подіями введення користувача.
button.addEventListener('click', () => { console.log('Кнопка натиснута'); });
RxJS (Reactive Extensions):
Використання бібліотеки для роботи з потоками даних через об'єкти Observable.
Підходить для складних асинхронних сценаріїв, як-от обробка кількох подій одночасно.
const observable = from(fetch('/api/data')); observable.subscribe({ next: response => console.log(response), error: err => console.error(err), });
== і === відрізняються способом порівняння:== (Нестроге порівняння): Виконує приведення типів (type coercion), тому
значення можуть бути різних типів.'5' == 5; // true false == 0; // true null == undefined; // true
=== (Строге порівняння): Порівнює без приведення типів. Значення повинні
бути одного типу.
'5' === 5; // false false === 0; // false null === undefined; // false
===§, щоб уникнути неочікуваних результатів через приведення
типів.== підходить лише у випадках, коли ви точно розумієте, як працює приведення.Кожен об'єкт має внутрішнє посилання на свій прототип, яке називається
[[Prototype]].
Прототипом об'єкта може бути інший об'єкт або null.
Коли ви намагаєтесь отримати доступ до властивості або методу об'єкта, JavaScript шукає їх у цьому об'єкті. Якщо не знаходить, переходить до прототипу й так далі в ланцюжку прототипів (prototype chain).
function Person(name) { this.name = name; } Person.prototype.greet = function () { console.log(`Привіт, я ${this.name}`); }; const user = new Person('Іван'); user.greet(); // Привіт, я Іван
Person.prototype - це прототип для всіх об'єктів, створених через Person.greet доступний об'єкту user через його прототип.const animal = { eat() { console.log('Їм'); }, }; const dog = Object.create(animal); dog.bark = function () { console.log('Гав!'); }; dog.eat(); // Їм (успадковано з animal) dog.bark(); // Гав!
null.Object.getPrototypeOf(obj) дозволяє отримати прототип об'єкта.null і undefined - це два різні типи даних в JavaScript, які обидва
означають "відсутність значення", але вони використовуються в різних контекстах.
null:
Це спеціальний об'єкт у JavaScript, що означає "відсутність значення" або "порожній об'єкт".
Його зазвичай використовують, щоб явно вказати на відсутність значення або на відсутність об'єкта.
Ініціалізується вручну.
let user = null; // явно вказано, що значення відсутнє
undefined:
let user; console.log(user); // undefined function test(a) { console.log(a); // undefined, якщо параметр не передано } test();
null - це об'єкт, явно призначений для вказівки на відсутність значення.undefined - це значення, яке присвоюється змінній, коли їй не було надано
значення або коли параметр функції не переданий.null == undefined - true (при порівнянні з == вони вважаються рівними
через приведення типів).null === undefined - false (при строгому порівнянні вони не однакові,
бо мають різні типи).Контекст виконання (execution context) - це середовище, в якому виконується JavaScript-код. Контекст визначає, які змінні, функції та об'єкти доступні в процесі виконання.
Глобальний контекст: Це початковий контекст, в якому запускається код (в браузері - це глобальний об'єкт window).
Контекст функції: Кожен виклик функції створює новий контекст виконання, що дозволяє доступ до змінних і параметрів функції.
Контекст об'єкта: Коли функція викликається як метод об'єкта, контекстом є цей об'єкт.
this - це ключовий елемент контексту. Він вказує на об'єкт, що є контекстом
виконання.
Методи для зміни контексту:
call(): Викликає функцію з конкретним контекстом.function greet() { console.log(`Привіт, ${this.name}`); } const person = { name: 'Іван' }; greet.call(person); // Привіт, Іван
apply(): Теж викликає функцію з певним контекстом, але аргументи
передаються у вигляді масиву.function sum(a, b) { console.log(this.name, a + b); } const person = { name: 'Оля' }; sum.apply(person, [2, 3]); // Оля 5
bind(): Створює нову функцію з прив'язаним контекстом, яку можна
викликати пізніше.function show() { console.log(this.name); } const person = { name: 'Петро' }; const showPerson = show.bind(person); showPerson(); // Петро
call() та apply() викликають функцію одразу з визначеним контекстом.bind() створює нову функцію, яка завжди має певний контекст, що може бути
викликана пізніше.Зміна контексту важлива, коли потрібно працювати з методами, які викликаються в різних обставинах, або при роботі з колбеками та асинхронним кодом.
Promise- це об'єкт, який представляє результат асинхронної операції, яка може
бути завершена або з успіхом, або з помилкою. Promise дозволяє працювати з
асинхронним кодом більш зручним способом, ніж через колбеки.
let promise = new Promise((resolve, reject) => { let success = true; if (success) { resolve('Операція успішна'); } else { reject('Щось пішло не так'); } }); promise .then(result => console.log(result)) // Обробка успіху .catch(error => console.log(error)); // Обробка помилки
.then() дозволяє більш зручно обробляти
асинхронні операції..catch().Promise.all() або Promise.race().Promise робить асинхронний код більш структурованим і менш громіздким порівняно з використанням колбеків.
Об'єктноорієнтоване програмування (ООП) у JavaScript має кілька особливостей,
оскільки мова не є класично об'єктноорієнтованою, як, наприклад, Java або C#.
Однак вона підтримує об'єктноорієнтовані концепції через механізм прототипів і з
введенням класів у ES6. Ось основні особливості ООП у JavaScript:
Прототипне наслідування (Prototype-based Inheritance):
JavaScript використовує прототипне наслідування, а не класове. Кожен об'єкт може мати прототип, який є іншим об'єктом, і успадковує від нього властивості та методи.
Коли ви звертаєтеся до властивості об'єкта, JavaScript спочатку шукає її в самому об'єкті, а потім переходить до його прототипу.
const person = { name: 'Іван', greet() { console.log(`Привіт, я ${this.name}`); }, }; const user = Object.create(person); user.name = 'Оля'; user.greet(); // Привіт, я Оля
Функції як конструктори:
function Person(name, age) { this.name = name; this.age = age; } const user = new Person('Іван', 25); console.log(user.name); // Іван
Класи (ES6+ класова синтаксична конструкція):
ES6, JavaScript отримав класову синтаксис для створення
об'єктів. Це полегшує створення класів і працює на основі прототипного
наслідування.class Person { constructor(name, age) { this.name = name; this.age = age; } greet() { console.log(`Привіт, я ${this.name}`); } } const user = new Person('Іван', 25); user.greet(); // Привіт, я Іван
Методи та властивості:
const person = { name: 'Іван', greet() { console.log(`Привіт, я ${this.name}`); }, }; person.greet(); // Привіт, я Іван
Інкапсуляція:
ES2022 також з'явилася
підтримка приватних полів у класах через #.class Person { #name; constructor(name) { this.#name = name; } getName() { return this.#name; } } const person = new Person('Іван'); console.log(person.getName()); // Іван
Поліморфізм:
class Animal { speak() { console.log('Робить звук'); } } class Dog extends Animal { speak() { console.log('Гав!'); } } const dog = new Dog(); dog.speak(); // Гав!
Абстракція:
Метод new:
new використовується для створення екземплярів класів чи
функцій-конструкторів, що ініціалізує новий об'єкт і встановлює прототип.function Person(name) { this.name = name; } const person = new Person('Іван');
JavaScript поєднує елементи класичного ООП з прототипним підходом, що дозволяє використовувати різні стилі програмування в залежності від задачі.
getElementById():<!DOCTYPE html> <html lang="uk"> <head> <meta charset="UTF-8" /> <title>Зміна тексту</title> </head> <body> <p id="example">Старий текст</p> <script> // Отримуємо елемент за ID const element = document.getElementById('example'); // Змінюємо текст element.textContent = 'Новий текст'; </script> </body> </html>
querySelector():<!DOCTYPE html> <html lang="uk"> <head> <meta charset="UTF-8" /> <title>Зміна тексту</title> </head> <body> <p class="example">Старий текст</p> <script> // Отримуємо елемент за класом const element = document.querySelector('.example'); // Змінюємо текст element.textContent = 'Новий текст'; </script> </body> </html>
textContent і innerText:textContent: Оновлює текст у елементі, включаючи прихований текст, але не
виконує рендеринг CSS.
innerText: Оновлює текст, враховуючи стилі CSS (наприклад, схований текст не
буде видимим).
Обидва підходи працюють для зміни тексту, але textContent - це більш швидкий і загальний спосіб.
DevLoversTeam/javascript-interview-questions is a public repo on GitHub by DevLoversTeam. Most popular JavaScript interview questions and answers -> https://www.devlovers.net.
It declares the MIT license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2025-12-13. Take My Repo does not judge from that whether it is maintained.
A complete computer science study plan to become a software engineer.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.

Learn how to design large-scale systems. Prep for the system design interview. Includes Anki flashcards.

List of top 500 ReactJS Interview Questions & Answers....Coding exercise questions are coming soon!!
📝 Algorithms and data structures implemented in JavaScript with explanations and links to further readings
Curated coding interview preparation materials for busy software engineers

List of 1000 JavaScript Interview Questions
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/DevLoversTeam/javascript-interview-questionsTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.