Співбесіда з JavaScript. 300+ запитань для Junior, Middle, Senior

Junior

Powered by Google TranslateTranslate

HTTP-запити - це методи взаємодії між клієнтом та сервером у протоколі HTTP. Нижче перераховані основні методи HTTP-запитів:

  1. GET - цей метод використовується для запиту ресурсів з сервера. Клієнт надсилає запит на сервер з вказанням URL-адреси ресурсу, який потрібно отримати. Відповідь на запит містить статус-код та вміст запрошеного ресурсу.

  2. POST - цей метод використовується для створення ресурсів на сервері або для відправки даних на сервер для обробки. Зазвичай цей метод використовується для відправки форм на сервер.

  3. PUT - цей метод використовується для оновлення існуючих ресурсів на сервері. Клієнт надсилає запит з вказанням URL-адреси ресурсу та нового вмісту, який повинен замінити старий вміст.

  4. DELETE - цей метод використовується для видалення ресурсів з сервера. Клієнт надсилає запит з вказанням URL-адреси ресурсу, який потрібно видалити.

  5. HEAD - цей метод використовується для запиту заголовків відповіді на запит, але без тіла відповіді. Цей метод корисний, коли потрібно отримати інформацію про ресурс без необхідності отримання всього вмісту.

  6. OPTIONS - цей метод використовується для отримання списку підтримуваних методів для конкретного ресурсу на сервері.

  7. PATCH - цей метод використовується для часткового оновлення ресурсу на сервері. Клієнт надсилає запит з вказанням URL-адреси ресурсу та змін, які потрібно зробити до ресурсу.

Це не повний список методів, що можуть використовуватися в HTTP-запитах, але ці методи є основними та найбільш поширеними.

HTTP - це протокол передачі гіпертексту, який використовується для передачі даних в Інтернеті. Нижче перераховані версії HTTP-протоколу:

  1. HTTP/0.9 - це перша версія протоколу, яка була випущена у 1991 році. Вона підтримує тільки метод GET та передає тільки текстовий вміст.

  2. HTTP/1.0 - це наступна версія, яка була випущена у 1996 році. Вона підтримує більше методів, включаючи POST та HEAD, а також може передавати бінарні дані.

  3. HTTP/1.1 - це найбільш поширена версія протоколу, яка була випущена у 1999 році. Вона підтримує багато методів, включаючи GET, POST, PUT, DELETE, HEAD, OPTIONS та інші. HTTP/1.1 також підтримує розподілені підключення, кешування та стиснення даних.

  4. HTTP/2 - ця версія була випущена у 2015 році. HTTP/2 використовує бінарний формат передачі даних, який дозволяє передавати дані швидше та ефективніше. HTTP/2 також підтримує розподілені підключення, мультиплексуванання та компресію заголовків.

  5. HTTP/3 - ця версія була випущена у 2020 році. HTTP/3 використовує протокол QUIC замість TCP для передачі даних, що дозволяє передавати дані ще швидше та ефективніше. HTTP/3 також підтримує розподілені підключення, мультиплексуванання та компресію заголовків.

Кожна нова версія HTTP-протоколу має покращення та нові функції, що дозволяють передавати дані швидше та ефективніше, що допомагає забезпечити кращий досвід для користувачів Інтернету.

HTTP-протокол використовує коди стану відповіді (response status codes), які вказують на результат обробки запиту сервером. Коди стану HTTP складаються з трьох цифр та можуть бути розділені на 5 груп:

1xx - Інформаційні повідомлення (Informational) 2xx - Успішна відповідь (Successful) 3xx - Перенаправлення (Redirection) 4xx - Помилки клієнта (Client errors) 5xx - Помилки сервера (Server errors)

Ось декілька прикладів кодів стану HTTP:

  • 200 OK - успішна відповідь, яка передає запитані дані
  • 201 Created - успішна відповідь, яка показує, що запит було створено успішно
  • 204 No Content - успішна відповідь, яка показує, що запит було оброблено успішно, але немає контенту для передачі
  • 301 Moved Permanently - повідомлення про перенаправлення, яке показує, що запитуваний ресурс було переміщено постійно на іншу адресу
  • 400 Bad Request - помилка клієнта, яка показує, що запит було сформовано неправильно
  • 403 Forbidden - помилка клієнта, яка показує, що клієнт не має дозволу на доступ до запитуваного ресурсу
  • 404 Not Found - помилка клієнта, яка показує, що запитуваний ресурс не знайдено
  • 500 Internal Server Error - помилка сервера, яка показує, що сервер не зміг обробити запит

HTTP-протокол має більше кодів стану, які допомагають забезпечити правильну взаємодію між клієнтом та сервером, та допомагають в розв'язанні проблем, які можуть виникнути в процесі обробки запиту.

Cross-Origin Resource Sharing (CORS) - це механізм, який дозволяє браузерам обмінюватися ресурсами між різними джерелами (origins). За замовчуванням, браузери захищені від схем атак, які використовують крос-доменні запити. CORS забезпечує спосіб зручно обійти ці обмеження.

Коли відбувається запит на інший домен, браузер надсилає запит з заголовком "Origin", що містить URL-адресу джерела, з якого був виконаний запит. Сервер може відповісти з заголовком "Access-Control-Allow-Origin", який вказує, які джерела дозволені для запиту на сервер. Якщо домен, що надсилає запит, знаходиться в дозволеному списку, браузер дозволяє отримати відповідь, в іншому випадку запит буде заблоковано браузером.

Щоб усунути проблеми з CORS, можна виконати наступні дії:

  1. Додати заголовки на сервер. Для того, щоб сервер дозволив запити з інших доменів, потрібно додати заголовки Access-Control-Allow-Origin і Access-Control-Allow-Methods.

  2. Використовувати проксі-сервер. Проксі-сервер може допомогти обійти обмеження CORS, оскільки всі запити будуть надсилатися з одного домену.

  3. Використовувати JSONP. JSONP (JSON with padding) - це механізм, який дозволяє запитувати дані з інших доменів. Він працює за допомогою вставки JavaScript-коду, який змінюється на сервері, щоб повернути дані у форматі JSONP.

  4. Використовувати CORS-бібліотеки. Існують бібліотеки, які дозволяють розширити функціонал CORS. Наприклад, бібліотека "cors" для Node.js.

Cookie - це невеликий файл, який зберігається на комп'ютері користувача і містить певну інформацію про взаємодію з веб-сайтом. Коли користувач відвідує веб-сайт, сервер може створити та відправити cookie на комп'ютер користувача. Коли користувач повертається на цей сайт, браузер надсилає цей cookie на сервер, дозволяючи веб-сайту ідентифікувати користувача та зберігати певну інформацію про його поведінку на сайті.

Cookie використовуються для збереження даних, які можуть бути важливими для взаємодії з веб-сайтом, наприклад, налаштувань користувача, даних про корзину покупок, аутентифікації користувача та інших.

Крім того, cookie можуть бути використані для відстеження поведінки користувача на веб-сайті, збираючи інформацію про відвідувані сторінки, клацання на посилання та інше. Ці дані можуть використовуватися для покращення взаємодії з користувачем, а також для аналізу поведінки користувачів та покращення функціоналу веб-сайту.

Звичайно, cookie можуть містити конфіденційну інформацію, тому важливо забезпечити їх захист. Для цього використовуються різні технології, такі як шифрування та підписування cookie, а також забезпечення безпечного передавання даних між сервером та браузером.

Максимальний розмір cookie залежить від браузера та налаштувань веб-сервера. Зазвичай, браузери дозволяють зберігати до 4096 байтів (4 кілобайт) в кожному cookie, а загальний розмір всіх cookie для одного домену не повинен перевищувати 50-60 кілобайт.

Також варто зазначити, що розмір cookie обмежений не лише браузером, але і проксі-серверами, які можуть обмежувати розмір запитів та відповідей. Якщо більшість користувачів використовують старі браузери, то це може обмежити розмір cookie, який можна використовувати на веб-сайті.

Отже, при проектуванні веб-додатків та використанні cookie важливо дотримуватись максимально можливого розміру та забезпечувати оптимальні налаштування сервера та браузерів користувачів.

Директива "use strict" - це інструкція, яка вказує JavaScript-інтерпретатору використовувати сучасний (строгий) режим розуміння коду JavaScript.

Коли директива "use strict" включена в початок файлу або функції, JavaScript-інтерпретатор застосовує режим, який вимагає більш суворих правил для коду, що дозволяє запобігти певним помилкам, зробити код більш безпечним та підвищити ефективність виконання. Зокрема, директива "use strict" забороняє використовувати змінні без оголошення, видаляти змінні та функції, які були оголошені з ключовим словом "var" або "function", використовувати зарезервовані слова як ідентифікатори, серед іншого.

Включення директиви "use strict" є хорошою практикою при написанні коду, оскільки дозволяє зробити його більш структурованим та зменшити кількість помилок. Однак, варто зазначити, що директива "use strict" може призвести до того, що певний код, який працює без помилок в нестрогому режимі, може не працювати в строгому режимі. Тому, перш ніж включати директиву "use strict", потрібно перевірити, чи всі частини коду будуть працювати правильно в строгому режимі.

JavaScript (JS) - це мова програмування, яка може використовуватись як на стороні клієнта (front-end), так і на стороні сервера (back-end). Однак, при використанні JS на стороні front-end та back-end, є деякі відмінності у способах використання та підходах до програмування.

На front-end, JavaScript використовується для взаємодії з користувачем та забезпечення динамічності веб-сторінок. JavaScript може бути вбудованим в HTML-код або підключений з зовнішнього файлу, і використовується для зміни вмісту та властивостей елементів веб-сторінки, обробки подій користувача, валідації форм та багато іншого. Front-end розробники також використовують різноманітні бібліотеки та фреймворки на базі JavaScript, такі як React, Vue, Angular, для швидкої розробки веб-додатків.

На back-end, JavaScript може використовуватись за допомогою платформи Node.js, яка дозволяє запускати JavaScript на стороні сервера. Node.js забезпечує доступ до файлової системи, взаємодіє з базами даних, створює серверні додатки та API, оброблює запити від клієнтів і забезпечує зв'язок зі сторонніми сервісами та API. За допомогою Node.js розробники можуть створювати швидкі та масштабовані додатки на базі JavaScript.

Отже, відмінності використання JavaScript на front-end та back-end полягають у специфіці задач та підходів до програмування. Front-end JavaScript використовується для взаємодії з користувачем та створення динамічних веб-сторінок, тоді як back-end JavaScript використовується для створення серверних додатків та API

Статична і динамічна типізація - це концепції, які описують, коли і як відбувається перевірка типів даних в мові програмування.

У статично типізованих мовах програмування, типи даних перевіряються на етапі компіляції. Компілятор перевіряє правильність використання типів даних у програмі та відображає помилки до того, як програма запуститься. Це дозволяє виявляти помилки в програмі ще до її запуску, але також може зменшити гнучкість у програмуванні, оскільки програміст повинен дотримуватися строгих правил щодо типів даних.

У динамічно типізованих мовах програмування, типи даних перевіряються в ході виконання програми. Це дозволяє більшу гнучкість у програмуванні, оскільки програміст може змінювати типи даних в ході виконання програми, але також може призвести до помилок під час виконання програми, коли типи даних не збігаються.

Наприклад, у статично типізованих мовах програмування, як от Java або C++, програміст повинен явно вказувати типи даних для змінних та параметрів функцій, і ці типи даних перевіряються на етапі компіляції. У динамічно типізованих мовах програмування, таких як JavaScript або Python, типи даних визначаються автоматично на етапі виконання програми.

Отже, статична та динамічна типізація - це дві різні стратегії перевірки типів даних у мовах програмування, кожна з яких має свої переваги та недоліки в залежності від конкретного випадку використання.

 

Клієнт і сервер взаємодіють за допомогою протоколу передачі даних HTTP (Hypertext Transfer Protocol). Процес взаємодії клієнта та сервера складається з наступних кроків:

  1. Клієнт відправляє запит на сервер, використовуючи HTTP-методи, такі як GET, POST, PUT, DELETE тощо. У запиті можуть бути передані параметри та заголовки, які вказують на бажані дії на сервері.

  2. Сервер отримує запит від клієнта та обробляє його відповідно до переданих параметрів та методу запиту. Сервер може повернути статус-код HTTP для підтвердження того, що запит було оброблено успішно.

  3. Якщо запит передбачає передачу даних, то сервер може повернути відповідь клієнту, яка може містити HTML-код, JSON-дані або інші формати даних. Відповідь може містити заголовки, які містять інформацію про вміст відповіді та інші параметри.

  4. Клієнт отримує відповідь від сервера та обробляє її. Якщо відповідь містить дані, клієнт може відобразити їх на сторінці, обробити їх за допомогою JavaScript-коду або використати їх для подальшої обробки на стороні клієнта.

REST (Representational State Transfer) - це архітектурний стиль побудови веб-сервісів, який використовується для створення додатків з високою масштабованістю та розширюваністю.

Основні принципи REST:

  1. Клієнт-серверна архітектура: система складається з клієнтів та серверів, які можуть розвиватися незалежно один від одного.

  2. Безстаний протокол: кожен запит від клієнта містить всю необхідну інформацію для обробки запиту на сервері, а сервер не зберігає жодної інформації про попередні запити.

  3. Кешування: клієнт може кешувати відповіді сервера, щоб зменшити кількість запитів до сервера.

  4. Єдинообразність інтерфейсу: використовування єдиного інтерфейсу для доступу до ресурсів системи, який включає в себе HTTP-методи GET, POST, PUT, DELETE.

  5. Шарова структура: система повинна бути побудована у вигляді шарів, що дозволяє зменшити складність та збільшити масштабованість.

REST використовується для створення веб-сервісів, які можуть використовуватися на різних платформах та в різних мовах програмування. REST дозволяє розробникам створювати додатки з високою масштабованістю та розширюваністю, що забезпечується за рахунок простоти та стандартизації інтерфейсу.

У JavaScript мутабельність (mutable) відноситься до властивості об'єктів і дозволяє змінювати їх стан після створення. Іммутабельність (immutable) відноситься до типів даних, значення яких не можна змінювати після створення.

Деякі типи даних, такі як об'єкти, масиви, функції та інші, є мутабельними. Це означає, що їх стан можна змінювати після створення. Наприклад, ви можете змінити властивість об'єкта або елемент масиву після їх створення.

Навпаки, примітивні типи даних, такі як числа, рядки, булеві значення і символи, є іммутабельними. Це означає, що значення цих типів не можна змінювати після створення. Наприклад, якщо ви маєте рядок, то не можете змінити його символи без створення нового рядка.

Перевагою іммутабельних типів даних є те, що вони зазвичай безпечніші в багатопоточних програмах, де багато потоків можуть намагатися змінювати один об'єкт одночасно. Крім того, іммутабельні типи даних легше тестувати і підтримувати, оскільки вони гарантують, що значення не будуть змінені.

Одним з способів створення іммутабельних даних у JavaScript є використання методів, які повертають нові об'єкти замість зміни старих. Наприклад, метод slice() для масивів повертає новий масив з вибраними елементами, не змінюючи вихідний масив.

 

У PHP мутабельність і іммутабельність є схожими з концепціями в інших мовах програмування. Іммутабельні об'єкти є незмінними, тобто коли об'єкт створений, він не може бути змінений. У мутабельних об'єктів можна змінювати їх стан після створення.

У PHP деякі примітивні типи, такі як рядки (strings) і числа (numbers), є іммутабельними. Це означає, що коли змінна містить рядок або число, то він не може бути змінений. Замість цього, будь-які зміни виконуються шляхом створення нового об'єкта.

У PHP складні типи даних, такі як масиви (arrays) і об'єкти (objects), є мутабельними. Це означає, що їх можна змінювати після створення. Якщо масив або об'єкт передається в функцію або метод, то будь-які зміни, які відбуваються всередині функції, також відображаються на оригінальному об'єкті.

Інші типи даних, такі як ресурси (resources), є також мутабельними. Наприклад, об'єкт з'єднання з базою даних є ресурсом і може бути змінений після створення.

Пошук помилок в коді є важливим процесом при програмуванні. Існує кілька підходів до пошуку помилок, такі як використання дебагера, логування, тестування та ін.

Дебагер є потужним інструментом для виявлення помилок в коді. Він дозволяє зупиняти виконання програми в будь-якому місці, перевіряти значення змінних та виконувати код крок за кроком. Це дозволяє виявляти помилки в коді та зрозуміти, які саме рядки коду призводять до проблем.

Однак, окрім використання дебагера, можна використовувати інші підходи. Наприклад, логування може бути корисним, коли необхідно відслідковувати певні події або значення змінних під час виконання програми. Також можна використовувати тестування, щоб перевірити різні частини програми на відповідність очікуваним результатам.

Відповідь на питання про те, чи використовую я дебагер, залежить від конкретної ситуації та інструментів, які доступні для відлагодження коду. Як правило, я використовую дебагер, коли потрібно відлагоджувати складний код, але іноді можу використовувати інші підходи, наприклад, логування або тестування, які допомагають виявляти проблеми в коді.

При розробці Frontend-додатків можуть виникати різноманітні помилки, такі як синтаксичні помилки, помилки в логіці програми, помилки відображення тощо. Для пошуку та виправлення помилок в коді Frontend можна використовувати наступні підходи та інструменти:

  1. Використання браузерних інструментів розробника: браузери мають вбудовані інструменти для дебагу, які дозволяють перевіряти код, відстежувати запити та відповіді сервера, перевіряти стилі тощо. Для цього можна використовувати консоль розробника, інструменти мережі, інспектор елементів тощо.

  2. Використання дебагерів: деякі редактори коду та IDE мають вбудовані дебагери, які дозволяють відстежувати виконання коду, встановлювати точки зупинки та досліджувати значення змінних.

  3. Використання логування: додавання логів до коду може допомогти зрозуміти, як працює програма, де виникають помилки та як їх виправляти.

  4. Використання тестування: автоматичне тестування додатку може допомогти виявити помилки та попередити їх виникнення у майбутньому.

У роботі з Frontend-додатками рекомендується використовувати різні підходи та інструменти для пошуку та виправлення помилок, в залежності від їх типу та складності.

JavaScript має величезну та широку спільноту розробників по всьому світу, серед них є безліч відомих фахівців, котрі роблять вагомий внесок у розвиток цієї мови та створення різноманітних фреймворків і бібліотек. Деякі з них:

  1. Brendan Eich - він створив JavaScript в 1995 році, і з того часу він був головним архітектором мови.

  2. Douglas Crockford - автор книги "JavaScript: The Good Parts" та старший програміст в PayPal.

  3. John Resig - створив бібліотеку jQuery.

  4. Ryan Dahl - створив Node.js.

  5. Eric Elliott - відомий автор, письменник та консультант, який активно сприяє впровадженню функціонального програмування у світ JS.

  6. Kyle Simpson - автор книги "You Don't Know JS" та співзасновник компанії Getify Solutions.

  7. Addy Osmani - інженер-розробник в Google та автор різноманітних бібліотек, таких як Material Design Lite та Yeoman.

  8. Dan Abramov - розробник React та Redux, співзасновник компанії React Training.

  9. Axel Rauschmayer - автор книги "Speaking JavaScript" та тренер з JS.

Це лише кілька прикладів з великої кількості талановитих та відомих людей у світі JavaScript.

У JavaScript існує декілька типів даних:

  1. Примітивні типи:
  • number (число)
  • string (рядок)
  • boolean (логічний тип)
  • null (відсутність значення)
  • undefined (значення не визначено)
  • symbol (символьний тип, введений у ES6)
  1. Об'єктні типи:
  • Object (об'єкт)
  • Array (масив)
  • Function (функція)
  • Date (дата)
  • RegExp (регулярний вираз)
  • Map (карта)
  • Set (множина)
  • інші типи, включаючи класи, які створюються користувачем.

Значення примітивних типів передаються за значенням, тоді як значення об'єктів передаються за посиланням.

У JavaScript існує кілька способів перевірки, чи є об'єкт масивом:

  1. Використовуючи метод Array.isArray():
let arr = [1, 2, 3];
console.log(Array.isArray(arr)); // поверне true
let obj = { name: "John", age: 30 };
console.log(Array.isArray(obj)); // поверне false

  1. Перевірка за допомогою конструктора Array:
let arr = [1, 2, 3];
console.log(arr.constructor === Array); // поверне true
let obj = { name: "John", age: 30 };
console.log(obj.constructor === Array); // поверне false

  1. Використання методу instanceof:

let arr = [1, 2, 3];
console.log(arr instanceof Array); // поверне true
let obj = { name: "John", age: 30 };
console.log(obj instanceof Array); // поверне false

 

Будь-який з цих методів може бути використаний для перевірки, чи є об'єкт масивом в JavaScript.

У JavaScript існує три ключових слова для створення змінних: var, let і const. Основна різниця між ними полягає в їх області видимості і можливості зміни значення змінної після її ініціалізації. Ось що потрібно знати про кожне з цих ключових слів:

  1. var:
  • Область видимості: функціональна;
  • Значення можна змінювати після ініціалізації;
  • Можна оголошувати без значення;
  • Використовується для оголошення змінних в старих версіях JavaScript;
  • Не рекомендується використовувати в сучасному коді.
  1. let:
  • Область видимості: блочна;
  • Значення можна змінювати після ініціалізації;
  • Не можна оголошувати без значення;
  • Використовується для оголошення змінних в сучасному JavaScript.
  1. const:
  • Область видимості: блочна;
  • Значення не можна змінювати після ініціалізації;
  • Не можна оголошувати без значення;
  • Використовується для оголошення констант в сучасному JavaScript;
  • Константи повинні бути ініціалізовані під час оголошення.

Отже, використовуйте var в старих версіях JavaScript, але використовуйте let та const в сучасному коді. Використовуйте let, якщо значення змінної повинні змінюватись, а const, якщо значення змінної не повинні змінюватись.

Область видимості (scope) в програмуванні - це частина програми, де можна отримати доступ до змінних і функцій, визначених в цій області. Область видимості визначає, які змінні і функції можуть бути доступні в якій частині коду.

У JavaScript існує два типи областей видимості:

  • Глобальна область видимості: змінні та функції, визначені в цій області, доступні з будь-якої частини програми;
  • Локальна область видимості: змінні та функції, визначені в цій області, доступні лише з обмеженої частини програми. Локальна область видимості може бути визначена в середині функцій, блоків коду або об'єктів.

В JavaScript область видимості керується змінними, оголошеними з ключовими словами var, let та const. Змінні, оголошені з var, мають функціональну область видимості, тобто їх можна використовувати в будь-якій частині функції. Змінні, оголошені з let та const, мають блочну область видимості, тобто їх можна використовувати тільки в межах блоку коду, в якому вони були оголошені.

Деструктуризація (destructuring) - це функціональність в JavaScript, яка дозволяє розбирати (деструктурувати) об'єкти або масиви на окремі змінні.

За допомогою деструктуризації можна зручно витягувати значення зі складних об'єктів та масивів. Деструктуризація дозволяє замість довгого та складного коду, що витягує значення, коротко та зрозуміло виразити ці значення.

Наприклад, ми маємо об'єкт зі свойствами:

const person = {
name: 'John',
age: 30,
address: {
city: 'New York',
country: 'USA'
}
};

За допомогою деструктуризації, ми можемо витягнути значення свойств об'єкта у змінні:
const { name, age, address: { city } } = person;
console.log(name); // 'John'
console.log(age); // 30
console.log(city); // 'New York'

Також, деструктуризація дозволяє витягнути значення з масивів:

const numbers = [1, 2, 3, 4, 5];
const [first, second, ...rest] = numbers;
console.log(first); // 1
console.log(second); // 2
console.log(rest); // [3, 4, 5]

Деструктуризація може бути корисною, коли ми маємо багато свойств в об'єкті чи багато елементів у масиві та хочемо витягнути лише певні значення.

Методи setTimeout та setInterval є функціональностями в JavaScript, які використовуються для виконання певних дій з певною затримкою чи періодичністю.

Метод setTimeout використовується для виконання певної функції через задану затримку. Синтаксис методу setTimeout виглядає наступним чином:

setTimeout(function, delay);

де function - функція, яку необхідно виконати, delay - затримка в мілісекундах до виконання функції.

Наприклад, наступний код виконує функцію sayHello через 2 секунди:

function sayHello() {
console.log('Hello!');
}
setTimeout(sayHello, 2000);

Метод setInterval використовується для виконання певної функції через заданий проміжок часу. Синтаксис методу setInterval виглядає наступним чином:

setInterval(function, delay);

де function - функція, яку необхідно виконувати, delay - інтервал в мілісекундах між виконаннями функції.

Наприклад, наступний код виконує функцію sayHello кожні 2 секунди:

function sayHello() {
console.log('Hello!');
}
setInterval(sayHello, 2000);

Методи setTimeout та setInterval є корисними, коли необхідно виконати певну дію після певної затримки чи періодично виконувати певну дію.
Однак, потрібно бути обережними з їх використанням,
оскільки можуть виникати проблеми з виконанням функцій, якщо вони займають багато часу, а також можуть виникати проблеми з пам'яттю, якщо вони виконуються довго.

JavaScript є мовою програмування, яка підтримує асинхронне програмування, тобто програмування з використанням функцій, які можуть виконуватись асинхронно, тобто в фоновому режимі, без блокування виконання інших функцій. Для роботи з асинхронним кодом в JavaScript є кілька підходів: callbacks, promises та async/await. Розглянемо кожен із них детальніше.

  1. Callbacks Callbacks - це функції, які передаються як параметри до іншої функції і викликаються, коли ця функція завершує своє виконання. Callbacks - це один з найстаріших способів роботи з асинхронним кодом в JavaScript, і вони є досить простим способом роботи з асинхронним кодом. Однак, використання callbacks може призвести до так званого "callback hell", коли вкладення функцій стає дуже глибоким та важко читати.

  2. Promises Promises - це спосіб роботи з асинхронним кодом, який ввів стандарт ES6. Promise - це об'єкт, який представляє результат асинхронної операції, і він може бути в стані "виконується", "виконано успішно" або "виконано з помилкою". Promise має два методи: then та catch, які дозволяють виконувати код при успішному виконанні або при виникненні помилки. Використання promises дозволяє уникнути "callback hell" та зробити код більш зрозумілим та читабельним.

  3. Async/await Async/await - це спосіб роботи з асинхронним кодом, який ввів стандарт ES2017. Async/await - це синтаксис, який дозволяє писати асинхронний код в стилі синхронного коду. Async оголошує функцію, яка містить await, як асинхронну, тобто виконується в фоновому режимі

Так, в JavaScript можна записувати нові властивості та функції в прототипи стандартних класів, таких як Array, Object і т.д. Однак, це не є рекомендованим підходом, оскільки може призвести до непередбачуваного поведінки вашої програми.

Розширюйте об'єкт прототипу через копіювання, а не прямим додаванням властивостей

 

 


Як мова йде про масиви, то ось декілька методів, які я знаю:

  1. push() - Додає новий елемент в кінець масиву.
  2. pop() - Видаляє останній елемент з масиву та повертає його значення.
  3. shift() - Видаляє перший елемент з масиву та повертає його значення.
  4. unshift() - Додає новий елемент на початок масиву.
  5. concat() - Об'єднує два або більше масивів у новий масив.
  6. slice() - Повертає частину масиву від початку до кінця, або від заданого індексу до кінця.
  7. splice() - Видаляє, додає або замінює елементи масиву.
  8. reverse() - Змінює порядок елементів масиву на протилежний.
  9. sort() - Сортує елементи масиву за зростанням або спаданням.
  10. indexOf() - Повертає індекс першого входження заданого елементу в масиві.
  11. lastIndexOf() - Повертає індекс останнього входження заданого елементу в масиві.

Методи масивів потрібні для здійснення різних операцій з масивами, таких як додавання, видалення, зміна порядку елементів, сортування, пошук елементів тощо. Вони дозволяють робити різноманітні операції з масивами, що дозволяє зробити код більш читабельним та ефективним.

У JavaScript є кілька перебираючих методів масивів, основні з яких такі:

  1. forEach(): викликає функцію з параметром для кожного елементу масиву.

  2. map(): створює новий масив, викликаючи функцію з параметром для кожного елементу масиву та повертаючи результат в новий масив.

  3. filter(): створює новий масив, який містить тільки елементи, які пройшли тест, визначений функцією.

  4. find(): повертає перший елемент масиву, який пройшов тест, визначений функцією.

  5. reduce(): обчислює одне значення за допомогою функції, яка виконується для кожного елементу масиву, і зберігає результат у пам'яті.

  6. some(): повертає true, якщо хоча б один елемент масиву пройшов тест, визначений функцією.

  7. every(): повертає true, якщо всі елементи масиву пройшли тест, визначений функцією.

Відмінність між ними полягає у тому, що кожен з цих методів призначений для виконання різних операцій з масивом. Наприклад, метод forEach() виконує функцію для кожного елементу масиву, тоді як метод map() створює новий масив, викликаючи функцію для кожного елементу масиву та повертаючи результат в новий масив. Використання правильного методу залежить від того, яку операцію ви хочете виконати з масивом.

https://www.w3schools.com/js/js_array_iteration.asp

Оператори в JavaScript використовуються для виконання різних операцій зі значеннями, змінними та об'єктами. Нижче наведено короткий опис декількох типів операторів в JavaScript.

  1. Оператор присвоєння (=): використовується для присвоєння значення змінній. Наприклад, a = 10; присвоює змінній a значення 10.

  2. Оператор порівняння (==, ===, !=, !==, <, >, <=, >=): використовується для порівняння двох значень. Оператор == порівнює два значення на рівність, тоді як оператор === порівнює їх на рівність і тип. Оператори != та !== виконують протилежну дію, тобто перевіряють, чи не рівні значення, або тип значень, які порівнюються. Оператори <, >, <=, >= використовуються для порівняння числових значень.

  3. Оператор рядкові (+): використовується для об'єднання рядків. Наприклад, "Hello " + "World"; поверне "Hello World".

  4. Оператори арифметичні (+, -, *, /, %): використовуються для виконання математичних операцій над числовими значеннями. Оператор + виконує додавання, - - віднімання, * - множення, / - ділення, % - повертає остачу від ділення.

  5. Оператори бітові (&, |, ^, ~, <<, >>, >>>): використовуються для виконання бітових операцій над числовими значеннями. Оператор & виконує операцію "AND" (логічне множення), | - операцію "OR" (логічне додавання), ^ - операцію "XOR" (логічне виключне "або"), ~ - операцію "NOT" (логічне заперечення), << - операцію зсуву вліво, >> - операцію зсуву вправо зі збереженням знака, операція зсуву вправо без збереження знака (>>>)

  6. Оператори логічні (&&, ||, !): використовуються для виконання логічних операцій над значеннями true і false. Оператор && повертає true, якщо обидва значення true, або false в іншому випадку. Оператор || повертає true, якщо хоча б одне зі значень true, або false в іншому випадку. Оператор ! повертає значення, протилежне до введеного.

  7. Оператори звертання до властивостей (., []): використовуються для отримання доступу до властивостей об'єктів. Оператор . використовується для звертання до властивостей об'єкту за іменем, тоді як оператор [] використовується для звертання до властивостей об'єкту за ключем.

  8. Оператор розгалуження (if/else): використовується для виконання коду на основі виразу, який повертає true або false.

  9. Оператор циклу (for, while, do/while): використовуються для виконання коду декілька разів. Оператор for виконується доти, доки виконується умова; оператор while виконується, доки умова повертає true; оператор do/while виконується принаймні один раз, після чого перевіряє умову.

Кожен оператор виконує свою функцію і має свої особливості. Знання різних типів операторів допомагає розуміти та ефективно писати код на JavaScript.

Map та Set - це колекції у JavaScript, які забезпечують ефективний доступ до даних та забезпечують швидкий пошук та операції з ними.

Map - це колекція, яка зберігає ключі та значення. Вона дозволяє зберігати дані в формі пар ключ-значення, де кожен ключ може мати тільки одне значення. Ключі можуть бути будь-якого типу даних, включаючи об'єкти. Операції додавання, видалення та пошуку елементів в Map виконуються дуже швидко, незалежно від розміру мапи. Крім того, Map зберігає ключі в порядку їх додавання, що дозволяє легко ітеруватися по мапі.

Приклад використання Map:

let myMap = new Map();// додавання елементів
myMap.set("key1", "value1");
myMap.set("key2", "value2");
// отримання значення за ключем
myMap.get("key1"); // поверне "value1"
// видалення елемента
myMap.delete("key2");
// перевірка наявності ключа
myMap.has("key1"); // поверне true
// отримання кількості елементів
myMap.size; // поверне 1

 

Set - це колекція, яка зберігає унікальні значення. Вона дозволяє швидко додавати, видаляти та перевіряти наявність елементів. Set зберігає елементи в порядку їх додавання, що дозволяє легко ітеруватися по ньому.

Приклад використання Set:

let mySet = new Set();// додавання елементів
mySet.add("value1");
mySet.add("value2");
// видалення елемента
mySet.delete("value1");
// перевірка наявності елемента
mySet.has("value2"); // поверне true
// отримання кількості елементів
mySet.size; // поверне 1

 

Використання Map та Set дозволяє легко та ефективно зберігати та опрацьовувати дані в JavaScript.

Глибока (deep) та поверхнева (shallow) копія об'єкта - це різні способи створення копії об'єкта.

Поверхнева копія (shallow copy) об'єкта створюється за допомогою оператора присвоєння або методу Object.assign(). При цьому створюється новий об'єкт з тими ж властивостями, що й у початковому об'єкті, але посилання на вкладені об'єкти залишаються ті самі. Тобто, при зміні вкладеного об'єкта в одному з об'єктів, зміни відобразяться і в іншому об'єкті.

Приклад поверхневої копії об'єкта:

let obj1 = {
a: 1,
b: {
c: 2
}
};
let obj2 = Object.assign({}, obj1);console.log(obj2); // { a: 1, b: { c: 2 } }obj1.b.c = 3;console.log(obj1); // { a: 1, b: { c: 3 } }
console.log(obj2); // { a: 1, b: { c: 3 } }

 

Глибока копія (deep copy) об'єкта створюється шляхом рекурсивного перебору всіх вкладених об'єктів та створення копій кожного з них. При цьому створюється новий об'єкт з повністю новими вкладеними об'єктами, що дозволяє змінювати один об'єкт, не впливаючи на інший.

Приклад глибокої копії об'єкта:

let obj1 = {
a: 1,
b: {
c: 2
}
};
let obj2 = JSON.parse(JSON.stringify(obj1));console.log(obj2); // { a: 1, b: { c: 2 } }obj1.b.c = 3;console.log(obj1); // { a: 1, b: { c: 3 } }
console.log(obj2); // { a: 1, b: { c: 2 } }

 

 

У JavaScript є два способи оголошення функції: декларація функції та функціональний вираз. Головна різниця між ними полягає в тому, коли і як вони можуть бути використані.

  • Декларація функції:

Декларація функції - це коли функція оголошується за допомогою ключового слова function. Цей спосіб є більш традиційним і може використовуватися незалежно від місця, де функція використовується.

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

Функція, оголошена таким чином, може бути викликана навіть перед тим, як вона оголошена в коді.

  • Функціональний вираз:

Функціональний вираз - це коли функція оголошується як частина виразу або присвоєння.

var add = function(a, b) {
return a + b;
};

 

Функція, оголошена таким чином, не може бути викликана до того, як вона була присвоєна змінній.

Крім того, функції, оголошені за допомогою функціональних виразів, можуть мати імена або бути анонімними.

 

var add = function sum(a, b) {
return a + b;
};

 

Якщо функціональний вираз має ім'я, воно може бути використане в самій функції, щоб звернутися до неї рекурсивно.

Анонімна функція в JavaScript - це функція, що не має імені і не прив'язана до жодної змінної. Це означає, що анонімну функцію можна використовувати тільки тоді, коли вона оголошується.

Анонімні функції зазвичай використовуються тоді, коли потрібно передати функцію як аргумент до іншої функції, як у випадку з функціями вищого порядку (higher-order functions), таких як map(), filter() та reduce().

Ось приклад анонімної функції, що використовується в методі map():

const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(function(number) {
return number * 2;
});
console.log(doubled); // [2, 4, 6, 8, 10]

 

У цьому прикладі функція, передана в метод map(), не має імені, але вона виконується для кожного елемента масиву numbers.

Хоча анонімні функції можуть бути корисними в певних випадках, але вони можуть бути важко читабельними, тому, зазвичай, рекомендується використовувати названі функції, коли це можливо.

Стрілкові функції (або "arrow functions") - це нова функціональність, яка була додана в ES6 (ECMAScript 2015) для зручного та лаконічного написання функцій в JavaScript.

Основні відмінності стрілкових функцій від звичайних функцій в JavaScript такі:

  1. Синтаксис: стрілкові функції записуються з допомогою стрілки =>, а не з ключовим словом function. Наприклад, const sum = (a, b) => { return a + b } замість function sum(a, b) { return a + b; }.

  2. Не має власного this: у стрілкових функціях this залежить від контексту, в якому вони були визвані, а не від контексту функції, як у звичайних функцій. Це означає, що this в стрілкових функціях не може бути змінено за допомогою методів call, apply або bind.

  3. Не має свого arguments: у стрілкових функцій немає свого власного об'єкту arguments. Замість цього, їх можна використовувати як звичайні функції з передачею аргументів через параметри функції.

  4. Немає ключового слова return для простих виразів: якщо тіло функції складається з одного виразу, то не потрібно вказувати ключове слово return. Наприклад, const double = x => x * 2 замість const double = function(x) { return x * 2; }.

Стрілкові функції корисні для написання коротких та зрозумілих функцій, які не мають власного контексту та не потребують використання ключового слова return. Вони зручні для використання з методами масивів, зокрема з map, filter та reduce, оскільки дозволяють лаконічно записувати код.

IIFE (Immediately Invoked Function Expression) - це функція, яка виконується негайно після того, як вона була оголошена.

Такі функції зазвичай використовуються для створення локального області видимості змінних та функцій, що дозволяє уникнути конфліктів між назвами змінних та функцій у глобальному контексті.

Наприклад, таку функцію можна використовувати для огортання коду, який повинен виконуватися під час завантаження сторінки або скрипта. Це допомагає уникнути змін глобального контексту, які можуть виникнути через змінні та функції, оголошені в тому самому файлі або на сторінці.

Наприклад, так виглядає приклад IIFE:

(function() {
// Код, який має виконатися
})();

У цьому прикладі функція оголошується в круглих дужках і відразу ж викликається. При цьому всі змінні та функції, що були оголошені всередині цієї функції, будуть доступні тільки всередині цієї функції, а не в глобальному контексті.

IIFE корисні, коли потрібно огорнути деякий код, щоб створити локальну область видимості, яка захищає змінні та функції від змін у глобальному контексті. Це допомагає зберегти порядок та читабельність коду і зменшити ймовірність конфліктів між змінними та функціями.

Hoisting - це процес підняття (від англ. "to hoist" - підіймати) оголошень змінних та функцій на верхній рівень області видимості, перед виконанням коду. Це означає, що ви можете використовувати змінні та функції, які були оголошені пізніше в коді, ніж ті, які викликають їх, оскільки їх оголошення будуть "підняті" на верхній рівень області видимості.

Процес hoisting відрізняється для змінних та функцій.

Для змінних, hoisting означає, що оголошення змінних будуть підняті на верхній рівень області видимості, але їх значення залишаться невизначеними, доки їм не буде присвоєне значення. Наприклад:

console.log(a); // undefined
var a = 1;
console.log(a); // 1

В цьому прикладі змінна a оголошується після виклику console.log(a), але завдяки hoisting, оголошення a буде підняте на верхній рівень, тому перший виклик console.log(a) виведе undefined.

Для функцій, hoisting означає, що оголошення функцій (але не їх тіла) будуть підняті на верхній рівень області видимості, що дозволяє викликати функції до їх оголошення. Наприклад:

foo(); // "Hello world!"
function foo() {
console.log("Hello world!");
}

У цьому прикладі функція foo() викликається перед її оголошенням, але завдяки hoisting, оголошення функції буде підняте на верхній рівень, тому виклик foo() буде працювати.

Хоча hoisting може здатися корисним, рекомендується відмовлятися від цього підходу

 

Замикання (closure) - це механізм мови програмування, що дозволяє зберігати доступ до змінних з зовнішньої області видимості функції незалежно від того, де функція викликається. Замикання є потужним інструментом для створення модульних, безпечних та масштабованих програм.

У JavaScript замикання створюється, коли функція звертається до змінної з зовнішньої області видимості. Функція зберігає в пам'яті посилання на зовнішню змінну, навіть якщо вона викликається з іншого місця програми, або після виконання функції, що її створила.

Основні сценарії використання замикань включають:

  1. Імітація приватності: Замикання дозволяють створювати змінні та функції, які не доступні ззовні, тобто їх значення та стан зберігається в приватному контексті функції.
function counter() {
let count = 0;
return function() {
return ++count;
}
}
const myCounter = counter();
console.log(myCounter()); // 1
console.log(myCounter()); // 2
console.log(myCounter()); // 3

  1. Каррінг (Currying): Замикання можуть бути використані для створення каррінгу - це техніка функціонального програмування, що дозволяє перетворити функцію з декількома аргументами у послідовність функцій з одним аргументом.
function multiply(x) {
return function(y) {
return x * y;
}
}
const double = multiply(2);
console.log(double(5)); // 10


  1. Мемоізація (Memoization): Замикання можуть бути використані для створення механізму запам'ятовування (кешування) результатів виклику функції для запобігання повторного обчислення.

function memoize(func) {
const cache = {};
return function(arg) {
if

 

Замикання (closures) - це механізм в JavaScript, що дозволяє функції звертатися до змінних, що були оголошені в батьківському контексті виконання, навіть після того, як батьківська функція вже завершила своє виконання. Тобто, замикання зберігає доступ до лексичного контексту, в якому воно було створено.

У JavaScript замикання використовуються, коли потрібно зберегти стан або створити приватні змінні в межах функції, або коли потрібно передати функцію як параметр до іншої функції.

Наприклад, ось код, що демонструє замикання:

function outerFunction() {
const outerVariable = "Hello, ";
function innerFunction(name) {
console.log(outerVariable + name);
}
return innerFunction;
}
const inner = outerFunction();
inner("John"); // виведе "Hello, John"

 

У цьому прикладі функція innerFunction має доступ до змінної outerVariable, оголошеної в батьківському контексті функції outerFunction. Хоча outerFunction завершила своє виконання, функція innerFunction все ще має доступ до значення outerVariable.

Відповідно до цього коду в консоль буде виведено рядок "Hello, John".

На початку ми викликаємо outerFunction(), яка повертає функцію innerFunction. Ми зберігаємо цю функцію в змінну inner. Потім ми викликаємо inner("John"), що виконає функцію innerFunction, виведе "Hello, " (значення outerVariable) і передасть "John" як аргумент. Результатом буде "Hello, John".

Рекурсія в JavaScript - це техніка програмування, яка полягає в тому, що функція викликає саму себе для вирішення проблеми. У JavaScript це може бути корисно для вирішення задач, які можуть бути вирішені за допомогою ітераційного алгоритму, але можуть бути більш зрозумілими та легкими для написання з використанням рекурсії.

 

Щоб функція була рекурсивною, вона повинна мати два основні компоненти:

  1. Базовий випадок - це випадок, коли функція не викликає сама себе, а повертає певне значення або робить певну дію. Цей випадок необхідний, щоб запобігти безкінечному рекурсивному виклику.

  2. Рекурсивний випадок - це випадок, коли функція викликає сама себе зі зміненими аргументами або станом. Цей випадок є необхідним для продовження роботи функції та її закінчення, коли досягнуто базового випадку.

Наприклад, факторіал числа n може бути визначений за допомогою рекурсивної функції, яка викликає сама себе зі зменшеним значенням n до тих пір, поки досягне базового випадку, коли n дорівнює 1.

 

function factorial(n) {
if (n === 1) {
return 1;
} else {
return n * factorial(n - 1);
}
}
console.log(factorial(5)); // 120

Рекурсія може бути корисною, але вона також може призвести до переповнення стеку, якщо викликів функції буде занадто багато.
Тому необхідно дбайливо планувати рекурсивні функції та запобігати безкінечному рекурсивному виклику.

Ключове слово this в JavaScript вказує на об'єкт, до якого звертається поточна функція. Значення this залежить від того, як саме викликана функція.

Зазвичай, значення this визначається в момент виклику функції та залежить від контексту виклику. Якщо функція викликається з об'єкта, то значення this вказує на цей об'єкт. Якщо функція викликається без об'єкта, то значення this вказує на глобальний об'єкт window (у випадку браузера) або на об'єкт global (у випадку Node.js).

Також можна використовувати методи call(), apply() та bind() для явного вказання значення this при виклику функції. Наприклад:

let person = {
name: "John",
age: 30,
sayHello: function() {
console.log(`Hello, my name is ${this.name}.`);
}
};person.sayHello(); // "Hello, my name is John."let person2 = {
name: "Jane",
age: 25
};person.sayHello.call(person2); // "Hello, my name is Jane."

У цьому прикладі метод sayHello() викликається з об'єкта person та використовує значення this, щоб отримати доступ до властивостей об'єкта.
При виклику методу з об'єкта
person2 за допомогою методу call(), значення this змінюється на person2, що дозволяє використати метод для виводу інформації про новий об'єкт.

 

Втрата контексту відбувається тоді, коли викликається метод об'єкта з іншого контексту, що може призвести до помилок або неправильної роботи програми.

Наприклад, коли функція викликається з події або з setTimeout, вона виконується в контексті глобального об'єкта (у випадку браузера це об'єкт window). Якщо в цій функції є посилання на this, то воно вказує на глобальний об'єкт, а не на об'єкт, з якого викликалась функція.

Для запобігання втраті контексту можна використовувати стрілкові функції, які не мають свого контексту і використовують контекст зовнішньої функції. Також можна використовувати методи bind(), call() або apply() для явного вказання контексту при виклику функції.

Наприклад, у наступному прикладі функція Person містить метод sayHello, який викликається з setTimeout. Без використання методу bind() метод sayHello втратить свій контекст і виведе помилку. Але, якщо використати bind(), то контекст буде збережений.

function Person(name) {
this.name = name;
}
Person.prototype.sayHello = function() {
console.log(`Hello, my name is ${this.name}.`);
}
let john = new Person("John");
setTimeout(john.sayHello, 1000); // Виникає помилка, this вказує на window
setTimeout(john.sayHello.bind(john), 1000); // Виводить "Hello, my name is John."

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

Різниця між методами полягає в тому, як вони передають аргументи в функцію і як вони поводяться, коли функція викликається з відсутнім контекстом.

Метод call() приймає список аргументів через кому і викликає функцію з вказаним контекстом. Наприклад:

 
function greet() {
console.log(`Hello, ${this.name}!`);
}
let person = { name: "John" };
greet.call(person); // Виводить "Hello, John!"

Метод apply() приймає масив аргументів і викликає функцію з вказаним контекстом. Наприклад:

function greet(greeting) {
console.log(`${greeting}, ${this.name}!`);
}
let person = { name: "John" };
greet.apply(person, ["Hello"]); // Виводить "Hello, John!"

Метод bind() повертає нову функцію з встановленим контекстом і аргументами, які можуть бути передані викликом нової функції. Наприклад:

function greet(greeting) {
console.log(`${greeting}, ${this.name}!`);
}
let person = { name: "John" };
let sayHello = greet.bind(person, "Hello");
sayHello(); // Виводить "Hello, John!"

Застосування цих методів корисно тоді, коли потрібно явно встановити контекст функції (наприклад, коли функція викликається з іншого контексту) і передати аргументи.

DOM (Document Object Model) - це стандартна модель об'єктів, яка представляє структуру HTML, XML або інших документів в браузері.

DOM включає в себе всі елементи веб-сторінки, такі як теги, атрибути тегів, текстові вузли та інші. Кожен елемент веб-сторінки представляється як об'єкт в DOM, що дозволяє програмістам змінювати структуру, вміст та стилі веб-сторінки з допомогою JavaScript.

DOM дозволяє програмістам динамічно змінювати вміст веб-сторінки та взаємодіяти з користувачем. Наприклад, за допомогою DOM можна створювати нові елементи, видаляти та змінювати існуючі елементи, змінювати стилі елементів, а також виконувати різноманітні дії з подіями користувача, такі як клік або наведення миші на елемент.

 

 

Атрибути async та defer призначені для того, щоб зменшити час завантаження веб-сторінки, але вони мають різні властивості та використовуються в різних ситуаціях:

  1. async - дозволяє браузеру завантажувати скрипт асинхронно, не блокуючи відображення веб-сторінки. Якщо є кілька скриптів з атрибутом async, то вони можуть завантажуватись та виконуватись в будь-якому порядку. Коли браузер завантажує скрипт з атрибутом async, він зупиняє обробку HTML та чекає, коли скрипт буде завантажено, і тільки потім продовжує виконання. Цей атрибут зазвичай використовується для зовнішніх скриптів, які не взаємодіють зі структурою HTML-документа.

  2. defer - дозволяє браузеру завантажувати скрипт асинхронно, але виконувати його тільки після того, як буде завершено завантаження веб-сторінки та побудовано структуру DOM. Якщо є кілька скриптів з атрибутом defer, то вони завантажуються в порядку зустрічі в HTML-документі. Коли браузер завантажує скрипт з атрибутом defer, він продовжує обробку HTML, а потім виконує скрипт після завантаження. Цей атрибут зазвичай використовується для скриптів, які потребують доступу до структури DOM та інших ресурсів сторінки.

Отже, async та defer - це два різних способи асинхронного завантаження скриптів, які можна використовувати залежно від ситуації та вимог до функціональності скрипта.

Обидві властивості innerHTML та innerText використовуються для отримання або встановлення текстового вмісту елемента, але між ними є різниці.

innerHTML дозволяє вставляти HTML-код в елемент, а також отримувати HTML-код, який міститься в елементі. Наприклад, якщо встановити innerHTML на елементі з текстом Hello world, то цей елемент може містити будь-який валідний HTML-код, наприклад <b>Hello</b> world.

innerText повертає лише видимий текстовий вміст елемента, без HTML-коду. Наприклад, якщо встановити innerText на елементі з текстом <b>Hello</b> world, то він поверне тільки Hello world без тегу <b>.

Одна з головних різниць між цими властивостями полягає в тому, що innerText враховує CSS властивості, такі як display: none, і не виводить текст, який прихований засобами CSS, тоді як innerHTML ігнорує ці властивості і відображає весь HTML-код в елементі.

Крім того, з використанням innerHTML є певні проблеми безпеки, оскільки він може відображати будь-який HTML-код, включаючи шкідливий код, тоді як innerText виводить лише текст та не містить таких проблем безпеки.

Отже, innerHTML та innerText мають різний функціонал, тому вибір того, яку з них використовувати, залежить від конкретного завдання.

Спливання подій (bubbling) - це процес, коли обробка події, яка виникла на дочірньому елементі, поширюється вгору по дереву DOM-елементів до батьківських елементів. Іншими словами, коли виникає подія на елементі, спочатку виконується обробник події для самого елементу, а потім він поширюється вгору по ланцюжку батьківських елементів до кореня дерева DOM.

У більшості браузерів спливання є стандартною поведінкою для більшості подій, включаючи клік миші, зміну значення поля вводу, вибір пункту меню та інші.

Наприклад, якщо на кнопку внутрішнього елементу встановлений обробник події, тоді виникає подія кліку, спочатку виконується обробник події для самого елементу, а потім поширюється на батьківський елемент, який містить цю кнопку. Якщо на цьому батьківському елементі також є обробник події, то він теж буде виконаний. Таким чином, обробка події розповсюджується вгору по ланцюжку батьківських елементів до кореня дерева DOM.

Цей процес може бути корисним, коли вам потрібно виконати декілька обробників подій на різних рівнях DOM-дерева. Але в той же час спливання подій може призвести до непередбачуваного поведінки, коли один обробник події може змінити поведінку іншого обробника, розташованого на батьківському елементі. Щоб уникнути таких проблем, можна використовувати метод stopPropagation() для зупинки спливання подій.

У JavaScript, коли подія виникає на елементі, він спочатку обробляється на найглибшому елементі (який спричинив подію) і поступово переходить до батьківських елементів у напрямку до кореня документу. Цей процес відомий як спливання подій (event bubbling). За замовчуванням, якщо подія не обробляється на одному елементі, вона спливає далі до його батьківських елементів.

Іноді, коли виникає подія на дочірньому елементі, ми хочемо зупинити спливання події, щоб вона не поширювалась на його батьківські елементи. Це можна зробити за допомогою методу stopPropagation().

Наприклад, якщо у нас є HTML-код з кнопкою, яка міститься в елементі div, і ми хочемо зупинити спливання події при кліку на кнопку, ми можемо використати наступний код:

<div id="myDiv">
<button id="myButton">Click me</button>
</div>

 

const button = document.getElementById("myButton");
const div = document.getElementById("myDiv");
button.addEventListener("click", function(event) {
event.stopPropagation();
console.log("Button clicked");
});
div.addEventListener("click", function(event) {
console.log("Div clicked");
});

 

У цьому коді ми використовуємо метод stopPropagation() в обробнику події для кнопки, щоб зупинити спливання події до елемента div. Як результат, при кліку на кнопку буде виведено "Button clicked", але "Div clicked" не буде виведено.

Важливо пам'ятати, що зупинка спливання події може мати наслідки для дочірніх елементів, які можуть очікувати на спливання події. Тому, якщо ми зупиняємо спливання події, ми повинні бути впевнені, що це не пошкодить інші частини коду.

 
 
 

Для того, щоб зупинити дефолтну обробку події, можна використовувати метод preventDefault() на об'єкті події. Цей метод використовується для того, щоб перешкодити виконанню дії за замовчуванням, яка зазвичай відбувається при спрацьовуванні певної події в браузері.

Наприклад, якщо ми хочемо зупинити дефолтну поведінку посилання при кліку на нього, ми можемо використати такий код:

const link = document.querySelector('a');
link.addEventListener('click', function(event) {
event.preventDefault(); // зупинити дефолтну обробку події
// робимо свої дії
});

Цей код перешкоджає виконанню дії за замовчуванням - переходу за посиланням - і дозволяє виконати свої власні дії при кліку на посилання.
Метод
preventDefault() можна використовувати для зупинки дефолтної обробки будь-якої події в браузері.

Значення this в обробнику події (event handler) залежить від того, яким чином був встановлений обробник події.

Якщо обробник події встановлено через атрибут HTML-елемента, наприклад:

<button onclick="console.log(this)">Клікніть мене</button>

то this буде посилатися на елемент, на якому спрацьовує подія, тобто на <button>.

Якщо обробник події встановлено через метод addEventListener, наприклад:

const button = document.querySelector('button');
button.addEventListener('click', function() {
console.log(this);
});

то this буде посилатися на елемент, на якому був встановлений обробник події, тобто на button.

Проте, якщо обробник події написаний з використанням стрілкової функції, то this буде посилатися на контекст, у якому була створена стрілкова функція, а не на елемент, на якому спрацьовує подія.

const button = document.querySelector('button');
button.addEventListener('click', () => {
console.log(this); // this посилатиметься на глобальний об'єкт window
});

Отже, значення this в обробнику події залежить від того, яким чином був встановлений обробник, і може посилатися на елемент, на якому спрацьовує подія, на елемент,
на якому був встановлений обробник, або на контекст, у якому була створена стрілкова функція.



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

LocalStorage зберігає дані без строків дії, тобто дані зберігаються до тих пір, поки їх не видалити вручну або не очистити кеш браузера. Дані в LocalStorage доступні для всіх вкладок та вікон браузера, що працюють з тим самим доменом.

SessionStorage зберігає дані на протязі сесії, тобто до закриття вкладки або браузера. Дані в SessionStorage доступні тільки для вкладок та вікон, які створені в рамках тієї самої сесії.

Максимальний розмір LocalStorage залежить від браузера та операційної системи. Зазвичай це коливається від 2 до 10 мегабайтів, але може бути більшим або меншим в залежності від конкретної реалізації браузера та обмежень операційної системи. Важливо пам'ятати, що використання LocalStorage може займати значну кількість місця в кеші браузера, тому важливо не зловживати його використанням та періодично очищати дані, які більше не потрібні.

Для отримання висоти блоку та його положення щодо меж документа використовують властивості offsetHeight та offsetTop.

offsetHeight - це висота елементу включаючи всі відступи, границі та полосу прокрутки, якщо вона є.

offsetTop - це відстань від верхнього краю блоку до верхнього краю його найближчого предка з позицією relative або absolute.

Наприклад, щоб отримати висоту та положення блоку з ідентифікатором "myDiv", можна використати такий код:

const myDiv = document.getElementById("myDiv");
const height = myDiv.offsetHeight;
const topOffset = myDiv.offsetTop;

Зверніть увагу, що offsetTop повертає відстань від верхнього краю батьківського елементу, якщо він має позицію relative або absolute.
Якщо батьківський елемент не має позицію relative або absolute, offsetTop повертає відстань від верхнього краю body.
Для отримання відстані від верхнього краю вікна браузера до верхнього краю елементу можна використати властивість getBoundingClientRect():

const myDiv = document.getElementById("myDiv");
const rect = myDiv.getBoundingClientRect();
const topWindowOffset = rect.top + window.pageYOffset;
У цьому прикладі topWindowOffset містить відстань від верхнього краю вікна браузера до верхнього краю елементу.
Зверніть увагу, що window.pageYOffset містить відстань, на яку прокручено сторінку відносно верхнього краю документа.

Webpack - це інструмент збірки (build tool) для веб-проектів на основі Node.js, який дозволяє об'єднувати різні файли проекту в один або декілька зкомпільованих файлів, оптимізуючи їх для швидшого завантаження в браузері.

Webpack є одним з найбільш популярних інструментів збірки веб-проектів в сучасному веб-розробці. Він підтримує багато різних форматів файлів, таких як JavaScript, CSS, HTML, картинки, шрифти та інші, та дозволяє об'єднувати їх в один або декілька зкомпільованих файлів.

Основні функції Webpack включають:

  • Збірку і об'єднання різних файлів проекту в один або декілька зкомпільованих файлів.
  • Трансформацію та оптимізацію файлів для покращення продуктивності та швидкості завантаження.
  • Роботу з модульною системою, яка дозволяє розділяти код на менші частини та зручно керувати залежностями між ними.
  • Підтримку багатьох різних плагінів та інструментів для автоматизації різних завдань, таких як побудова CSS або генерація HTML-файлів.

Webpack зазвичай використовується в сучасних фронтенд-фреймворках та бібліотеках, таких як React, Vue.js, Angular та інших, для збірки та пакування коду використовуючи модульну систему.

Тож якщо треба запустити його в роботі

Потрібно виконати наступні кроки:

  1. Встановити Webpack та необхідні плагіни та завдання.

  2. Створити конфігураційний файл webpack.config.js в кореневій папці проекту.

  3. Визначити точку входу вашого додатку, тобто ту точку, з якої Webpack має починати збірку проекту.

  4. Визначити точки виходу, тобто ті файли, які мають бути створені після збірки проекту.

  5. Налаштувати правила для збору різних типів файлів, наприклад, для обробки JavaScript, CSS, зображень і т.д.

  6. Додати необхідні плагіни, такі як HtmlWebpackPlugin, щоб автоматично генерувати HTML-файли зі збірки.

  7. Налаштувати devServer для запуску локального сервера для розробки, щоб ви могли перевірити свій додаток без необхідності завантажувати його на реальний сервер.

  8. Налаштувати режими роботи Webpack, такі як режим розробки і режим виробництва, щоб забезпечити належну оптимізацію вашого додатку.

  9. Перевірити налаштування та запустити збірку проекту за допомогою команди "webpack".

Ці кроки допоможуть налаштувати Webpack для вашого проекту та забезпечити його ефективну роботу. Проте, налаштування Webpack є складним процесом, тому рекомендується використовувати документацію та приклади, щоб допомогти зрозуміти принципи роботи Webpack.

Dev-збірка та Prod-збірка - це дві різні конфігурації збірки проекту, які різняться за своїм призначенням.

Dev-збірка (або розробницька збірка) - це конфігурація збірки, яка призначена для розробки та відлагодження проекту. Її основна мета - забезпечити швидку збірку проекту та забезпечити розробнику зручне середовище для розробки, включаючи можливість редагування та відлагодження коду в реальному часі, виведення на екран повідомлень про помилки, попереджень та ін.

Prod-збірка (або продакшн збірка) - це конфігурація збірки, яка призначена для публікації проекту в робочому середовищі (production). Її основна мета - забезпечити оптимізований та скомпільований код проекту, який працює швидко та без помилок в реальному середовищі. Продакшн збірка включає в себе оптимізацію коду, мініфікацію файлів, зведення декількох файлів в один, підтримку кешування, оптимізацію зображень та інші техніки оптимізації для забезпечення максимальної продуктивності та швидкості завантаження.

Основна різниця між dev-збіркою та prod-збіркою полягає в тому, що dev-збірка забезпечує зручне середовище для розробки, яке дозволяє редагувати та відлагоджувати код у реальному часі, тоді як prod-збірка забезпечує оптимізований та готовий до використання код для публікації в робочому середовищі.

Блокова модель CSS - це спосіб, за яким веб-браузер відображає HTML-елемент. За допомогою блокової моделі можна керувати розмірами, відступами та рамками HTML-елементів.

Блокова модель складається з чотирьох основних елементів: контент, внутрішні відступи, зовнішні відступи та рамки. Кожен HTML-елемент має властивості, що відповідають кожному з цих елементів.

  • Контент - це вміст HTML-елемента, такий як текст, зображення або відео.

  • Внутрішні відступи (padding) - це простір між контентом та рамкою. Вони можуть бути задані за допомогою властивості padding.

  • Зовнішні відступи (margin) - це простір між рамкою та сусідніми HTML-елементами або межами сторінки. Вони можуть бути задані за допомогою властивості margin.

  • Рамки (border) - це лінії, які оточують контент та внутрішні відступи HTML-елемента. Вони можуть бути задані за допомогою властивості border.

Загальна ширина і висота HTML-елемента обчислюються як сума ширини / висоти контенту, внутрішніх відступів, зовнішніх відступів та рамок. Ця сума називається "блоковим розміром" елемента.

Блокова модель CSS є важливим концептом веб-розробки, оскільки вона дозволяє контролювати розміри та місцезнаходження HTML-елементів на сторінці.

Існує кілька способів центрування блокового контенту по горизонталі та вертикалі в CSS:

  1. Центрування по горизонталі:

    • margin: 0 auto; - задає блоку нульовий верхній та нижній відступи і автоматично визначає лівий та правий відступи, щоб блок був відцентрованим по горизонталі;
    • display: flex; justify-content: center; - задає блоку flex контекст та вирівнює його вміст по центру за горизонталлю;
    • text-align: center; - центрує вміст блокового елемента, але не впливає на його розмір.
  2. Центрування по вертикалі:

    • display: flex; align-items: center; - задає блоку flex контекст та вирівнює його вміст по центру за вертикаллю;
    • display: grid; place-items: center; - задає блоку grid контекст та вирівнює його вміст по центру за горизонталлю та вертикаллю;
    • position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); - розміщує блок в абсолютному позиціонуванні відносно його батьківського елемента та вирівнює його по центру за горизонталлю та вертикаллю.

Ці способи можуть використовуватись окремо або в комбінації для досягнення потрібного ефекту центрування.

Існує декілька підходів до верстки сторінок веб-сайтів, серед них:

  1. Float - використовується для розташування елементів вирівняних по горизонталі з використанням властивості float. Цей підхід є старішим і менш гнучким порівняно з іншими підходами.

  2. Flexbox - це один з найпопулярніших підходів, який використовується для верстки динамічних і гнучких макетів. Цей підхід базується на властивості display: flex, яка дозволяє легко контролювати порядок, розміри та вирівнювання елементів в контейнері.

  3. Grid - це ще один сучасний підхід до верстки сторінок, який дозволяє створювати складні макети зі значною кількістю елементів та рядків. Цей підхід базується на властивості display: grid та дає можливість контролювати ширину та висоту елементів, їх розміщення та відступи.

  4. Bootstrap - це фреймворк, який використовується для швидкої та ефективної верстки макетів веб-сторінок. Він включає в себе багато готових компонентів та класів CSS, що дозволяє зосередитися на розробці функціональності, не витрачаючи час на верстку.

  5. CSS-фреймворки - це набір стандартів та правил для розробки макетів, які включають в себе широкий спектр різних компонентів та класів CSS. Деякі з найпопулярніших CSS-фреймворків, які використовуються для верстки сторінок, включають в себе Bootstrap, Foundation, Materialize і Tailwind CSS.

Для того, щоб зробити додаток responsive, потрібно використовувати техніки адаптивного дизайну, які дозволяють змінювати вигляд сторінки в залежності від розміру екрану пристрою.

Ось декілька підходів, які можуть бути використані:

  1. Використання медіа-запитів - дозволяє задавати CSS-стилі для конкретних розмірів екрану або типів пристроїв.

  2. Використання відносинних одиниць вимірювання, таких як відсотки або em - дозволяє створювати пропорційну розмітку, яка адаптується до різних екранів.

  3. Використання флексбоксів та сіток - дозволяє створювати гнучкі розмітки, які адаптуються до розміру екрану.

  4. Використання ретельного тестування - необхідно перевірити вигляд додатку на різних пристроях та у різних браузерах, щоб переконатися, що він відображається належним чином.

Загалом, для створення responsive додатку необхідно використовувати комбінацію цих технік та уважно перевіряти вигляд додатку на різних пристроях.

Семантична верстка - це підхід до розробки веб-сайтів, при якому HTML-код створюється таким чином, щоб він був зрозумілим не тільки браузеру, але й розробникам, що працюють з цим кодом. Принципи семантичної верстки включають наступні елементи:

  1. Використання тегів HTML згідно їхнього призначення: наприклад, використовуйте <header> для заголовку сайту, <nav> для навігації, <main> для головного вмісту сторінки і т.д.

  2. Використання відповідних атрибутів HTML: наприклад, використовуйте атрибут alt для зображень, щоб описати їх для користувачів з обмеженими можливостями.

  3. Створення структури HTML згідно ієрархії контенту: наприклад, використовуйте тег <section> для визначення групи пов'язаних елементів.

  4. Використання правильної семантики для посилань: наприклад, використовуйте тег <a> з атрибутом href для посилань.

  5. Використання CSS для оформлення візуального стилю веб-сайту, а не для визначення структури документа.

  6. Використання валідного HTML-коду, щоб забезпечити сумісність з різними браузерами і покращити доступність для користувачів з обмеженими можливостями.

  7. Використання резервування місця для медіа-елементів: наприклад, встановлюйте ширину та висоту зображення, щоб уникнути стрибків вмісту під час завантаження зображення.

Семантична верстка допомагає покращити доступність, SEO та підтримку різних пристроїв. Вона також полегшує розробку, тому що розробники можуть швидко зрозуміти структуру сторінки, не занурюючись у складний HTML

.Префікси для деяких CSS-властивостей, такі як -webkit-, -moz-, -ms- та інші (-o ) використовуються для опису поведінки у відповідних браузерах.

Префікси для деяких CSS-властивостей (-webkit-, -moz- тощо) використовуються для підтримки експериментальних або неофіційних властивостей браузерами, які ще не є частинами остаточних стандартів CSS.

Написання кросбраузерних стилів може бути складним і часомістким процесом, особливо коли потрібно підтримувати старі версії браузерів.

Одним зі способів спростити написання кросбраузерних стилів є використання CSS-препроцесорів, таких як Sass або Less. Ці препроцесори мають можливості для створення змінних, міксінів та інших функцій, які допомагають уникнути повторення коду та підтримувати кросбраузерність.

Ще один спосіб - використання CSS-фреймворків, таких як Bootstrap, Foundation або Bulma, які надають готові компоненти та стилізацію, які працюють у багатьох браузерах.

Також, можна використовувати веб-сервіси, такі як Autoprefixer або CanIUse, які допомагають створювати кросбраузерний CSS, автоматично додаючи префікси відповідно до списку підтримуваних браузерів.

Загалом, для спрощення написання кросбраузерних стилів рекомендується використовувати найновіші стандарти CSS, використовувати CSS-препроцесори та фреймворки, які підтримують кросбраузерність, та регулярно перевіряти свій код за допомогою веб-сервісів.

CSS-препроцесори - це інструменти, які дозволяють розширювати стандартний CSS з новими функціями та можливостями, які допомагають зменшити складність CSS-коду та спростити розробку веб-інтерфейсів.

+:

  • Змінні (variables) - дозволяють зберігати значення та використовувати їх на всій сторінці.
  • Міксіни (mixins) - дозволяють зберігати групи властивостей, які можна використовувати у різних елементах сторінки.
  • Наслідування (inheritance) - дозволяє створювати класи, які успадковують властивості від інших класів.

 

Middle

Senior

Функціональне програмування - це парадигма програмування, в якій програми будуються з функцій та зазвичай мають імутабельні дані. Ця парадигма стверджує, що функції є основними будівельними блоками програм та що вони повинні бути написані таким чином, щоб вони не мали побічних ефектів, тобто результат роботи функції залежить лише від її аргументів.

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

Основні принципи функціонального програмування включають:

  • Імутабельність даних: значення, які не можуть змінюватися після їх створення, що дозволяє більш просто та надійно розробляти код.
  • Чистота функцій: функції повинні повертати результат лише на основі вхідних параметрів та не мати побічних ефектів, таких як змінення глобальних змінних чи вивід на екран.
  • Функції вищого порядку: функції можуть приймати інші функції як параметри та повертати функції в якості результату.

TDD (Test Driven Development) і BDD (Behavior Driven Development) - це дві методології розробки програмного забезпечення, які дозволяють зосередитися на тестуванні та визначенні потреб користувачів на ранніх етапах розробки.

TDD - це метод, який базується на написанні тестів перед написанням коду. Розробник створює тести, які перевіряють очікуване поведінку програми, та потім написання коду, який буде проходити ці тести. Цей процес повторюється на кожному етапі розробки.

BDD - це метод, який зосереджується на поведінці програми, з точки зору користувача. Розробник спілкується зі зацікавленими сторонами про те, яку поведінку вони очікують від програми, та використовує ці відомості для написання специфікацій, які перевіряють, чи працює програма правильно.

Обидва підходи дозволяють розробникам зосередитися на якості програмного забезпечення та виявленні проблем на ранніх етапах розробки. TDD та BDD також допомагають знизити кількість помилок в програмному забезпеченні, зменшити витрати на тестування та підвищити ефективність команди розробників.

Браузер визначає, чи можна спілкуватися між вкладками на основі політики безпеки сховища даних (Same Origin Policy) і CORS (Cross-Origin Resource Sharing).

Same Origin Policy встановлює, що веб-сторінка може отримувати доступ до ресурсів (наприклад, Cookies, Local Storage, та ін.) тільки з того ж походження (origin), що і сама веб-сторінка. Походження включає схему (http або https), домен і порт.

Якщо дві веб-сторінки мають різне походження, то вони не можуть безпосередньо спілкуватися між собою. Для того, щоб було можливе спілкування між веб-сторінками з різними походженнями, можна використовувати CORS.

CORS дозволяє серверу визначити, з яких джерел можуть бути запити до його ресурсів. Коли запит приходить з іншого джерела, браузер спочатку відправляє запит на сервер для перевірки правил CORS, а потім виконує запит до сервера, якщо правила CORS дозволяють це.

Отже, браузер використовує політику Same Origin Policy та CORS для визначення можливості спілкування між вкладками.

Content Security Policy (CSP) - це механізм безпеки, який дозволяє вказати браузеру, звідки можна завантажувати контент на сторінці. Він дозволяє встановлювати політики безпеки на основі списку джерел, з яких може бути завантажено скрипти, стилі, медіа, шрифти та інші ресурси. Це може допомогти запобігти атакам на базі XSS, недоброякісним скриптам та іншим загрозам безпеці.

CSP може бути використаний для:

  • Захисту від XSS-атак, обмеження виконання JavaScript інших джерел, крім вказаних;
  • Захисту від недоброякісних вбудованих ресурсів, таких як відстежувачі, зображення з віддалених джерел;
  • Обмеження використання інших типів ресурсів, наприклад, вказання джерел, з яких можна завантажувати шрифти.

Приклад встановлення CSP-політики, яка дозволяє завантажувати лише ресурси з вказаних джерел:

Content-Security-Policy: default-src 'self' https://trusted-source.com;

Ця політика дозволяє завантажувати всі ресурси з поточної сторінки та з https://trusted-source.com, а все інше буде заблоковано браузером.

Існує багато метрик, які використовуються для оцінки ефективності веб-сайту. Ось декілька з них:

  1. Кількість відвідувань (Visits) або Сесій (Sessions) - це кількість разів, коли користувачі відвідують ваш веб-сайт.

  2. Кількість користувачів (Users) - це кількість унікальних користувачів, які відвідали ваш веб-сайт.

  3. Середній час перебування на сторінці (Average time on page) - це середній час, який користувачі проводять на окремих сторінках вашого веб-сайту.

  4. Показник відмов (Bounce rate) - це відсоток користувачів, які покидають ваш веб-сайт без переходу на інші сторінки.

  5. Конверсійна воронка (Conversion funnel) - це метрика, яка дозволяє відстежувати, як користувачі переходять від першого відвідування вашого сайту до виконання бажаної дії, наприклад, покупки продукту або заповнення форми.

  6. Кількість сторінок на сесію (Pages per session) - це середня кількість сторінок, які відвідувач переглядає за один візит.

  7. Кількість повторних відвідувань (Returning visitors) - це кількість користувачів, які повертаються на ваш веб-сайт після першого відвідування.

  8. Відсоток нових відвідувачів (New visitors) - це відсоток користувачів, які відвідують ваш веб-сайт вперше.

  9. Середній час завантаження сторінки (Average page load time) - це середній час, який потрібен для завантаження сторінок вашого веб-сайту.

  10. Відсоток відхилень від цільових метрик (Deviation from target metrics) 

    -)