From 95aca4b4d8fa62815d4bd412fff1a364f842814a Mon Sep 17 00:00:00 2001 From: Ryan Johnson Date: Thu, 29 Apr 2021 16:16:42 -0700 Subject: remove retired locales (#699) --- .../reference/statements/async_function/index.html | 272 ------------------ .../reference/statements/block/index.html | 132 --------- .../reference/statements/break/index.html | 151 ---------- .../reference/statements/class/index.html | 119 -------- .../reference/statements/const/index.html | 232 --------------- .../reference/statements/continue/index.html | 164 ----------- .../reference/statements/debugger/index.html | 78 ----- .../reference/statements/do...while/index.html | 101 ------- .../reference/statements/empty/index.html | 105 ------- .../reference/statements/export/index.html | 205 ------------- .../reference/statements/for-await...of/index.html | 253 ---------------- .../reference/statements/for...in/index.html | 149 ---------- .../reference/statements/for...of/index.html | 319 --------------------- .../javascript/reference/statements/for/index.html | 165 ----------- .../reference/statements/function/index.html | 179 ------------ .../reference/statements/function_star_/index.html | 268 ----------------- .../reference/statements/if...else/index.html | 173 ----------- .../web/javascript/reference/statements/index.html | 130 --------- .../reference/statements/label/index.html | 182 ------------ .../javascript/reference/statements/let/index.html | 272 ------------------ .../reference/statements/return/index.html | 159 ---------- .../reference/statements/switch/index.html | 295 ------------------- .../reference/statements/throw/index.html | 198 ------------- .../reference/statements/try...catch/index.html | 319 --------------------- .../javascript/reference/statements/var/index.html | 226 --------------- .../reference/statements/while/index.html | 104 ------- .../reference/statements/with/index.html | 107 ------- 27 files changed, 5057 deletions(-) delete mode 100644 files/uk/web/javascript/reference/statements/async_function/index.html delete mode 100644 files/uk/web/javascript/reference/statements/block/index.html delete mode 100644 files/uk/web/javascript/reference/statements/break/index.html delete mode 100644 files/uk/web/javascript/reference/statements/class/index.html delete mode 100644 files/uk/web/javascript/reference/statements/const/index.html delete mode 100644 files/uk/web/javascript/reference/statements/continue/index.html delete mode 100644 files/uk/web/javascript/reference/statements/debugger/index.html delete mode 100644 files/uk/web/javascript/reference/statements/do...while/index.html delete mode 100644 files/uk/web/javascript/reference/statements/empty/index.html delete mode 100644 files/uk/web/javascript/reference/statements/export/index.html delete mode 100644 files/uk/web/javascript/reference/statements/for-await...of/index.html delete mode 100644 files/uk/web/javascript/reference/statements/for...in/index.html delete mode 100644 files/uk/web/javascript/reference/statements/for...of/index.html delete mode 100644 files/uk/web/javascript/reference/statements/for/index.html delete mode 100644 files/uk/web/javascript/reference/statements/function/index.html delete mode 100644 files/uk/web/javascript/reference/statements/function_star_/index.html delete mode 100644 files/uk/web/javascript/reference/statements/if...else/index.html delete mode 100644 files/uk/web/javascript/reference/statements/index.html delete mode 100644 files/uk/web/javascript/reference/statements/label/index.html delete mode 100644 files/uk/web/javascript/reference/statements/let/index.html delete mode 100644 files/uk/web/javascript/reference/statements/return/index.html delete mode 100644 files/uk/web/javascript/reference/statements/switch/index.html delete mode 100644 files/uk/web/javascript/reference/statements/throw/index.html delete mode 100644 files/uk/web/javascript/reference/statements/try...catch/index.html delete mode 100644 files/uk/web/javascript/reference/statements/var/index.html delete mode 100644 files/uk/web/javascript/reference/statements/while/index.html delete mode 100644 files/uk/web/javascript/reference/statements/with/index.html (limited to 'files/uk/web/javascript/reference/statements') diff --git a/files/uk/web/javascript/reference/statements/async_function/index.html b/files/uk/web/javascript/reference/statements/async_function/index.html deleted file mode 100644 index da4ac5f24a..0000000000 --- a/files/uk/web/javascript/reference/statements/async_function/index.html +++ /dev/null @@ -1,272 +0,0 @@ ---- -title: async function -slug: Web/JavaScript/Reference/Statements/async_function -tags: - - JavaScript - - async - - Функція - - приклад -translation_of: Web/JavaScript/Reference/Statements/async_function ---- -
-
{{jsSidebar("Statements")}}
- -

Оголошення async function визначає асинхронну функцію — функцію, яка є об'єктом {{jsxref("Global_Objects/AsyncFunction","AsyncFunction")}}. Асинхронні функції мають окремий від решти функцій порядок виконання, через цикл подій, вертаючи неявний {{jsxref("Promise","проміс")}} в якості результату. Але синтаксис та структура коду, який використовує асинхронні функції, виглядають, як стандартні синхронні функції.

- -
-

Ви також можете визначити асинхронну функцію за допомогою {{jsxref("Operators/async_function", "виразу async function", "", 1)}}.

-
-
- -
{{EmbedInteractiveExample("pages/js/statement-async.html", "taller")}}
- - - -

Синтаксис

- -
async function name([param[, param[, ... param]]]) {
-   statements
-}
-
- -

Параметри

- -
-
name
-
Ім'я функції.
-
- -
-
param
-
Ім'я аргумента, що передається у функцію.
-
- -
-
statements
-
Інструкції, що складають тіло функції.
-
- -

Значення, що повертається

- -

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

- -

Опис

- -

Асинхронна функція може містити вираз {{jsxref("Operators/await", "await")}}, який призупиняє виконання функції, щоб дочекатись на вирішення об'єкта Promise, після чого відновлює виконання асинхронної функції та повертає вирішене значення.
-
- Ключове слово await працює тільки всередині асинхронних функцій. Якщо ви використаєте його поза межами тіла асинхронної функції, то отримаєте помилку SyntaxError.

- -

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

- -
-

Метою async/await є спрощення синхронного використання промісів, а також виконання певних дій над групою промісів. Як проміси схожі на структуровані зворотні виклики, так використання async/await схоже на поєднання генераторів та промісів.

-
- -

Приклади

- -

Асинхронні функції та порядок виконання

- -
function resolveAfter2Seconds() {
-  console.log("починається повільний проміс")
-  return new Promise(resolve => {
-    setTimeout(function() {
-      resolve("повільний")
-      console.log("повільний проміс завершено")
-    }, 2000);
-  });
-}
-
-function resolveAfter1Second() {
-  console.log("починається швидкий проміс")
-  return new Promise(resolve => {
-    setTimeout(function() {
-      resolve("швидкий")
-      console.log("швидкий проміс завершено")
-    }, 1000);
-  });
-}
-
-async function sequentialStart() {
-  console.log('==ПОСЛІДОВНИЙ СТАРТ==')
-
-  // 1. Виконання доходить сюди майже миттєво
-  const slow = await resolveAfter2Seconds()
-  console.log(slow) // 2. це виконується 2 секунди після 1.
-
-  const fast = await resolveAfter1Second()
-  console.log(fast) // 3. це виконується 3 секунди після 1.
-}
-
-async function concurrentStart() {
-  console.log('==КОНКУРЕНТНИЙ СТАРТ з await==')
-  const slow = resolveAfter2Seconds() // запускає таймер негайно
-  const fast = resolveAfter1Second() // запускає таймер негайно
-
-  // 1. Виконання доходить сюди майже миттєво
-  console.log(await slow) // 2. це виконується 2 секунди після 1.
-  console.log(await fast) // 3. це виконується 2 секунди після 1., одразу після 2., оскільки швидкий вже вирішений
-}
-
-function concurrentPromise() {
-  console.log('==КОНКУРЕНТНИЙ СТАРТ з Promise.all==')
-  return Promise.all([resolveAfter2Seconds(), resolveAfter1Second()]).then((messages) => {
-    console.log(messages[0]) // повільний
-    console.log(messages[1]) // швидкий
-  });
-}
-
-async function parallel() {
-  console.log('==ПАРАЛЕЛЬНИЙ з await Promise.all==')
-
-  // Починає 2 "роботи" паралельно та чекає, поки обидві не завершаться
-  await Promise.all([
-      (async()=>console.log(await resolveAfter2Seconds()))(),
-      (async()=>console.log(await resolveAfter1Second()))()
-  ])
-}
-
-// Ця функція не обробляє помилки. Дивіться застереження нижче!
-function parallelPromise() {
-  console.log('==ПАРАЛЕЛЬНИЙ з Promise.then==')
-  resolveAfter2Seconds().then((message)=>console.log(message))
-  resolveAfter1Second().then((message)=>console.log(message))
-}
-
-sequentialStart() // через 2 секунди виводить "повільний", далі через ще 1 секунду "швидкий"
-
-// чекає, поки попередній завершиться
-setTimeout(concurrentStart, 4000) // через 2 секунди виводить "повільний", а потім "швидкий"
-
-// знову чекає
-setTimeout(concurrentPromise, 7000) // такий самий, як і concurrentStart
-
-// знову чекає
-setTimeout(parallel, 10000) // справді паралельний: через 1 секунду виводить "швидкий", потім ще через 1 секунду "повільний"
-
-// знову чекає
-setTimeout(parallelPromise, 13000) // такий самий, як і parallel
-
- -

await та паралелізм

- -

У sequentialStart виконання відкладається на 2 секунди для першого await, а потім ще на секунду для другого await. Другий таймер не створюється, поки перший не завершиться, отже, код завершує виконання через 3 секунди.

- -

У concurrentStart обидва таймери створюються і потім очікуються у await. Таймери виконуються конкурентно, це означає, що код завершує виконання через 2, а не через 3 секунди, тобто, як найповільніший таймер.
- Однак, виклики await все одно запускаються один за одним, це означає, що другий await чекатиме, поки перший не завершиться. У цьому випадку результат швидшого таймера обробляється після повільнішого.

- -

Якщо ви бажаєте виконувати дві або більше робіт паралельно, ви маєте використовувати await Promise.all([job1(), job2()]), як це показано у прикладі parallel.

- -
-

async/await проти Promise#then та обробка помилок

- -

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

- -

І concurrentStart, і concurrentPromise функціонально еквівалентні:

- - - -

Однак, асинхронні функції все ж можуть ковтати помилки.
- Візьміть для прикладу асинхронну функцію parallel. Якби вона не мала await (чи return) для повернення результату виклику Promise.all([]), будь-яка помилка не спливала б.
- В той час, як приклад parallelPromise виглядає простішим, він взагалі не обробляє помилки! Для цього знадобилося б схожа конструкція return Promise.all([]).

-
- -

Заміна ланцюжка промісів на асинхронну функцію

- -

API, який вертає {{jsxref("Promise")}}, створить ланцюжок промісів, і це розбиває функцію на багато частин. Розглянемо наступний код:

- -
function getProcessedData(url) {
-  return downloadData(url) // вертає проміс
-    .catch(e => {
-      return downloadFallbackData(url) // вертає проміс
-    })
-    .then(v => {
-      return processDataInWorker(v) // вертає проміс
-    })
-}
-
- -

його можна переписати єдиною асинхронною функцією наступним чином:

- -
async function getProcessedData(url) {
-  let v
-  try {
-    v = await downloadData(url)
-  } catch(e) {
-    v = await downloadFallbackData(url)
-  }
-  return processDataInWorker(v)
-}
-
- -

У наведеному вище прикладі немає оператора await після ключового слова return, тому що повернене значення async function неявно загортається у {{jsxref("Promise.resolve")}}.

- -
-

return await promiseValue; проти return promiseValue;

- -

Неявне загортання повернених значень у {{jsxref("Promise.resolve")}} не означає, що return await promiseValue; є функціонально еквівалентним return promiseValue;

- -

Розглянемо наступну переробку наведеного вище коду, яка вертає null, якщо processDataInWorker відхиляється з помилкою:

- -
async function getProcessedData(url) {
-  let v;
-  try {
-    v = await downloadData(url)
-  } catch(e) {
-    v = await downloadFallbackData(url)
-  }
-  try {
-    return await processDataInWorker(v) // Зауважте `return await` у порівнянні з `return`
-  } catch (e) {
-    return null
-  }
-}
-
- -

Варіант return processDataInWorker(v); спричинив би відхилення об'єкта {{jsxref("Promise")}}, поверненого функцією, замість вирішення його зі значенням null, якщо processDataInWorker(v) відхилено.

- -

Це висвітлює тонку різницю між return foo; та return await foo; — return foo; негайно вертає foo і ніколи не викидає помилку, навіть якщо foo є промісом, який відхиляється. return await foo; чекатиме на вирішення чи відхилення foo, якщо це проміс, і викидає помилку до повернення, якщо його відхилено.

-
- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ESDraft', '#sec-async-function-definitions', 'async function')}}{{Spec2('ESDraft')}}Початкове визначення у ES2017.
{{SpecName('ES8', '#sec-async-function-definitions', 'async function')}}{{Spec2('ES8')}}
- -

Сумісність з веб-переглядачами

- -
- - -

{{Compat("javascript.statements.async_function")}}

-
- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/block/index.html b/files/uk/web/javascript/reference/statements/block/index.html deleted file mode 100644 index 4a5dd619aa..0000000000 --- a/files/uk/web/javascript/reference/statements/block/index.html +++ /dev/null @@ -1,132 +0,0 @@ ---- -title: Блок -slug: Web/JavaScript/Reference/Statements/block -tags: - - JavaScript - - Довідка -translation_of: Web/JavaScript/Reference/Statements/block ---- -
{{jsSidebar("Statements")}}
- -

Блок (або складена інструкція у інших мовах) використовується, щоб об'єднати нуль або більше інструкцій. Блок позначається парою фігурних дужок і може мати необов'язкову {{jsxref("Statements/label", "мітку")}}:

- -
{{EmbedInteractiveExample("pages/js/statement-block.html")}}
- - - -

Синтаксис

- -

Блок

- -
{
-  StatementList
-}
-
- -

Блок з міткою

- -
LabelIdentifier: {
-  StatementList
-}
-
- -
-
StatementList
-
Інструкції, згруповані всередині блоку.
-
LabelIdentifier
-
Необов'язкова {{jsxref("Statements/label", "мітка")}} для візуальної ідентифікації або як вказівник для оператора {{jsxref("Statements/break", "break")}}.
-
- -

Опис

- -

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

- -

Блоки часто використовуються у поєднанні з операторами if та for.

- -

Правила області видимості блоку

- -

З var та оголошенням функцій

- -

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

- -
var x = 1;
-{
-  var x = 2;
-}
-console.log(x); // виведе 2
-
- -

Цей код виведе 2, тому що інструкція var x всередині блоку знаходиться в тій самій області видимості, що й інструкція var x перед блоком.

- -

З let та const

- -

А ось ідентифікатори, оголошені операторами {{jsxref("Statements/let", "let")}} та {{jsxref("Statements/const", "const")}} мають блочну область видимості:

- -
let x = 1;
-{
-  let x = 2;
-}
-console.log(x); // виведе 1
- -

Інструкція x = 2 обмежена областю видимості блоку, у якому записана.

- -

Те саме працює для const:

- -
const c = 1;
-{
-  const c = 2;
-}
-console.log(c); // виведе 1 і не викине SyntaxError...
- -

Зауважте, що const c = 2 у області видимості блоку не викине SyntaxError: Identifier 'c' has already been declared, тому що оголошення є унікальним всередині блоку.

- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ESDraft', '#sec-block', 'Block statement')}}{{Spec2('ESDraft')}}
{{SpecName('ES6', '#sec-block', 'Block statement')}}{{Spec2('ES6')}}
{{SpecName('ES5.1', '#sec-12.1', 'Block statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES3', '#sec-12.1', 'Block statement')}}{{Spec2('ES3')}}
{{SpecName('ES1', '#sec-12.1', 'Block statement')}}{{Spec2('ES1')}}Початкове визначення. Реалізоване у JavaScript 1.0.
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.block")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/break/index.html b/files/uk/web/javascript/reference/statements/break/index.html deleted file mode 100644 index 700d495bd6..0000000000 --- a/files/uk/web/javascript/reference/statements/break/index.html +++ /dev/null @@ -1,151 +0,0 @@ ---- -title: break -slug: Web/JavaScript/Reference/Statements/break -tags: - - JavaScript - - Довідка - - Оператор -translation_of: Web/JavaScript/Reference/Statements/break ---- -
{{jsSidebar("Statements")}}
- -

Оператор break перериває виконання поточного циклу, перемикача {{jsxref("Statements/switch", "switch")}} або {{jsxref("Statements/label", "поміченого")}} блоку і передає контроль до наступної за перерваним блоком інструкції.

- -
{{EmbedInteractiveExample("pages/js/statement-break.html")}}
- - - -

Синтаксис

- -
break [label];
- -
-
label {{optional_inline}}
-
Ідентифікатор, асоційований з міткою конструкції. Якщо конструкція не є циклом або перемикачем {{jsxref("Statements/switch", "switch")}}, цей параметр є обов'язковим.
-
- -

Опис

- -

Оператор break має необов'язкову мітку, яка дозволяє програмі переривати виконання поміченої конструкції. Оператор break має бути розташований всередині конструкції, на яку посилається. Вона може бути будь-яким {{jsxref("Statements/block", "блоком")}} інструкцій; це необов'язково має бути цикл.

- -

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

- -

Приклади

- -

Наступна фукнція містить оператор break, що перериває цикл {{jsxref("Statements/while", "while")}}, коли i дорівнює 3, а після цього поветає значення 3 * x.

- -
function testBreak(x) {
-  var i = 0;
-
-  while (i < 6) {
-    if (i == 3) {
-      break;
-    }
-    i += 1;
-  }
-
-  return i * x;
-}
- -

Наступний код використовує оператори break з поміченими блоками. Оператор break має знаходитися всередині будь-якої мітки, на яку посилається. Зауважте, що inner_block вкладений у outer_block.

- -
outer_block: {
-  inner_block: {
-    console.log('1');
-    break outer_block; // перериває обидва inner_block та outer_block
-    console.log(':-('); // пропускається
-  }
-  console.log('2'); // пропускається
-}
-
- -

Наступний код також використовує оператори break з поміченими блоками, але генерує помилку SyntaxError, тому що оператор break знаходиться всередині block_1, але посилається на block_2. Оператор break завжди має знаходитися всередині будь-якої мітки, на яку посилається.

- -
block_1: {
-  console.log('1');
-  break block_2; // SyntaxError: label not found
-}
-
-block_2: {
-  console.log('2');
-}
-
- -

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

- -
function testBreak(x) {
-  var i = 0;
-
-  while (i < 6) {
-    if (i == 3) {
-      (function() {
-        break;
-      })();
-    }
-    i += 1;
-  }
-
-return i * x;
-}
-
-testBreak(1); // SyntaxError: Illegal break statement
-
- -
block_1: {
-  console.log('1');
-  ( function() {
-    break block_1; // SyntaxError: Undefined label 'block_1'
-  })();
-}
-
- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ES1')}}{{Spec2('ES1')}}Початкове визначення. Версія без мітки.
{{SpecName('ES3')}}{{Spec2('ES3')}}Додано версію з міткою.
{{SpecName('ES5.1', '#sec-12.8', 'Break statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-break-statement', 'Break statement')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-break-statement', 'Break statement')}}{{Spec2('ESDraft')}}
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.break")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/class/index.html b/files/uk/web/javascript/reference/statements/class/index.html deleted file mode 100644 index 1350459ce8..0000000000 --- a/files/uk/web/javascript/reference/statements/class/index.html +++ /dev/null @@ -1,119 +0,0 @@ ---- -title: class -slug: Web/JavaScript/Reference/Statements/class -tags: - - ECMAScript 2015 - - JavaScript - - Довідка - - Класи - - оголошення -translation_of: Web/JavaScript/Reference/Statements/class ---- -
{{jsSidebar("Statements")}}
- -

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

- -
{{EmbedInteractiveExample("pages/js/statement-class.html")}}
- - - -
-

Ви також можете визначити клас, використовуючи {{jsxref("Operators/class", "вираз класу", "", 1)}}. Але, на відміну від виразу класу, оголошення класу не дозволяє повторне оголошення існуючого класу і викине помилку при спробі це зробити. 

-
- -

Синтаксис

- -
class name [extends] {
-  // тіло класу
-}
-
- -

Опис

- -

Тіло класу у оголошенні класу виконується у строгому режимі. Властивість constructor є необов'язковою.

- -

Оголошення класу не {{Glossary("Hoisting", "виринають")}} (на відміну від оголошення функцій).

- -

Приклади

- -

Просте оголошення класу

- -

У наступному прикладі ми спочатку визначаємо клас на ім'я Polygon, далі розширюємо його, створюючи клас на ім'я Square. Зауважте, що ключове слово super() може використовуватись лише у конструкторах і має викликатись раніше, ніж використовується ключове слово this.

- -
class Polygon {
-  constructor(height, width) {
-    this.name = 'Polygon';
-    this.height = height;
-    this.width = width;
-  }
-}
-
-class Square extends Polygon {
-  constructor(length) {
-    super(length, length);
-    this.name = 'Square';
-  }
-}
- -
-

Спроба оголосити клас двічі

- -

Повторне оголошення класу викидає помилку типу.

- -
class Foo {};
-class Foo {}; // Uncaught SyntaxError: Identifier 'Foo' has already been declared
-
- -

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

- -
var Foo = class {};
-class Foo {}; // Uncaught TypeError: Identifier 'Foo' has already been declared
-
-
-
- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ES2015', '#sec-class-definitions', 'Class definitions')}}{{Spec2('ES2015')}}Початкове визначення.
{{SpecName('ES2016', '#sec-class-definitions', 'Class definitions')}}{{Spec2('ES2016')}}
{{SpecName('ES2017', '#sec-class-definitions', 'Class definitions')}}{{Spec2('ES2017')}}
{{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}}{{Spec2('ESDraft')}}
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.class")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/const/index.html b/files/uk/web/javascript/reference/statements/const/index.html deleted file mode 100644 index 18e898e6cb..0000000000 --- a/files/uk/web/javascript/reference/statements/const/index.html +++ /dev/null @@ -1,232 +0,0 @@ ---- -title: const -slug: Web/JavaScript/Reference/Statements/const -tags: - - константа -translation_of: Web/JavaScript/Reference/Statements/const ---- -
{{jsSidebar("Statements")}}
- -

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

- -

Синтаксис

- -
const назваКонстантноїЗмінної1 = значення1 [, назваКонстантноїЗмінної2 = значення2 [, ... [, назваКонстантноїЗмінноїN = значенняN]]];
- -
-
значенняN
-
Назва константи, будь-який прийнятний {{Glossary("identifier")}} (ідентифікатор).
-
значенняN
-
Значення константи; будь-яки дозволений вираз (expression).
-
- -

Description

- -

This declaration creates a constant that can be either global or local to the function in which it is declared. An initializer for a constant is required; that is, you must specify its value in the same statement in which it's declared (which makes sense, given that it can't be changed later).

- -

Constants are block-scoped, much like variables defined using the let statement. The value of a constant cannot change through re-assignment, and it can't be redeclared.

- -

All the considerations about the "temporal dead zone" that apply to let, also apply to const.

- -

A constant cannot share its name with a function or a variable in the same scope.

- -

Examples

- -

The following example demonstrates how constants behave. Try this in your browser console.

- -
// NOTE: Constants can be declared with uppercase or lowercase, but a common
-// convention is to use all-uppercase letters.
-
-// define MY_FAV as a constant and give it the value 7
-const MY_FAV = 7;
-
-// this will throw an error in Firefox and Chrome (but does not fail in Safari)
-MY_FAV = 20;
-
-// will print 7
-console.log("my favorite number is: " + MY_FAV);
-
-// trying to redeclare a constant throws an error
-const MY_FAV = 20;
-
-// the name MY_FAV is reserved for constant above, so this will also fail
-var MY_FAV = 20;
-
-// this throws an error also
-let MY_FAV = 20;
-
-// it's important to note the nature of block scoping
-if (MY_FAV === 7) {
-    // this is fine and creates a block scoped MY_FAV variable
-    // (works equally well with let to declare a block scoped non const variable)
-    const MY_FAV = 20;
-
-    // MY_FAV is now 20
-    console.log("my favorite number is " + MY_FAV);
-
-    // this gets hoisted into the global context and throws an error
-    var MY_FAV = 20;
-}
-
-// MY_FAV is still 7
-console.log("my favorite number is " + MY_FAV);
-
-// Assigning to A const variable is a syntax error
-const A = 1; A = 2;
-
-// throws an error, missing initializer in const declaration
-const FOO;
-
-// const also works on objects
-const MY_OBJECT = {"key": "value"};
-
-// Overwriting the object behaves as above (throws an error in Firefox and Chrome but does not fail in Safari)
-MY_OBJECT = {"OTHER_KEY": "value"};
-
-// However, object keys are not protected,
-// so the following statement is executed without problem
-MY_OBJECT.key = "otherValue"; // Use Object.freeze() to make object immutable
-
- -

Specifications

- - - - - - - - - - - - - - - - - - - -
SpecificationStatusComment
{{SpecName('ES6', '#sec-let-and-const-declarations', 'Let and Const Declarations')}}{{Spec2('ES6')}}Initial definition.
{{SpecName('ESDraft', '#sec-let-and-const-declarations', 'Let and Const Declarations')}}{{Spec2('ESDraft')}} 
- -

Browser compatibility

- -

{{CompatibilityTable}}

- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FeatureChromeEdgeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatChrome(21)}}{{CompatVersionUnknown}}{{CompatGeckoDesktop(36)}}11125.1
Reassignment fails{{CompatChrome(20)}}{{CompatVersionUnknown}}{{CompatGeckoDesktop(13)}}11{{CompatUnknown}}{{CompatUnknown}}
Allowed in sloppy mode{{CompatChrome(49.0)}}     
-
- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FeatureAndroidAndroid WebviewFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Basic support{{CompatNo}}{{CompatVersionUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatVersionUnknown}}{{CompatUnknown}}{{CompatVersionUnknown}}
Reassignment fails{{CompatNo}}{{CompatVersionUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatVersionUnknown}}{{CompatUnknown}}{{CompatVersionUnknown}}
Allowed in sloppy mode{{CompatNo}}{{CompatChrome(49.0)}}    {{CompatChrome(49.0)}}
-
- -

Compatibility notes

- -

In earlier versions of Firefox & Chrome and as of Safari 5.1.7 and Opera 12.00, if you define a variable with const, you can still change its value later. It is not supported in Internet Explorer 6-10, but is included in Internet Explorer 11.

- -

Firefox-specific notes

- -

The const declaration was implemented in Firefox long before const appeared in the ECMAScript 2015 (ES6) specification. For const ES6 compliance see {{bug(950547)}} and {{bug(611388)}}.

- - - -

See also

- - diff --git a/files/uk/web/javascript/reference/statements/continue/index.html b/files/uk/web/javascript/reference/statements/continue/index.html deleted file mode 100644 index 59adc0173a..0000000000 --- a/files/uk/web/javascript/reference/statements/continue/index.html +++ /dev/null @@ -1,164 +0,0 @@ ---- -title: continue -slug: Web/JavaScript/Reference/Statements/continue -tags: - - JavaScript -translation_of: Web/JavaScript/Reference/Statements/continue ---- -
{{jsSidebar("Statements")}}
- -

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

- -
{{EmbedInteractiveExample("pages/js/statement-continue.html")}}
- - - -

Синтаксис

- -
continue [label];
- -
-
label
-
Ідентифікатор, асоційований з міткою циклу.
-
- -

Опис

- -

На відміну від оператора {{jsxref("Statements/break", "break")}}, continue не перериває виконання циклу повністю: замість цього,

- - - - - -

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

- -

Приклади

- -

Використання continue з while

- -

Наступний приклад демонструє цикл {{jsxref("Statements/while", "while")}}, що містить оператор continue, який виконується, коли значення i дорівнює 3. Таким чином, n приймає значення 1, 3, 7 та 12.

- -
var i = 0;
-var n = 0;
-
-while (i < 5) {
-  i++;
-
-  if (i === 3) {
-    continue;
-  }
-
-  n += i;
-}
-
- -

Використання continue з міткою

- -

У наступному прикладі цикл, помічений як checkiandj, містить цикл, помічений як checkj. Якщо зустрічається continue, програма продовжує виконання з початку циклу checkj. Кожен раз, як зустрічається continue, checkj починає нову ітерацію, поки його умова не поверне false. Коли повертається false, виконується решта циклу checkiandj.

- -

Якби оператор continue мав мітку checkiandj, програма би продовжувалась з початку циклу checkiandj.

- -

Дивіться також статтю {{jsxref("Statements/label", "Мітка")}}.

- -
var i = 0;
-var j = 8;
-
-checkiandj: while (i < 4) {
-  console.log('i: ' + i);
-  i += 1;
-
-  checkj: while (j > 4) {
-    console.log('j: ' + j);
-    j -= 1;
-
-    if ((j % 2) == 0)
-      continue checkj;
-    console.log(j + ' непарне число.');
-  }
-  console.log('i = ' + i);
-  console.log('j = ' + j);
-}
-
- -

Виведе:

- -
i: 0
-
-// початок checkj
-j: 8
-7 непарне число.
-j: 7
-j: 6
-5 непарне число.
-j: 5
-// кінець checkj
-
-i = 1
-j = 4
-
-i: 1
-i = 2
-j = 4
-
-i: 2
-i = 3
-j = 4
-
-i: 3
-i = 4
-j = 4
-
- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ES1')}}{{Spec2('ES1')}}Початкове визначення. Версія без мітки.
{{SpecName('ES3')}}{{Spec2('ES3')}}Додана версія з міткою.
{{SpecName('ES5.1', '#sec-12.7', 'Continue statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-continue-statement', 'Continue statement')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-continue-statement', 'Continue statement')}}{{Spec2('ESDraft')}}
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.continue")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/debugger/index.html b/files/uk/web/javascript/reference/statements/debugger/index.html deleted file mode 100644 index 12277d50e5..0000000000 --- a/files/uk/web/javascript/reference/statements/debugger/index.html +++ /dev/null @@ -1,78 +0,0 @@ ---- -title: debugger -slug: Web/JavaScript/Reference/Statements/debugger -tags: - - JavaScript - - Оператор -translation_of: Web/JavaScript/Reference/Statements/debugger ---- -
{{jsSidebar("Statements")}}
- -

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

- -

Синтаксис

- -
debugger;
- -

Приклади

- -

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

- -
function potentiallyBuggyCode() {
-    debugger;
-    // потенційно помилковий код, через який треба пройти, дослідити і т.д.
-}
- -

Коли викликається налагоджувач, виконання призупиняється на операторі debugger. Це як точка переривання у коді скрипта.

- -

Paused at a debugger statement.

- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ESDraft', '#sec-debugger-statement', 'Debugger statement')}}{{Spec2('ESDraft')}}
{{SpecName('ES6', '#sec-debugger-statement', 'Debugger statement')}}{{Spec2('ES6')}}
{{SpecName('ES5.1', '#sec-12.15', 'Debugger statement')}}{{Spec2('ES5.1')}}Початкове визначення
{{SpecName('ES3', '#sec-7.5.3', 'Debugger statement')}}{{Spec2('ES3')}}
{{SpecName('ES1', '#sec-7.4.3', 'Debugger statement')}}{{Spec2('ES1')}}Лише згаданий як зарезервоване слово.
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.debugger")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/do...while/index.html b/files/uk/web/javascript/reference/statements/do...while/index.html deleted file mode 100644 index 676ce0a4ca..0000000000 --- a/files/uk/web/javascript/reference/statements/do...while/index.html +++ /dev/null @@ -1,101 +0,0 @@ ---- -title: do...while -slug: Web/JavaScript/Reference/Statements/do...while -tags: - - JavaScript - - Цикл -translation_of: Web/JavaScript/Reference/Statements/do...while ---- -
{{jsSidebar("Statements")}}
- -

Оператор do...while створює цикл, який виконує вказану інструкцію, доки перевірочна умова не буде оцінена як false. Умова оцінюється після виконання інструкції, в результаті вказана інструкція виконується принаймні один раз.

- -
{{EmbedInteractiveExample("pages/js/statement-dowhile.html")}}
- - - -

Синтаксис

- -
do
-   statement
-while (condition);
-
- -
-
statement
-
Інструкція, яка виконується принаймні один раз, і виконується повторно кожен раз, коли умова оцінюється як true. Для виконання кількох інструкцій, використовуйте {{jsxref("Statements/block", "блок")}} ({ ... }), щоб згрупувати ці інструкції.
-
- -
-
condition
-
Вираз, який оцінюється після кожного проходу циклу. Якщо condition оцінюється як true, statement виконується повторно. Коли condition оцінюється як false, контроль переходить до наступної після do...while інструкції.
-
- -

Приклад

- -

Використання do...while

- -

У наступному прикладі цикл do...while виконується принаймні один раз, і продовжує виконуватись, доки i не перестане бути менше 5.

- -

HTML-зміст

- -
<div id="example"></div>
- -

JavaScript-зміст

- -
var result = '';
-var i = 0;
-do {
-   i += 1;
-   result += i + ' ';
-} while (i > 0 && i < 5); // Хоча i == 0, цикл виконається, оскільки починається без перевірки
-document.getElementById('example').innerHTML = result;
- -

Результат

- -

{{ EmbedLiveSample('Examples') }}

- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ES3')}}{{Spec2('ES3')}}Початкове визначення. Реалізоване у JavaScript 1.2
{{SpecName('ES5.1', '#sec-12.6.1', 'do-while statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-do-while-statement', 'do-while statement')}}{{Spec2('ES6')}}Кінцева крапка з комою ; тепер необов'язкова.
{{SpecName('ESDraft', '#sec-do-while-statement', 'do-while statement')}}{{Spec2('ESDraft')}}
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.do_while")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/empty/index.html b/files/uk/web/javascript/reference/statements/empty/index.html deleted file mode 100644 index cdb9945396..0000000000 --- a/files/uk/web/javascript/reference/statements/empty/index.html +++ /dev/null @@ -1,105 +0,0 @@ ---- -title: Порожній оператор -slug: Web/JavaScript/Reference/Statements/Empty -tags: - - JavaScript - - Оператор -translation_of: Web/JavaScript/Reference/Statements/Empty ---- -
{{jsSidebar("Statements")}}
- -

Порожній оператор використовується, щоб не надавати інструкції там, де синтаксис JavaScript їх очікує.

- -
{{EmbedInteractiveExample("pages/js/statement-empty.html")}}
- - - -

Синтаксис

- -
;
-
- -

Опис

- -

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

- -

Приклади

- -

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

- -
var arr = [1, 2, 3];
-
-// Присвоїти всім елементам масиву значення 0
-for (i = 0; i < arr.length; arr[i++] = 0) /* порожній оператор */ ;
-
-console.log(arr)
-// [0, 0, 0]
-
- -

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

- -
if (condition);       // Обережно, цей "if" нічого не робить!
-   killTheUniverse()  // Тому це ніколи не виконається!!!
-
- -

Інший приклад: Конструкція if...else без фігурних дужок ({}). Якщо three дорівнює true, то нічого не відбудеться, four не грає ролі, і, таким чином, функція launchRocket() у випадку else не буде виконана.

- -
if (one)
-  doOne();
-else if (two)
-  doTwo();
-else if (three)
-  ; // тут нічого
-else if (four)
-  doFour();
-else
-  launchRocket();
- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ESDraft', '#sec-empty-statement', 'Empty statement')}}{{Spec2('ESDraft')}}
{{SpecName('ES6', '#sec-empty-statement', 'Empty statement')}}{{Spec2('ES6')}}
{{SpecName('ES5.1', '#sec-12.3', 'Empty statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES3', '#sec-12.3', 'Empty statement')}}{{Spec2('ES3')}}
{{SpecName('ES1', '#sec-12.3', 'Empty statement')}}{{Spec2('ES1')}}Початкове визначення.
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.empty")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/export/index.html b/files/uk/web/javascript/reference/statements/export/index.html deleted file mode 100644 index ef946fa4e4..0000000000 --- a/files/uk/web/javascript/reference/statements/export/index.html +++ /dev/null @@ -1,205 +0,0 @@ ---- -title: export -slug: Web/JavaScript/Reference/Statements/export -translation_of: Web/JavaScript/Reference/Statements/export ---- -
{{jsSidebar("Statements")}}
- -

Вираз export використовується для створення модулів у Javascript для експортування функцій, об'єктів, або примітивних значень з модуля щоб їх можна було використовувати в інших програмах за допомогою виразу {{jsxref("Statements/import", "import")}}.

- -

Експортовані модулі знаходяться в {{jsxref("Strict_mode","strict mode")}} незалежно від того чи ви оголошуєте їх як такі чи ні. Вираз експорт не може бути використаним в вбудованих скріптах (embedded scripts).

- -

Синтакс

- -

Існує три види експортів

- -
    -
  1. Іменовані експорти (Нуль або більше експортів в модулі)
    2. -
  2. Дефолтний експорт (Один на модуль)
    3. -
  3. Гібридні експорти
    4. -
- -
// Експортування індивідуальних властивостей
-export let name1, name2, …, nameN; // також var, const
-export let name1 = …, name2 = …, …, nameN; // також var, const
-export function functionName(){...}
-export class ClassName {...}
-
-// Список експортів
-export { name1, name2, …, nameN };
-
-// Перейменування експортів
-export { variable1 as name1, variable2 as name2, …, nameN };
-
-// Експортування деструктивних значень з перейменуванням
-export const { name1, name2: bar } = o;
-
-// Дефолтні експорти
-export default expression;
-export default function (…) { … } // також class, function*
-export default function name1(…) { … } // також class, function*
-export { name1 as default, … };
-
-//  Агрегаціямодулів
-export * from …; // не встановлює дефолтний експорт
-export { name1, name2, …, nameN } from …;
-export { import1 as name1, import2 as name2, …, nameN } from …;
-export { default } from …;
- -
-
nameN
-
Змінна яку потрібно експортувати (щоб імпортувати за допомогою {{jsxref("Statements/import", "import")}} в іншому скрипті).
-
- -

Опис

- -

Існує два типи експортів, іменовані і дефолтні. Ви можете мати багато іменованих в модулі, але тільки один дефолтний експорт. Кожен тип має відповідність у синтаксі наведеному вище:

- -

Іменовані експорти:

- -
// експорт функціоналу оголошеного раніше
-export { myFunction, myVariable };
-
-// експортуємо індивідуальний функціонал (можу бути var, let,
-// const, function, class)
-export let myVariable = Math.sqrt(2);
-export function myFunction() { ... };
-
- -

Дефолтні експорти:

- -
// експорт функціоналу оголошеного раніше як дефолтний
-export { myFunction as default };
-
-// експорт індивідуального функціоналу як дефолтний
-export default myFunction() { ... }
-export default class { .. }
- -

Іменоввані експорти є корисними при експортуванні декількох значень. Під час імпорту іменованих експортів обов'язково потрібно використовувати те саме ім'я відповідного об'єкта.

- -

Але дефолтний експорт може бути імпортований з будь яким ім'ям, наприклад:

- -
// файл test.js
-let k; export default k = 12;
-
- -
// якийсь інший файл
-import m from './test'; // Візьміть до уваги що ми можемо використовувати import m замість import k, тому що k є дефолтним експортом
-console.log(m);        // виведе 12
-
- -

Ви також можете переіменовувати іменні експорти щоб уникнути конфліктів:

- -
export { myFunction as function1,
-         myVariable as variable };
- -

І складати підмодулі докупи в батьківському модулі щоб можна було їх імпортувати з цього модуля.

- -
// В parentModule.js
-export { myFunction, myVariable } from 'childModule1.js';
-export { myClass } from 'childModule2.js';
-
- -
// В модулі вищого рівня
-import { myFunction, myVariable, myClass } from 'parentModule.js'
- -

Приклад

- -

Використання іменних експортів

- -

В модулі my-module.js, ми можемо написати такий код:

- -
// модуль "my-module.js"
-function cube(x) {
-  return x * x * x;
-}
-
-const foo = Math.PI + Math.SQRT2;
-
-var graph = {
-  options: {
-      color:'white',
-      thickness:'2px'
-  },
-  draw: function() {
-      console.log('From graph draw function');
-  }
-}
-
-export { cube, foo, graph };
-
- -

Потім у модулі вищого порядку всередині вашої HTML сторінки ми можемо написати:

- -
import { cube, foo, graph } from './my-module.js';
-
-graph.options = {
-    color:'blue',
-    thickness:'3px'
-};
-
-graph.draw();
-console.log(cube(3)); // 27
-console.log(foo);    // 4.555806215962888
- -

Важливо звернути увагу на наступне:

- - - -

Використання дефолтного експорта

- -

Якщо ви хочете експортувати одне значення з вашого модулю ви можете використати дефолтний екпорт:

- -
// модуль "my-module.js"
-
-export default function cube(x) {
-  return x * x * x;
-}
-
- -

Потім, у дефолтному скрипті імпортувати напряму це значення:

- -
import cube from './my-module.js';
-console.log(cube(3)); // 27
-
- -

Специфікація

- - - - - - - - - - - - - - - - - - - -
SpecificationStatusComment
{{SpecName('ESDraft', '#sec-exports', 'Exports')}}{{Spec2('ESDraft')}}
{{SpecName('ES2015', '#sec-exports', 'Exports')}}{{Spec2('ES2015')}}Initial definition.
- -

Підтримка браузерами

- - - -

{{Compat("javascript.statements.export")}}

- -

Дивіться також

- - diff --git a/files/uk/web/javascript/reference/statements/for-await...of/index.html b/files/uk/web/javascript/reference/statements/for-await...of/index.html deleted file mode 100644 index 9c0440c346..0000000000 --- a/files/uk/web/javascript/reference/statements/for-await...of/index.html +++ /dev/null @@ -1,253 +0,0 @@ ---- -title: for await...of -slug: Web/JavaScript/Reference/Statements/for-await...of -tags: - - JavaScript - - await - - Інструкція - - асинхронний - - перебір -translation_of: Web/JavaScript/Reference/Statements/for-await...of ---- -
{{jsSidebar("Statements")}}
- -

Інструкція for await...of створює цикл, що перебирає як асинхронні ітерабельні об'єкти, так і синхронні ітерабельні об'єкти, в тому числі вбудовані {{jsxref("String")}}, {{jsxref("Array")}}, подібні до масивів об'єкти (наприклад, {{jsxref("Functions/arguments", "arguments")}} чи {{DOMxRef("NodeList")}}), {{jsxref("TypedArray")}}, {{jsxref("Map")}}, {{jsxref("Set")}}, а також визначені користувачем асинхронні/синхронні ітерабельні об'єкти. Вона викликає користувацький хук до ітерацій з командами, що виконуватимуться для значення кожної окремої властивості об'єкта. Як і оператор {{jsxref("Operators/await", "await")}}, інструкція може використовуватись лише всередині {{jsxref("Statements/async_function", "асинхронної функції")}}.

- -
-

for await...of не працює з асинхронними ітераторами, які не є асинхронними ітерабельними об'єктами.

-
- - - -

Синтаксис

- -
for await (variable of iterable) {
-  statement
-}
-
- -
-
variable
-
На кожній ітерації значення іншої властивості присвоюється змінній variable. Змінна variable може бути оголошена через const, let або var.
-
iterable
-
Об'єкт, чиї ітерабельні властивості перебираються.
-
- -

Приклади

- -

Перебір асинхронних ітерабельних об'єктів

- -

Ви також можете перебирати об'єкт, який явно реалізує протокол асинхронного ітерабельного об'єкта:

- -
const asyncIterable = {
-  [Symbol.asyncIterator]() {
-    return {
-      i: 0,
-      next() {
-        if (this.i < 3) {
-          return Promise.resolve({ value: this.i++, done: false });
-        }
-
-        return Promise.resolve({ done: true });
-      }
-    };
-  }
-};
-
-(async function() {
-   for await (let num of asyncIterable) {
-     console.log(num);
-   }
-})();
-
-// 0
-// 1
-// 2
-
- -

Перебір асинхронних генераторів

- -

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

- -
async function* asyncGenerator() {
-  let i = 0;
-  while (i < 3) {
-    yield i++;
-  }
-}
-
-(async function() {
-  for await (let num of asyncGenerator()) {
-    console.log(num);
-  }
-})();
-// 0
-// 1
-// 2
- -

Для більш конкретного прикладу перебору асинхронного генератора за допомогою for await...of, розгляньте перебір даних з API.

- -

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

- -
async function* streamAsyncIterable(stream) {
-  const reader = stream.getReader();
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        return;
-      }
-      yield value;
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-// Отримує дані з URL та обчислює розмір відповіді за допомогою
-// асинхронного генератора.
-async function getResponseSize(url) {
-  const response = await fetch(url);
-  // Міститиме розмір відповіді, у байтах.
-  let responseSize = 0;
-  // Цикл for-await-of. Асинхронно перебирає кожну частку відповіді.
-  for await (const chunk of streamAsyncIterable(response.body)) {
-    // Збільшує загальну довжину відповіді.
-    responseSize += chunk.length;
-  }
-
-  console.log(`Розмір відповіді: ${responseSize} байтів`);
-  // очікуваний результат: "Розмір відповіді: 1071472 байтів"
-  return responseSize;
-}
-getResponseSize('https://jsonplaceholder.typicode.com/photos');
- -

Перебір синхронних ітерабельних об'єктів та генераторів

- -

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

- -
function* generator() {
-  yield 0;
-  yield 1;
-  yield Promise.resolve(2);
-  yield Promise.resolve(3);
-  yield 4;
-}
-
-(async function() {
-  for await (let num of generator()) {
-    console.log(num);
-  }
-})();
-// 0
-// 1
-// 2
-// 3
-// 4
-
-// порівняйте з циклом for-of:
-
-for (let numOrPromise of generator()) {
-  console.log(numOrPromise);
-}
-// 0
-// 1
-// Promise { 2 }
-// Promise { 3 }
-// 4
-
- -
- -
-

Заувага: остерігайтеся видавати відхилені проміси з синхронного генератора. У цьому випадку for await...of викидає виняток при споживанні відхиленого проміса та НЕ ВИКЛИКАЄ блоки finally всередині цього генератора. Це може бути небажаним, якщо вам треба звільнити певні виділені ресурси за допомогою try/finally.

-
- -
function* generatorWithRejectedPromises() {
-  try {
-    yield 0;
-    yield 1;
-    yield Promise.resolve(2);
-    yield Promise.reject(3);
-    yield 4;
-    throw 5;
-  } finally {
-    console.log('викликано finally')
-  }
-}
-
-(async function() {
-  try {
-    for await (let num of generatorWithRejectedPromises()) {
-      console.log(num);
-    }
-  } catch (e) {
-    console.log('перехоплено', e)
-  }
-})();
-// 0
-// 1
-// 2
-// перехоплено 3
-
-// порівняйте з циклом for-of:
-
-try {
-  for (let numOrPromise of generatorWithRejectedPromises()) {
-    console.log(numOrPromise);
-  }
-} catch (e) {
-  console.log('перехоплено', e)
-}
-// 0
-// 1
-// Promise { 2 }
-// Promise { <rejected> 3 }
-// 4
-// перехоплено 5
-// викликано finally
-
- -

Для того, щоб блоки finally у синхронному генераторі завжди викликались, використовуйте належну форму циклу, for await...of для асинхронних генераторів та for...of для синхронних, та чекайте на видані проміси явно всередині циклу.

- -
(async function() {
-  try {
-    for (let numOrPromise of generatorWithRejectedPromises()) {
-      console.log(await numOrPromise);
-    }
-  } catch (e) {
-    console.log('перехоплено', e)
-  }
-})()
-// 0
-// 1
-// 2
-// перехоплено 3
-// викликано finally
- -

Специфікації

- - - - - - - - - - - - -
Специфікація
{{SpecName('ESDraft', '#sec-for-in-and-for-of-statements', 'ECMAScript Language: The for-in, for-of, and for-await-of Statements')}}
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.for_await_of")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/for...in/index.html b/files/uk/web/javascript/reference/statements/for...in/index.html deleted file mode 100644 index f8bb6221be..0000000000 --- a/files/uk/web/javascript/reference/statements/for...in/index.html +++ /dev/null @@ -1,149 +0,0 @@ ---- -title: for...in -slug: Web/JavaScript/Reference/Statements/for...in -tags: - - JavaScript - - Інструкція - - Цикл -translation_of: Web/JavaScript/Reference/Statements/for...in ---- -
{{jsSidebar("Statements")}}
- -

Цикл for...in перебирає усі перелічувані властивості об'єкта, ключами яких є рядки (ігноруючи ті, ключами яких є символи), в тому числі успадковані перелічувані властивості.

- -
{{EmbedInteractiveExample("pages/js/statement-forin.html")}}
- - - -

Синтаксис

- -
for (variable in object)
-  statement
- -
-
variable
-
Нове ім'я властивості призначається параметру variable на кожній ітерації.
-
object
-
Об'єкт, чиї не символьні перелічувані властивості перебираються.
-
- -

Опис

- -

Цикл for...in перебирає лише перелічувані, не символьні властивості. Об'єкти, створені вбудованими конструкторами, як Array та Object, успадковують неперелічувані властивості від Object.prototype та String.prototype, такі як метод {{jsxref("String.indexOf", "indexOf()")}} у {{jsxref("String")}} або метод {{jsxref("Object.toString", "toString()")}} у {{jsxref("Object")}}. Цикл перебиратиме усі особисті перелічувані властивості об'єкта й ті, які об'єкт успадковує від прототипу конструктора (властивості, розташовані ближче до об'єкта у ланцюжку прототипів, заміщують властивості прототипу).

- -

Видалені, додані або модифіковані властивості

- -

Цикл for...in перебирає властивості об'єкта у довільному порядку (дивіться оператор {{jsxref("Operators/delete", "delete")}}, щоб дізнатись, чому не можна покладатися на удавану впорядкованість перебору, принаймні, у кросбраузерних налаштуваннях).

- -

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

- -

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

- -

Перебір масиву та for...in

- -
-

Заувага: цикл for...in не слід використовувати для перебору {{jsxref("Array", "масиву")}}, де порядок індексів є важливим.

-
- -

Індекси масивів є просто перелічуваними властивостями з цілочисельними іменами, в усьому іншому вони ідентичні загальним властивостям об'єкта. Немає гарантій, що for...in поверне індекси у певному порядку. Цикл for...in поверне усі перелічувані властивості, в тому числі не цілочисельні імена та успадковані властивості.

- -

Оскільки порядок перебору залежить від реалізації, перебір масиву може відвідувати елементи масиву непослідовно. Тому краще використовувати цикл {{jsxref("Statements/for", "for")}} з числовим індексом (або {{jsxref("Array.prototype.forEach()")}} чи {{jsxref("Statements/for...of", "for...of")}}) для перебору масивів, коли порядок звернення до елементів важливий.

- -

Перебір лише особистих властивостей

- -

Якщо ви бажаєте розглядати властивості, притаманні лише самому об'єкту, а не його прототипам, скористайтесь {{jsxref("Object.getOwnPropertyNames", "getOwnPropertyNames()")}} або виконайте перевірку {{jsxref("Object.prototype.hasOwnProperty", "hasOwnProperty()")}} (також можна використати {{jsxref("Object.prototype.propertyIsEnumerable", "propertyIsEnumerable()")}}). Альтернативно, якщо ви певні, що не буде зовнішнього втручання у код, ви можете розширити вбудовані прототипи методом перевірки.

- -

Навіщо використовувати for...in?

- -

Враховуючи, що цикл for...in створений для перебору властивостей об'єкта, не рекомендований для використання у масивах, і що існують такі варіанти як Array.prototype.forEach() та for...of, яка взагалі може бути користь від for...in?

- -

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

- -

Приклади

- -

Використання for...in

- -

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

- -
var obj = {a: 1, b: 2, c: 3};
-
-for (const prop in obj) {
-  console.log(`obj.${prop} = ${obj[prop]}`);
-}
-
-// Виведе:
-// "obj.a = 1"
-// "obj.b = 2"
-// "obj.c = 3"
- -

Перебір особистих властивостей

- -

Наступна функція ілюструє використання {{jsxref("Object.prototype.hasOwnProperty", "hasOwnProperty()")}}: успадковані властивості не виводяться.

- -
var triangle = {a: 1, b: 2, c: 3};
-
-function ColoredTriangle() {
-  this.color = 'red';
-}
-
-ColoredTriangle.prototype = triangle;
-
-var obj = new ColoredTriangle();
-
-for (const prop in obj) {
-  if (obj.hasOwnProperty(prop)) {
-    console.log(`obj.${prop} = ${obj[prop]}`);
-  }
-}
-
-// Виведе:
-// "obj.color = red"
- -

Специфікації

- - - - - - - - - - -
Специфікація
{{SpecName('ESDraft', '#sec-for-in-and-for-of-statements', 'for...in statement')}}
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.for_in")}}

- -

Сумісність: Ініціалізація лічильника у строгому режимі

- -

До Firefox 40 було можливо використати ініціалізацію лічильника (i=0) у циклі for...in:

- -
var obj = {a: 1, b: 2, c: 3};
-for (var i = 0 in obj) {
-  console.log(obj[i]);
-}
-// 1
-// 2
-// 3
-
- -

Ця нестандартна поведінка тепер ігнорується у версії 40 та пізніших і викличе помилку {{jsxref("SyntaxError")}} ("for-in loop head declarations may not have initializers") у строгому режимі ({{bug(748550)}} та {{bug(1164741)}}).

- -

Інші рушії, такі як v8 (Chrome), Chakra (IE/Edge) та JSC (WebKit/Safari), також проводять дослідження щодо прибирання цієї нестандартної поведінки.

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/for...of/index.html b/files/uk/web/javascript/reference/statements/for...of/index.html deleted file mode 100644 index dc4ebaf7b8..0000000000 --- a/files/uk/web/javascript/reference/statements/for...of/index.html +++ /dev/null @@ -1,319 +0,0 @@ ---- -title: for...of -slug: Web/JavaScript/Reference/Statements/for...of -tags: - - ECMAScript 2015 - - ES6 - - JavaScript - - Довідка -translation_of: Web/JavaScript/Reference/Statements/for...of ---- -
{{jsSidebar("Statements")}}
- -

Конструкція for...of створює цикл, що перебирає ітерабельні об'єкти, в тому числі: вбудовані {{jsxref("String")}}, {{jsxref("Array")}}, подібні до масиву об'єкти (наприклад, {{jsxref("Functions/arguments", "arguments")}} або {{domxref("NodeList")}}), {{jsxref("TypedArray")}}, {{jsxref("Map")}}, {{jsxref("Set")}}, а також визначені користувачем ітерабельні об'єкти. Він викликає користувацький хук до ітерацій з командами, що виконуються для значення кожної окремої властивості об'єкта.

- -
{{EmbedInteractiveExample("pages/js/statement-forof.html")}}
- - - -

Синтаксис

- -
for (variable of iterable) {
-  statement
-}
-
- -
-
variable
-
На кожній ітерації параметру variable призначається значення іншої властивості. Параметр variable може бути оголошений через const, let або var.
-
iterable
-
Об'єкт, чиї ітерабельні властивості перебираються.
-
- -

Приклади

- -

Перебір об'єкта {{jsxref("Array")}}

- -
let iterable = [10, 20, 30];
-
-for (let value of iterable) {
-  value += 1;
-  console.log(value);
-}
-// 11
-// 21
-// 31
-
- -

Ви також можете використати const замість let, якщо не переприсвоюєте змінну всередині блоку.

- -
let iterable = [10, 20, 30];
-
-for (const value of iterable) {
-  console.log(value);
-}
-// 10
-// 20
-// 30
-
- -

Перебір об'єкта {{jsxref("String")}}

- -
let iterable = 'фух';
-
-for (let value of iterable) {
-  console.log(value);
-}
-// "ф"
-// "у"
-// "х"
-
- -

Перебір об'єкта {{jsxref("TypedArray")}}

- -
let iterable = new Uint8Array([0x00, 0xff]);
-
-for (let value of iterable) {
-  console.log(value);
-}
-// 0
-// 255
-
- -

Перебір об'єкта {{jsxref("Map")}}

- -
let iterable = new Map([['а', 1], ['б', 2], ['в', 3]]);
-
-for (let entry of iterable) {
-  console.log(entry);
-}
-// ['а', 1]
-// ['б', 2]
-// ['в', 3]
-
-for (let [key, value] of iterable) {
-  console.log(value);
-}
-// 1
-// 2
-// 3
-
- -

Перебір об'єкта {{jsxref("Set")}}

- -
let iterable = new Set([1, 1, 2, 2, 3, 3]);
-
-for (let value of iterable) {
-  console.log(value);
-}
-// 1
-// 2
-// 3
-
- -

Перебір об'єкта arguments

- -

Ви можете перебирати об'єкт {{jsxref("Functions/arguments", "arguments")}}, щоб дослідити усі параметри, передані у функцію JavaScript:

- -
(function() {
-  for (let argument of arguments) {
-    console.log(argument);
-  }
-})(1, 2, 3);
-
-// 1
-// 2
-// 3
- -

Перебір колекції DOM-елементів

- -

Перебір колекцій DOM-елементів, таких як {{domxref("NodeList")}}: наступний приклад додає клас read до вузлів paragraph, які є прямими нащадками вузла article:

- -
// Заувага: Це працюватиме лише у платформах, де
-// реалізовано NodeList.prototype[Symbol.iterator]
-let articleParagraphs = document.querySelectorAll('article > p');
-
-for (let paragraph of articleParagraphs) {
-  paragraph.classList.add('read');
-}
-
- -

Закриття ітераторів

- -

У циклах for...of раптове переривання ітерації може бути спричинено операторами break, throw або return. У цих випадках ітератор закривається.

- -
function* foo(){
-  yield 1;
-  yield 2;
-  yield 3;
-};
-
-for (let o of foo()) {
-  console.log(o);
-  break; // закриває ітератор, виконання продовжується поза циклом
-}
-console.log('done');
-
- -

Перебір генераторів

- -

Ви також можете перебирати генератори, тобто, функції, що генерують ітерабельні об'єкти:

- -
function* fibonacci() { // функція-генератор
-  let [prev, curr] = [0, 1];
-  while (true) {
-    [prev, curr] = [curr, prev + curr];
-    yield curr;
-  }
-}
-
-for (let n of fibonacci()) {
-  console.log(n);
-  // обрізати послідовність на 1000
-  if (n >= 1000) {
-    break;
-  }
-}
-
- -

Не використовуйте генератори повторно

- -

Генератори не можна використовувати повторно, навіть якщо цикл for...of завчасно перервався, наприклад, ключовим словом {{jsxref("Statements/break", "break")}}. На виході з циклу генератор закривається, і спроби викликати його знову не дадуть подальших результатів.

- -
let gen = (function *(){
-  yield 1;
-  yield 2;
-  yield 3;
-})();
-for (let o of gen) {
-  console.log(o);
-  break;  // закриває ітератор
-}
-
-// Генератор не можна використовувати знову, наступне не має сенсу!
-for (let o of gen) {
-  console.log(o); // Ніколи не виконається.
-}
-
- -

Перебір інших ітерабельних об'єктів

- -

Ви також можете перебирати об'єкт, який відкрито реалізує протокол ітерабельного:

- -
let iterable = {
-  [Symbol.iterator]() {
-    return {
-      i: 0,
-      next() {
-        if (this.i < 3) {
-          return { value: this.i++, done: false };
-        }
-        return { value: undefined, done: true };
-      }
-    };
-  }
-};
-
-for (let value of iterable) {
-  console.log(value);
-}
-// 0
-// 1
-// 2
-
- -

Різниця між for...of та for...in

- -

І цикл for...in, і цикл for...of щось перебирають. Головна різниця між ними полягає в тому, що саме вони перебирають.

- -

Цикл {{jsxref("Statements/for...in", "for...in")}} перебирає перелічувані властивості об'єкта, у довільному порядку.

- -

Цикл for...of перебирає значення, які ітерабельний об'єкт визначає для перебирання.

- -

Наступний приклад демонструє різницю між циклом for...of та циклом for...in при використанні з {{jsxref("Array", "масивом")}}.

- -
Object.prototype.objCustom = function() {};
-Array.prototype.arrCustom = function() {};
-
-let iterable = [3, 5, 7];
-iterable.foo = 'привіт';
-
-for (let i in iterable) {
-  console.log(i); // виведе 0, 1, 2, "foo", "arrCustom", "objCustom"
-}
-
-for (let i in iterable) {
-  if (iterable.hasOwnProperty(i)) {
-    console.log(i); // виведе 0, 1, 2, "foo"
-  }
-}
-
-for (let i of iterable) {
-  console.log(i); // виведе 3, 5, 7
-}
-
- -

Розглянемо наведений код крок за кроком.

- -
Object.prototype.objCustom = function() {};
-Array.prototype.arrCustom = function() {};
-
-let iterable = [3, 5, 7];
-iterable.foo = 'привіт';
- -

Кожний об'єкт успадковуватиме властивість objCustom і кожний об'єкт, що є об'єктом {{jsxref("Array")}}, успадковуватиме властивість arrCustom, оскільки ці властивості були додані у {{jsxref("Object.prototype")}} та {{jsxref("Array.prototype")}} відповідно. Об'єкт iterable успадковує властивості objCustom та arrCustom через наслідування та ланцюжок прототипів.

- -
for (let i in iterable) {
-  console.log(i); // виведе 0, 1, 2, "foo", "arrCustom", "objCustom"
-}
- -

Цей цикл виводить тільки перелічувані властивості об'єкта iterable, у довільному порядку. Він не виводить елементи масиву 3, 5, 7 або привіт, оскільки вони не є перелічуваними властивостями, власне, вони взагалі не є властивостями, вони є значеннями. Цикл виводить індекси масиву, а також arrCustom та objCustom, які є властивостями. Якщо ви не певні, чому ці властивості перебираються, є більш детальне пояснення того, як працює {{jsxref("Statements/for...in", "перебір масиву та for...in", "#Перебір_масиву_та_for...in")}}.

- -
for (let i in iterable) {
-  if (iterable.hasOwnProperty(i)) {
-    console.log(i); // виведе 0, 1, 2, "foo"
-  }
-}
- -

Цей цикл схожий на перший, але використовує {{jsxref("Object.prototype.hasOwnProperty()", "hasOwnProperty()")}} для перевірки, чи є знайдена перелічувана властивість особистою властивістю об'єкта, тобто, не успадкованою. Якщо є, властивість виводиться. Властивості 0, 1, 2 та foo виводяться, оскільки вони є особистими властивостями (не успадкованими). Властивості arrCustom та objCustom не виводяться, оскільки вони успадковані.

- -
for (let i of iterable) {
-  console.log(i); // виведе 3, 5, 7
-}
- -

Цей цикл перебирає та виводить значення, які iterable як ітерабельний об'єкт визначає для перебору. Елементи об'єкта 3, 5, 7 виводяться, але немає жодної з властивостей об'єкта.

- -

Специфікації

- - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ES2015', '#sec-for-in-and-for-of-statements', 'for...of statement')}}{{Spec2('ES2015')}}Початкове визначення.
{{SpecName('ESDraft', '#sec-for-in-and-for-of-statements', 'for...of statement')}}{{Spec2('ESDraft')}}
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.for_of")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/for/index.html b/files/uk/web/javascript/reference/statements/for/index.html deleted file mode 100644 index 12e0bbefd7..0000000000 --- a/files/uk/web/javascript/reference/statements/for/index.html +++ /dev/null @@ -1,165 +0,0 @@ ---- -title: for -slug: Web/JavaScript/Reference/Statements/for -tags: - - JavaScript - - for - - Цикл -translation_of: Web/JavaScript/Reference/Statements/for ---- -
{{jsSidebar("Statements")}}
- -

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

- -
{{EmbedInteractiveExample("pages/js/statement-for.html")}}
- - - -

Синтаксис

- -
for ([initialization]; [condition]; [final-expression])
-   statement
- -
-
initialization
-
Вираз (в тому числі вирази присвоєння) або оголошення змінної, оцінюється один раз перед початком циклу. Зазвичай використовується для ініціалізації змінної лічильника. Цей вираз може також оголошувати нові змінні ключовими словами var або let. Змінні, оголошені через var не є локальними для циклу, тобто, вони знаходяться у тій же області видимості, що й сам цикл for. Змінні, оголошені через let, є локальними змінними циклу.
-
Результат цього виразу відкидається.
-
condition
-
Вираз, який оцінюється перед кожною ітерацією циклу. Якщо вираз оцінюється як true, то statement виконується. Ця перевірка є необов'язковою. Якщо вона пропущена, то умова завжди оцінюється як true. Якщо вираз оцінюється як false, виконання переходить до першого виразу, розташованого після конструкції for.
-
final-expression
-
Вираз, який оцінюється в кінці кожної ітерації циклу. Це відбувається до наступного оцінювання виразу condition. Зазвичай використовується, щоб оновити або збільшити значення змінної лічильника.
-
statement
-
Команда, яка виконується, поки умова оцінюється як true. Для виконання кількох команд, використовуйте {{jsxref("Statements/block", "блок", "", 0)}} ({ ... }), щоб згрупувати ці команди. Щоб не виконувати жодних команд, скористайтесь {{jsxref("Statements/empty", "порожнім", "", 0)}} оператором (;).
-
- -

Приклади

- -

Використання циклу for

- -

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

- -
for (let i = 0; i < 9; i++) {
-   console.log(i);
-   // ще команди
-}
-
- -

Необов'язкові вирази циклу for

- -

Всі три вирази у шапці циклу for є необов'язковими.

- -

Наприклад, у блоці initialization не вимагається ініціалізувати змінні:

- -
var i = 0;
-for (; i < 9; i++) {
-    console.log(i);
-    // ще команди
-}
-
- -

Як і блок initialization, блок умови condition також є необов'язковим. Якщо ви пропускаєте цей вираз, то маєте переконатись, що встановили переривання у тілі циклу, щоб не створити нескінченний цикл.

- -
for (let i = 0;; i++) {
-   console.log(i);
-   if (i > 3) break;
-   // ще команди
-}
- -

Ви також можете пропустити всі три блоки. Знову ж таки, переконайтеся, що ви встановили оператор {{jsxref("Statements/break", "break")}}, щоб закінчити цикл, а також змінили (збільшили) змінну, щоб умова для переривання в якийсь момент набула значення true.

- -
var i = 0;
-
-for (;;) {
-  if (i > 3) break;
-  console.log(i);
-  i++;
-}
-
- -

Використання циклу for без команд

- -

Наведений цикл for обчислює зміщення вузла у розділі final-expression, і тому не вимагає використання розділу statement, замість нього використовується крапка з комою.

- -
function showOffsetPos(sId) {
-
-  var nLeft = 0, nTop = 0;
-
-  for (
-
-    var oItNode = document.getElementById(sId); /* ініціалізація */
-
-    oItNode; /* умова */
-
-    nLeft += oItNode.offsetLeft, nTop += oItNode.offsetTop, oItNode = oItNode.offsetParent /* final-expression */
-
-  ); /* крапка з комою */
-
-  console.log('Зміщення елемента \'' + sId + '\':\n left: ' + nLeft + 'px;\n top: ' + nTop + 'px;');
-
-}
-
-/* Приклад виклику: */
-
-showOffsetPos('content');
-
-// Результат:
-// "Зміщення елемента "content":
-// left: 0px;
-// top: 153px;"
- -
Заувага: Це один з небагатьох випадків у JavaScript, коли крапка з комою є обов'язковою. Дійсно, без крапки з комою рядок, що записаний після циклу, вважатиметься командою циклу.
- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ES1', '#sec-12.6.2', 'for statement')}}{{Spec2('ES1')}}Початкове визначення.
{{SpecName('ES3', '#sec-12.6.3', 'for statement')}}{{Spec2('ES3')}}
{{SpecName('ES5.1', '#sec-12.6.3', 'for statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-for-statement', 'for statement')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-for-statement', 'for statement')}}{{Spec2('ESDraft')}}
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.for")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/function/index.html b/files/uk/web/javascript/reference/statements/function/index.html deleted file mode 100644 index c038ec106d..0000000000 --- a/files/uk/web/javascript/reference/statements/function/index.html +++ /dev/null @@ -1,179 +0,0 @@ ---- -title: Оголошення функції -slug: Web/JavaScript/Reference/Statements/function -tags: - - JavaScript - - Функція -translation_of: Web/JavaScript/Reference/Statements/function ---- -
{{jsSidebar("Statements")}}
- -

Оголошення функції (функціональний оператор) визначає функцію з вказаними параметрами.

- -

Ви також можете визначати функції за допомогою конструктора {{jsxref("Function")}} та {{jsxref("Operators/function", "функціонального виразу")}}.

- -
{{EmbedInteractiveExample("pages/js/statement-function.html")}}
- - - -

Синтаксис

- -
function name([param[, param,[..., param]]]) {
-   [statements]
-}
-
- -
-
name
-
Ім'я функції.
-
- -
-
param
-
Ім'я аргументу, що передається у функцію. Максимальна кількість аргументів відрізняється у різних рушіях.
-
- -
-
statements
-
Інструкції, які складають тіло функції.
-
- -

Опис

- -

Функція, утворена через оголошення функції, є об'єктом Function, і має усі властивості, методи та поведінку об'єктів Function. Більш детальну інформацію щодо функцій дивіться у статті {{jsxref("Function")}}.

- -

Функція також може бути створена через за допомогою виразу (дивіться {{jsxref("Operators/function", "функціональний вираз")}}).

- -

За замовчуванням функції повертають undefined. Щоб повернути будь-яке інше значення, функція повинна мати оператор {{jsxref("Statements/return", "return")}}, який вказує значення, що буде повернене.

- -

Умовне створення функцій

- -

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

- -
var hoisted = "foo" in this;
-console.log(`Ім'я 'foo'${hoisted ? "" : " не"} піднімається. typeof foo дорівнює ${typeof foo}`);
-if (false) {
-  function foo(){ return 1; }
-}
-
-// У Chrome:
-// Ім'я 'foo' піднімається. typeof foo дорівнює undefined
-//
-// У Firefox:
-// Ім'я 'foo' піднімається. typeof foo дорівнює undefined
-//
-// У Edge:
-// Ім'я 'foo' не піднімається. typeof foo дорівнює undefined
-//
-// У Safari:
-// Ім'я 'foo' піднімається. typeof foo дорівнює function
-
- -

Результат буде такий самий для умови, яка дорівнює true

- -
var hoisted = "foo" in this;
-console.log(`Ім'я 'foo' ${hoisted ? "" : " не"} піднімається. typeof foo дорівнює ${typeof foo}`);
-if (true) {
-  function foo(){ return 1; }
-}
-
-// У Chrome:
-// Ім'я 'foo' піднімається. typeof foo дорівнює undefined
-//
-// У Firefox:
-// Ім'я 'foo' піднімається. typeof foo дорівнює undefined
-//
-// У Edge:
-// Ім'я 'foo' не піднімається. typeof foo дорівнює undefined
-//
-// У Safari:
-// Ім'я 'foo' піднімається. typeof foo дорівнює function
-
- -

Підняття оголошення функції

- -

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

- -
hoisted(); // виводить "foo"
-
-function hoisted() {
-  console.log('foo');
-}
-
- -

Зауважте, що {{jsxref("Operators/function", "функціональні вирази")}} не піднімаються:

- -
notHoisted(); // TypeError: notHoisted is not a function
-
-var notHoisted = function() {
-   console.log('bar');
-};
-
- -

Приклади

- -

Використання function

- -

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

- -
function calc_sales(units_a, units_b, units_c) {
-   return units_a * 79 + units_b * 129 + units_c * 699;
-}
-
- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ESDraft', '#sec-function-definitions', 'Function definitions')}}{{Spec2('ESDraft')}}
{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}{{Spec2('ES6')}}
{{SpecName('ES5.1', '#sec-13', 'Function definition')}}{{Spec2('ES5.1')}}
{{SpecName('ES3', '#sec-13', 'Function definition')}}{{Spec2('ES3')}}
{{SpecName('ES1', '#sec-13', 'Function definition')}}{{Spec2('ES1')}}Початкове визначення. Реалізоване у JavaScript 1.0.
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.function")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/function_star_/index.html b/files/uk/web/javascript/reference/statements/function_star_/index.html deleted file mode 100644 index f900241ddc..0000000000 --- a/files/uk/web/javascript/reference/statements/function_star_/index.html +++ /dev/null @@ -1,268 +0,0 @@ ---- -title: function* -slug: Web/JavaScript/Reference/Statements/function* -tags: - - ECMAScript 2015 - - Function - - JavaScript - - Ітератор - - генератор -translation_of: Web/JavaScript/Reference/Statements/function* ---- -
{{jsSidebar("Statements")}}
- -

Оголошення function* (ключове слово function з зірочкою) визначає функцію-генератор, яка повертає об'єкт {{jsxref("Global_Objects/Generator","Generator")}}.

- -
{{EmbedInteractiveExample("pages/js/statement-functionasterisk.html")}}
- - - -

Ви також можете визначати функції-генератори за допомогою конструктора {{jsxref("GeneratorFunction")}} або функціонального виразу.

- -

Синтаксис

- -
function* name([param[, param[, ... param]]]) {
-   statements
-}
-
- -
-
name
-
Ім'я функції.
-
- -
-
param
-
Ім'я формального параметра функції.
-
- -
-
statements
-
Інструкції, що складають тіло функції.
-
- -

Опис

- -

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

- -

Виклик функції-генератора не виконує тіло функції негайно; замість цього повертається об'єкт-ітератор для функції. Коли викликається метод ітератора next(), тіло функції-генератора виконується до першого виразу {{jsxref("Operators/yield", "yield")}}, який визначає значення, що має бути повернене ітератором, або, оператором {{jsxref("Operators/yield*", "yield*")}}, делегується до іншої функції-генератора. Метод next() повертає об'єкт з властивістю value, що містить отримане значення, та властивістю done, яка вказує, чи генератор віддав останнє значення, у вигляді булевого значення. Виклик метода next() з аргументом відновить виконання функції-генератора, замінюючи вираз yield в тій точці, де виконання було призупинене, аргументом з next().

- -

Оператор return у генераторі змусить генератор завершити виконання (тобто, властивості done поверненого об'єкта буде присвоєне значення true). Якщо повертається значення, воно буде присвоєте властивості value об'єкта, що повертається генератором.
- Схоже на оператор return, викидання помилки всередині генератора змусить генератор завершити виконання -- якщо не буде перехоплене у тілі генератора.
- Коли генератор завершує виконання, наступні виклики next не виконають жодного коду генератора, вони лише повернуть об'єкт наступного вигляду: {value: undefined, done: true}.

- -

Приклади

- -

Простий приклад

- -
function* idMaker() {
-  var index = 0;
-  while (true)
-    yield index++;
-}
-
-var gen = idMaker();
-
-console.log(gen.next().value); // 0
-console.log(gen.next().value); // 1
-console.log(gen.next().value); // 2
-console.log(gen.next().value); // 3
-// ...
- -

Приклад з yield*

- -
function* anotherGenerator(i) {
-  yield i + 1;
-  yield i + 2;
-  yield i + 3;
-}
-
-function* generator(i) {
-  yield i;
-  yield* anotherGenerator(i);
-  yield i + 10;
-}
-
-var gen = generator(10);
-
-console.log(gen.next().value); // 10
-console.log(gen.next().value); // 11
-console.log(gen.next().value); // 12
-console.log(gen.next().value); // 13
-console.log(gen.next().value); // 20
-
- -

Передача аргументів у об'єкти Generator

- -
function* logGenerator() {
-  console.log(0);
-  console.log(1, yield);
-  console.log(2, yield);
-  console.log(3, yield);
-}
-
-var gen = logGenerator();
-
-// перший виклик метода next виконує функцію з початку
-// до першого оператора yield
-gen.next();             // 0
-gen.next('крендель');   // 1 крендель
-gen.next('кава');       // 2 кава
-gen.next('майонез');    // 3 майонез
-
- -

Оператор return у генераторі

- -
function* yieldAndReturn() {
-  yield "Y";
-  return "R";
-  yield "недосяжний";
-}
-
-var gen = yieldAndReturn()
-console.log(gen.next()); // { value: "Y", done: false }
-console.log(gen.next()); // { value: "R", done: true }
-console.log(gen.next()); // { value: undefined, done: true }
-
- -

Генератор як властивість об'єкта

- -
const someObj = {
-  *generator () {
-    yield 'а';
-    yield 'б';
-  }
-}
-
-const gen = someObj.generator()
-
-console.log(gen.next()); // { value: 'а', done: false }
-console.log(gen.next()); // { value: 'б', done: false }
-console.log(gen.next()); // { value: undefined, done: true }
-
- -

Генератор як метод класу

- -
class Foo {
-  *generator () {
-    yield 1;
-    yield 2;
-    yield 3;
-  }
-}
-
-const f = new Foo ();
-const gen = f.generator();
-
-console.log(gen.next()); // { value: 1, done: false }
-console.log(gen.next()); // { value: 2, done: false }
-console.log(gen.next()); // { value: 3, done: false }
-console.log(gen.next()); // { value: undefined, done: true }
-
- -

Генератор як обчислювана властивість

- -
class Foo {
-  *[Symbol.iterator] () {
-    yield 1;
-    yield 2;
-  }
-}
-
-const SomeObj = {
-  *[Symbol.iterator] () {
-    yield 'а';
-    yield 'б';
-  }
-}
-
-console.log(Array.from(new Foo)); // [ 1, 2 ]
-console.log(Array.from(SomeObj)); // [ 'а', 'б' ]
-
- -

Генератори не є конструкторами

- -
function* f() {}
-var obj = new f; // викидає "TypeError: f is not a constructor
-
- -

Генератор, визначений у виразі

- -
const foo = function* () {
-  yield 10;
-  yield 20;
-};
-
-const bar = foo();
-console.log(bar.next()); // {value: 10, done: false}
- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ES2015', '#sec-generator-function-definitions', 'function*')}}{{Spec2('ES2015')}}Початкове визначення.
{{SpecName('ES2016', '#sec-generator-function-definitions', 'function*')}}{{Spec2('ES2016')}}Внесено зміни, що генератори не повинні мати пастки [[Construct]] та викидатимуть помилку при використанні з new.
{{SpecName('ESDraft', '#sec-generator-function-definitions', 'function*')}}{{Spec2('ESDraft')}}
- -

Сумісність з веб-переглядачами

- -
- - -

{{Compat("javascript.statements.generator_function")}}

-
- -

Примітки щодо Firefox

- -

Генератори та ітератори у Firefox до 26-ї версії

- -

Старші версії Firefox реалізують старшу версію пропозиції генераторів. У старшій версії генератори визначались за допомогою звичайного ключового слова function (без зірочки), серед інших відмінностей. Дивіться більше інформації у статті Застаріла функція-генератор.

- -

Замість викидання помилки повертається об'єкт IteratorResult

- -

Починаючи з Gecko 29 {{geckoRelease(29)}}, завершена функція-генератор більше не викидає помилку {{jsxref("TypeError")}} "generator has already finished". Замість цього, вона повертає об'єкт IteratorResult у вигляді { value: undefined, done: true } ({{bug(958951)}}).

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/if...else/index.html b/files/uk/web/javascript/reference/statements/if...else/index.html deleted file mode 100644 index bee07d07bf..0000000000 --- a/files/uk/web/javascript/reference/statements/if...else/index.html +++ /dev/null @@ -1,173 +0,0 @@ ---- -title: if...else -slug: Web/JavaScript/Reference/Statements/if...else -tags: - - JavaScript - - else - - if - - Оператор -translation_of: Web/JavaScript/Reference/Statements/if...else ---- -
{{jsSidebar("Statements")}}
- -

Умовний оператор if виконує команду, якщо вказана умова є {{Glossary("truthy", "правдивою")}}. Якщо умова є {{Glossary("falsy", "хибною")}}, може бути виконана інша команда.

- -
{{EmbedInteractiveExample("pages/js/statement-ifelse.html")}}
- - - -

Синтаксис

- -
if (condition)
-   statement1
-[else
-   statement2]
-
- -
-
condition
-
Вираз, який вважається або {{Glossary("truthy", "правдивим")}}, або {{Glossary("falsy", "хибним")}}.
-
- -
-
statement1
-
Команда, що виконується, якщо умова є {{Glossary("truthy", "правдивою")}}. Може бути будь-яка команда, в тому числі вкладені оператори if. Для виконання кількох команд використовуйте блок ({ ... }), щоб згрупувати ці команди. Щоб не виконувати жодних команд, використайте порожній оператор.
-
- -
-
statement2
-
Команда, що виконується, якщо умова є {{Glossary("falsy", "хибною")}} та присутній блок else. Може бути будь-яка команда, в тому числі блок команд та вкладені оператори if.
-
- -

Опис

- -

Можна додавати вкладені вирази if...else для створення конструкції else if. Зауважте, що у JavaScript не існує ключового слова elseif (одним словом).

- -
if (condition1)
-  statement1
-else if (condition2)
-  statement2
-else if (condition3)
-  statement3
-...
-else
-  statementN
-
- -

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

- -
if (condition1)
-  statement1
-else
-  if (condition2)
-    statement2
-  else
-    if (condition3)
-...
-
- -

Щоб виконати декілька команд, використовуйте позначення блоку ({ ... }), щоб згрупувати ці команди. Взагалі, гарною практикою вважається завжди використовувати блочні вирази, особливо у коді, який містить вкладені оператори if:

- -
if (condition) {
-  statements1
-} else {
-  statements2
-}
-
- -

Не плутайте примітивні булеві значення true та false з правдивістю та хибністю об'єкта {{jsxref("Global_Objects/Boolean", "Boolean")}}. Будь-яке значення, яке не є false, undefined, null, 0, -0, NaN, або порожнім текстовим рядком (""), і будь-який об'єкт, в тому числі об'єкт Boolean, чиє значення дорівнює false, вважається {{Glossary("truthy", "правдивим")}} при використанні у якості умови. Для прикладу:

- -
var b = new Boolean(false);
-if (b) // ця умова є правдивою
-
- -

Приклади

- -

Використання if...else

- -
if (cipher_char === from_char) {
-  result = result + to_char;
-  x++;
-} else {
-  result = result + clear_char;
-}
-
- -

Використання else if

- -

Зауважте, що у JavaScript немає оператора elseif. Однак, ви можете його записати з пробілом між else та if:

- -
if (x > 50) {
-  /* зробити що треба */
-} else if (x > 5) {
-  /* зробити що треба */
-} else {
-  /* зробити що треба */
-}
- -

Присвоєння всередині умовного виразу

- -

Не рекомендовано використовувати прості присвоєння в умовному виразі, тому що присвоєння можна переплутати з порівнянням при швидкому перегляді коду. Наприклад, не використовуйте наступний код:

- -
if (x = y) {
-  /* зробити що треба */
-}
-
- -

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

- -
if ((x = y)) {
-  /* зробити що треба */
-}
-
- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ESDraft', '#sec-if-statement', 'if statement')}}{{Spec2('ESDraft')}}
{{SpecName('ES6', '#sec-if-statement', 'if statement')}}{{Spec2('ES6')}}
{{SpecName('ES5.1', '#sec-12.5', 'if statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES3', '#sec-12.5', 'if statement')}}{{Spec2('ES3')}}
{{SpecName('ES1', '#sec-12.5', 'if statement')}}{{Spec2('ES1')}}Початкове визначення
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.if_else")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/index.html b/files/uk/web/javascript/reference/statements/index.html deleted file mode 100644 index 7a16fcc672..0000000000 --- a/files/uk/web/javascript/reference/statements/index.html +++ /dev/null @@ -1,130 +0,0 @@ ---- -title: Інструкції та оголошення -slug: Web/JavaScript/Reference/Statements -tags: - - JavaScript - - Довідка - - оголошення - - інструкції -translation_of: Web/JavaScript/Reference/Statements ---- -
{{jsSidebar("Statements")}}
- -

Застосунки JavaScript складаються з інструкцій з відповідним синтаксисом. Одна інструкція може займати декілька рядків. Декілька інструкцій можуть розташовуватись на одному рядку, якщо кожна інструкція відділена крапкою з комою. Це не ключове слово, а група ключових слів.

- -

Інструкції та оголошення за категоріями

- -

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

- -

Потік керування

- -
-
{{jsxref("Statements/block", "Block")}}
-
Блок використовують, щоб згрупувати нуль чи більше інструкцій. Блок позначається парою фігурних дужок.
-
{{jsxref("Statements/break", "break")}}
-
Перериває поточний цикл, switch або помічену інструкцію та передає контроль програми у інструкцію, наступну за перерваною інструкцією.
-
{{jsxref("Statements/continue", "continue")}}
-
Перериває виконання інструкцій у поточній ітерації поточного або поміченого циклу та продовжує виконання циклу з наступної ітерації.
-
{{jsxref("Statements/Empty", "Empty")}}
-
Порожній оператор використовується, щоб не надавати інструкцію там, де синтаксис JavaScript її очікує.
-
{{jsxref("Statements/if...else", "if...else")}}
-
Виконує інструкцію, якщо вказана умова дорівнює true. Якщо умова дорівнює false, виконується інша інструкція.
-
{{jsxref("Statements/switch", "switch")}}
-
Обчислює вираз, шукаючі збіг значення виразу з блоком case, та виконує інструкції, асоційовані з цим блоком.
-
{{jsxref("Statements/throw", "throw")}}
-
Викидає визначений користувачем виняток.
-
{{jsxref("Statements/try...catch", "try...catch")}}
-
Позначає блок інструкцій, які необхідно спробувати виконати, та визначає відповідь у випадку, якщо викидається виняток.
-
- -

Оголошення

- -
-
{{jsxref("Statements/var", "var")}}
-
Оголошує змінну, необов'язково ініціалізуючи її значенням.
-
{{jsxref("Statements/let", "let")}}
-
Оголошує локальну змінну блочної області видимості, необов'язково ініціалізуючи її значенням.
-
{{jsxref("Statements/const", "const")}}
-
Оголошує іменовану константу, доступну лише для читання.
-
- -

Функції та класи

- -
-
{{jsxref("Statements/function", "function")}}
-
Оголошує функцію з вказаними параметрами.
-
{{jsxref("Statements/function*", "function*")}}
-
Функції-генератори спрощують написання ітераторів.
-
{{jsxref("Statements/async_function", "async function")}}
-
Оголошує асинхронну функцію з вказаними параметрами.
-
{{jsxref("Statements/return", "return")}}
-
Вказує значення, яке має повернути функція.
-
{{jsxref("Statements/class", "class")}}
-
Оголошує клас.
-
- -

Перебори

- -
-
{{jsxref("Statements/do...while", "do...while")}}
-
Створює цикл, що виконує вказану інструкцію, яка виконується, доки перевірочна умова не стане дорівнювати false. Умова обчислюється після виконання інструкції, в результаті вказана інструкція виконується принаймні один раз.
-
{{jsxref("Statements/for", "for")}}
-
Створює цикл, що складається з трьох необов'язкових виразів, записаних у дужках та розділених крапками з комами, після яких вказується інструкція для виконання циклом.
-
{{jsxref("Statements/for_each...in", "for each...in")}}
-
Перебирає вказаною змінною усі значення властивостей об'єкта. Для кожної окремої властивості виконується вказана інструкція.
-
{{jsxref("Statements/for...in", "for...in")}}
-
Перебирає перелічувані властивості об'єкта у довільному порядку. Для кожної окремої властивості можуть виконуватись інструкції.
-
{{jsxref("Statements/for...of", "for...of")}}
-
Перебирає ітерабельні об'єкти (в тому числі {{jsxref("Global_Objects/Array","масиви","","true")}}, подібні до масивів об'єкти, ітератори та генератори), викликаючи користувацький хук до ітерацій з інструкціями, що виконуватимуться для значення кожної окремої властивості.
-
{{jsxref("Statements/for-await...of", "for await...of")}}
-
Перебирає асинхронні ітерабельні об'єкти, подібні до масивів об'єкти, ітератори та генератори, викликаючи користувацький хук до ітерацій з інструкціями, що виконуватимуться для значення кожної окремої властивості.
-
{{jsxref("Statements/while", "while")}}
-
Створює цикл, який виконує вказану інструкцію, доки перевірочна умова дорівнює true. Умова обчислюється перед виконанням інструкції.
-
- -

Інші

- -
-
{{jsxref("Statements/debugger", "debugger")}}
-
Запускає будь-яку доступну налагоджувальну функціональність. Якщо налагоджувальна функціональність недоступна, цей оператор не матиме ефекту.
-
{{jsxref("Statements/export", "export")}}
-
Використовується для експорту функцій, щоб зробити їх доступними для імпорту у зовнішні модулі та інші скрипти.
-
{{jsxref("Statements/import", "import")}}
-
Використовується для імпорту функцій, експортованих з зовнішнього модуля чи іншого скрипта.
-
import.meta
-
Об'єкт, що відкриває залежні від контексту метадані про модуль JavaScript.
-
{{jsxref("Statements/label", "label")}}
-
Надає інструкцію з ідентифікатором, на який можна посилатись при використанні інструкцій break або continue.
-
- -
-
{{jsxref("Statements/with", "with")}}
-
Розширює ланцюжок областей видимості для інструкції.
-
- -

Специфікації

- - - - - - - - - - -
Специфікація
{{SpecName('ESDraft', '#sec-ecmascript-language-statements-and-declarations', 'ECMAScript Language: Statements and Declarations')}}
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/label/index.html b/files/uk/web/javascript/reference/statements/label/index.html deleted file mode 100644 index b29fa8fb42..0000000000 --- a/files/uk/web/javascript/reference/statements/label/index.html +++ /dev/null @@ -1,182 +0,0 @@ ---- -title: Мітка -slug: Web/JavaScript/Reference/Statements/label -tags: - - JavaScript -translation_of: Web/JavaScript/Reference/Statements/label ---- -
{{jsSidebar("Statements")}}
- -

Мітка (label) може використовуватися з операторами {{jsxref("Statements/break", "break")}} та {{jsxref("Statements/continue", "continue")}}. Вона додається попереду виразу у вигляді ідентифікатора, на який можна посилатися.

- -
{{EmbedInteractiveExample("pages/js/statement-label.html")}}
- - - -
-

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

-
- -

Синтаксис

- -
label :
-   statement
-
- -
-
label
-
Будь-який ідентифікатор JavaScript, який не є зарезервованим словом.
-
statement
-
Інструкція JavaScript. Оператор break може використовуватися з будь-якою поміченою конструкцією, а оператор continue може використовуватися з поміченими циклами.
-
- -

Опис

- -

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

- -

Зауважте, що у JavaScript немає оператора goto, ви можете використовувати мітки лише з break або continue.

- -

У строгому режимі не можна використовувати "let" в якості імені мітки. Це спричинить викидання {{jsxref("SyntaxError")}} (let є зарезервованим ідентифікатором).

- -

Приклади

- -

Використання поміченого continue з циклами for

- -
var i, j;
-
-loop1:
-for (i = 0; i < 3; i++) {      //Перший цикл for помічений як "loop1"
-   loop2:
-   for (j = 0; j < 3; j++) {   //Другий цикл for помічений як "loop2"
-      if (i === 1 && j === 1) {
-         continue loop1;
-      }
-      console.log('i = ' + i + ', j = ' + j);
-   }
-}
-
-// Результат:
-//   "i = 0, j = 0"
-//   "i = 0, j = 1"
-//   "i = 0, j = 2"
-//   "i = 1, j = 0"
-//   "i = 2, j = 0"
-//   "i = 2, j = 1"
-//   "i = 2, j = 2"
-// Зауважте, що пропущені як "i = 1, j = 1", так і "i = 1, j = 2"
-
- -

Використання поміченого оператора continue

- -

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

- -
var itemsPassed = 0;
-var i, j;
-
-top:
-for (i = 0; i < items.length; i++) {
-  for (j = 0; j < tests.length; j++) {
-    if (!tests[j].pass(items[i])) {
-      continue top;
-    }
-  }
-
-  itemsPassed++;
-}
- -

Використання поміченого оператора break з циклами for

- -
var i, j;
-
-loop1:
-for (i = 0; i < 3; i++) {      //Перший цикл for помічений як "loop1"
-   loop2:
-   for (j = 0; j < 3; j++) {   //Другий цикл for помічений як "loop2"
-      if (i === 1 && j === 1) {
-         break loop1;
-      }
-      console.log('i = ' + i + ', j = ' + j);
-   }
-}
-
-// Результат:
-//   "i = 0, j = 0"
-//   "i = 0, j = 1"
-//   "i = 0, j = 2"
-//   "i = 1, j = 0"
-// Зауважте різницю з попереднім прикладом з continue
- -

Використання поміченого оператора break

- -

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

- -
var allPass = true;
-var i, j;
-
-top:
-for (i = 0; items.length; i++)
-  for (j = 0; j < tests.length; i++)
-    if (!tests[j].pass(items[i])) {
-      allPass = false;
-      break top;
-    }
- -

Використання поміченого блоку з оператором break

- -

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

- -
foo: {
-  console.log('пере');
-  break foo;
-  console.log('ця частина не виконається');
-}
-console.log('стрибнув');
-
-// цей код виведе:
-
-// "пере"
-// "стрибнув
- -

Помічені оголошення функцій

- -

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

- -
L: function F() {}
- -

Однак, у строгому режимі це викине помилку {{jsxref("SyntaxError")}}:

- -
'use strict';
-L: function F() {}
-// SyntaxError: functions cannot be labelled
- -

Функції-генератори також не можуть мати мітки ні у строгому, ні у звичайному режимі:

- -
L: function* F() {}
-// SyntaxError: generator functions cannot be labelled
-
- -

Специфікації

- - - - - - - - - - -
Специфікація
{{SpecName('ESDraft', '#sec-labelled-statements', 'Labelled statement')}}
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.label")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/let/index.html b/files/uk/web/javascript/reference/statements/let/index.html deleted file mode 100644 index ee0db303e6..0000000000 --- a/files/uk/web/javascript/reference/statements/let/index.html +++ /dev/null @@ -1,272 +0,0 @@ ---- -title: let -slug: Web/JavaScript/Reference/Statements/let -tags: - - ECMAScript 2015 - - JavaScript - - let - - змінні -translation_of: Web/JavaScript/Reference/Statements/let ---- -
{{jsSidebar("Statements")}}
- -

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

- -
{{EmbedInteractiveExample("pages/js/statement-let.html")}}
- - - -

Синтаксис

- -
let var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN];
- -

Параметри

- -
-
var1, var2, …, varN
-
Імена змінної або змінних, що оголошуються. Кожне ім'я має бути дозволеним ідентифікатором JavaScript.
-
value1, value2, …, valueN {{optional_inline}}
-
Для кожної оголошеної змінної ви можете вказати її початкове значення будь-яким дозволеним виразом JavaScript.
-
- -

Опис

- -

Оператор let дозволяє оголошувати змінні, що обмежені областю видимості {{jsxref("statements/block", "блоку")}} або виразу, для якого використовуються, на відміну від ключового слова {{jsxref("statements/var", "var")}}, яке визначає змінну глобально, чи локально для всієї функції, незалежно від області видимості блоку. Інша відмінність між операторами {{jsxref("statements/var", "var")}} та let полягає в тому, що останній ініціалізується тільки після оцінювання синтаксичним аналізатором (дивіться нижче).

- -

Як і {{jsxref("statements/const", "const", "Description")}}, let не створює властивостей об'єкта {{domxref('window')}} при глобальному оголошенні (у області видимості верхнього рівня).

- -

Пояснення, чому була обрана назва "let" можна подивитись тут.

- -

Правила області видимості

- -

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

- -
function varTest() {
-  var x = 1;
-  {
-    var x = 2;  // та сама змінна!
-    console.log(x);  // 2
-  }
-  console.log(x);  // 2
-}
-
-function letTest() {
-  let x = 1;
-  {
-    let x = 2;  // інша змінна
-    console.log(x);  // 2
-  }
-  console.log(x);  // 1
-}
-
- -

На верхньому рівні програм та функцій let, на відміну від var, не створює властивості глобального об'єкта. Наприклад:

- -
var x = 'глобальна';
-let y = 'глобальна';
-console.log(this.x); // "глобальна"
-console.log(this.y); // undefined
-
- -

Імітація приватних членів

- -

Працюючи з конструкторами, можна використовувати let-зв'язування для створення приватних членів без використання замикань:

- -
var Thing;
-
-{
-  let privateScope = new WeakMap();
-  let counter = 0;
-
-  Thing = function() {
-    this.someProperty = 'foo';
-
-    privateScope.set(this, {
-      hidden: ++counter,
-    });
-  };
-
-  Thing.prototype.showPublic = function() {
-    return this.someProperty;
-  };
-
-  Thing.prototype.showPrivate = function() {
-    return privateScope.get(this).hidden;
-  };
-}
-
-console.log(typeof privateScope);
-// "undefined"
-
-var thing = new Thing();
-
-console.log(thing);
-// Thing {someProperty: "foo"}
-
-thing.showPublic();
-// "foo"
-
-thing.showPrivate();
-// 1
-
- -

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

- -

Повторні оголошення

- -

Повторне оголошення тієї самої змінної у області видимості тієї самої функції чи блоку спричиняє помилку {{jsxref("SyntaxError")}}.

- -
if (x) {
-  let foo;
-  let foo; // викидається SyntaxError.
-}
-
- -

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

- -
let x = 1;
-switch(x) {
-  case 0:
-    let foo;
-    break;
-
-  case 1:
-    let foo; // SyntaxError через повторне оголошення.
-    break;
-}
- -

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

- -
let x = 1;
-
-switch(x) {
-  case 0: {
-    let foo;
-    break;
-  }
-  case 1: {
-    let foo;
-    break;
-  }
-}
- -

Тимчасова мертва зона

- -

На відміну від змінних, оголошених через var, які спочатку мають значення undefined, let-змінні не ініціалізуються, поки не відбудеться обчислення їхнього оголошення. Звернення до змінної до ініціалізації призводить до викидання ReferenceError. Змінна знаходиться у "тимчасовій мертвій зоні" від початку блоку і до проходження ініціалізації.

- -
function do_something() {
-  console.log(bar); // undefined
-  console.log(foo); // ReferenceError
-  var bar = 1;
-  let foo = 2;
-}
- -

Тимчасова мертва зона та typeof

- -

На відміну від просто неоголошених змінних та змінних, що містять значення undefined, використання оператора typeof для перевірки типу змінної, що знаходиться у своїй ТМЗ, викине ReferenceError:

- -
// виведе 'undefined'
-console.log(typeof undeclaredVariable);
-// призведе до 'ReferenceError'
-console.log(typeof i);
-let i = 10;
- -

Ще один приклад тимчасової мертвої зони у поєднанні з лексичною областю видимості

- -

Через наявність лексичної області видимості, ідентифікатор foo у виразі (foo + 55) оцінюється як ідентифікатор foo блоку if, а не розташована вище змінна foo зі значенням 33.

- -

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

- -

Змінна foo блоку if досі у тимчасовій мертвій зоні.

- -
function test(){
-   var foo = 33;
-   if (true) {
-      let foo = (foo + 55); // ReferenceError
-   }
-}
-test();
- -

Цей феномен може заплутати, наприклад, у наступній ситуації. Інструкція let n of n.a вже знаходиться всередині приватної області видимості блоку циклу for. Отже, ідентифікатор n.a вважається властивістю 'a' об'єкта 'n', розташованого у першій частині цієї ж інструкції ("let n").

- -

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

- -
function go(n) {
-  // n тут визначений!
-  console.log(n); // Object {a: [1,2,3]}
-
-  for (let n of n.a) { // ReferenceError
-    console.log(n);
-  }
-}
-
-go({a: [1, 2, 3]});
-
- -

Інші ситуації

- -

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

- -
var a = 1;
-var b = 2;
-
-if (a === 1) {
-  var a = 11; // глобальна область видимості
-  let b = 22; // областю видимості є блок if
-
-  console.log(a);  // 11
-  console.log(b);  // 22
-}
-
-console.log(a); // 11
-console.log(b); // 2
-
- -

Однак, комбінація оголошень var та let, наведена нижче, спричинить SyntaxError через підняття var наверх блоку. Це призводить до неявного повторного оголошення змінної.

- -
let x = 1;
-
-{
-  var x = 2; // SyntaxError через повторне оголошення
-}
-
- -

Специфікації

- - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ES2015', '#sec-let-and-const-declarations', 'Let and Const Declarations')}}{{Spec2('ES2015')}}Початкове визначення. Не визначає let-вирази та let-блоки.
{{SpecName('ESDraft', '#sec-let-and-const-declarations', 'Let and Const Declarations')}}{{Spec2('ESDraft')}}
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.let")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/return/index.html b/files/uk/web/javascript/reference/statements/return/index.html deleted file mode 100644 index 030027232f..0000000000 --- a/files/uk/web/javascript/reference/statements/return/index.html +++ /dev/null @@ -1,159 +0,0 @@ ---- -title: return -slug: Web/JavaScript/Reference/Statements/return -tags: - - JavaScript - - Оператор -translation_of: Web/JavaScript/Reference/Statements/return ---- -
{{jsSidebar("Statements")}}
- -

Оператор return завершує виконання функції та вказує значення, що буде повернене функцією.

- -
{{EmbedInteractiveExample("pages/js/statement-return.html")}}
- - - -

Синтаксис

- -
return [[expression]];
- -
-
expression
-
Вираз, значення якого буде повернене. Якщо пропущений, повертається undefined.
-
- -

Опис

- -

Коли у тілі функції використовується оператор return, виконання функції зупиняється. За наявності, надане значення повертається у інструкцію, що викликала функцію. Наприклад, наступна функція повертає квадрат свого аргументу x, де x є числом.

- -
function square(x) {
-   return x * x;
-}
-var demo = square(3);
-// demo дорівнюватиме 9
-
- -

Якщо значення не вказане, повертається undefined.

- -

Всі наведені оператори return переривають виконання функції:

- -
return;
-return true;
-return false;
-return x;
-return x + y / 3;
-
- -

Автоматична вставка крапки з комою

- -

Оператор return підпадає під автоматичну вставку крапки з комою (ASI, automatic semicolon insertion). Символи кінця рядка недозволені між ключовим словом return та виразом.

- -
return
-a + b;
-
- -

перетворюється у:

- -
return;
-a + b;
-
- -

Консоль виведе попередження "unreachable code after return statement" (недосяжний код після оператора return).

- -
Починаючи з Gecko 40 {{geckoRelease(40)}}, у консолі виводиться попередження, якщо після оператора return знайдено недосяжний код.
- -

Щоб уникнути цієї проблеми (запобігти ASI), використовуйте дужки:

- -
return (
-  a + b
-);
-
- -

Приклади

- -

Переривання функції

- -

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

- -
function counter() {
-  for (var count = 1; ; count++) {  // нескінченний цикл
-    console.log(count + 'A'); // до 5
-      if (count === 5) {
-        return;
-      }
-      console.log(count + 'B');  // до 4
-    }
-  console.log(count + 'C');  // ніколи не виводиться
-}
-
-counter();
-
-// Результат:
-// 1A
-// 1B
-// 2A
-// 2B
-// 3A
-// 3B
-// 4A
-// 4B
-// 5A
-
- -

Повернення результату функції

- -

Дивіться також статтю про Замикання.

- -
function magic() {
-  return function calc(x) { return x * 42; };
-}
-
-var answer = magic();
-answer(1337); // 56154
-
- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ES1')}}{{Spec2('ES1')}}Початкове визначення.
{{SpecName('ES5.1', '#sec-12.9', 'Return statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-return-statement', 'Return statement')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-return-statement', 'Return statement')}}{{Spec2('ESDraft')}}
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.return")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/switch/index.html b/files/uk/web/javascript/reference/statements/switch/index.html deleted file mode 100644 index 986ba49599..0000000000 --- a/files/uk/web/javascript/reference/statements/switch/index.html +++ /dev/null @@ -1,295 +0,0 @@ ---- -title: switch -slug: Web/JavaScript/Reference/Statements/switch -tags: - - JavaScript - - Інструкція - - Довідка -translation_of: Web/JavaScript/Reference/Statements/switch ---- -
{{jsSidebar("Statements")}}
- -

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

- -
{{EmbedInteractiveExample("pages/js/statement-switch.html", "taller")}}
- - - -

Синтаксис

- -
switch (expression) {
-  case value1:
-    //Інструкції, що виконуються, коли
-    //результат виразу збігається з value1
-    [break;]
-  case value2:
-    //Інструкції, що виконуються, коли
-    //результат виразу збігається з value2
-    [break;]
-  ...
-  case valueN:
-    //Інструкції, що виконуються, коли
-    //результат виразу збігається з valueN
-    [break;]
-  [default:
-    //Інструкції, що виконуються, коли жодне
-    //значення не збігається зі значенням виразу
-    [break;]]
-}
- -
-
expression
-
Вираз, чий результат зіставляється з кожним блоком case.
-
case valueN {{optional_inline}}
-
Блок case, який зіставляється з виразом expression. Якщо значення expression збігається з вказаним значенням valueN, інструкції всередині блоку case виконуються, поки не досягнуть або кінця інструкції switch, або оператора break.
-
default {{optional_inline}}
-
Блок default; якщо вказаний, виконується у випадку, коли значення expression не збігається з жодним з блоків case.
-
- -

Опис

- -

Інструкція switch спочатку обчислює вираз. Далі шукає перший блок case, чий вираз має таке саме значення, що й результат вхідного виразу (використовуючи строгу рівність, ===) та передає контроль цьому блоку, виконуючи інструкції, що до нього відносяться. (Якщо більше одного case збігаються з наданим значенням, обирається перший знайдений case, навіть якщо блоки case не дорівнюють одне одному.)

- -

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

- -

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

- -

Приклади

- -

Використання switch

- -

У наступному прикладі, якщо expr дорівнює Банани, програма знаходить збіг з блоком case 'Банани' та виконує відповідну інструкцію. Дійшовши до оператора break, програма перериває виконання switch та виконує інструкцію, наступну після switch. Якби не оператор break, інструкція блоку case 'Вишні' також би виконалась.

- -
switch (expr) {
-  case 'Апельсини':
-    console.log('Апельсини коштують $0.59 за фунт.');
-    break;
-  case 'Яблука':
-    console.log('Яблука коштують $0.32 за фунт.');
-    break;
-  case 'Банани':
-    console.log('Банани коштують $0.48 за фунт.');
-    break;
-  case 'Вишні':
-    console.log('Вишні коштують $3.00 за фунт.');
-    break;
-  case 'Манго':
-  case 'Папайя':
-    console.log('Манго та папайя коштують $2.79 за фунт.');
-    break;
-  default:
-    console.log('Вибачте, в нас закінчились ' + expr + '.');
-}
-
-console.log("Бажаєте чого-небудь ще?");
-
- -

Що станеться, якщо я забуду break?

- -

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

- -

Дивіться наступний приклад:

- -
var foo = 0;
-switch (foo) {
-  case -1:
-    console.log('від\'ємна 1');
-    break;
-  case 0: // foo дорівнює 0, отже, умова виконана, і цей блок виконається
-    console.log(0);
-    // ЗАУВАГА: забутий break стояв би тут
-  case 1: // немає оператора break у 'case 0:', тому цей блок також виконається
-    console.log(1);
-    break; // програма зустріне тут break і не виконуватиме 'case 2:'
-  case 2:
-    console.log(2);
-    break;
-  default:
-    console.log('default');
-}
- -

Чи можна поставити default між блоками case?

- -

Так, можна! JavaScript відправить вас у default, якщо не знайде збігів:

- -
var foo = 5;
-switch (foo) {
-  case 2:
-    console.log(2);
-    break; // програма зустріне тут break, і не виконуватиме 'default:'
-  default:
-    console.log('default')
-    // проходимо далі
-  case 1:
-    console.log('1');
-}
-
- -

Це також працює, якщо поставити default перед усіма блоками case.

- -

Методи для кількох критеріїв case

- -

Джерело цієї техніки тут:

- -

Інструкція switch з кількома блоками case у JavaScript (Stack Overflow)

- -

Декілька case : одна операція

- -

Цей метод використовує переваги того факту, що, якщо в кінці блоку case немає оператора break, він продовжить виконувати наступний блок case, незалежно від того, чи той відповідає необхідній умові. (Дивіться розділ Що станеться, якщо я забуду break?)

- -

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

- -
var Animal = 'Жирафа';
-switch (Animal) {
-  case 'Корова':
-  case 'Жирафа':
-  case 'Собака':
-  case 'Свиня':
-    console.log('Ці тварини підуть на Ноїв ковчег.');
-    break;
-  case 'Динозавр':
-  default:
-    console.log('Ця тварина не піде.');
-}
- -

Декілька case : ланцюгові операції

- -

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

- -
var foo = 1;
-var output = 'Результат: ';
-switch (foo) {
-  case 0:
-    output += 'То ';
-  case 1:
-    output += 'як ';
-  case 2:
-    output += 'тебе ';
-  case 3:
-    output += 'звати';
-  case 4:
-    output += '?';
-    console.log(output);
-    break;
-  case 5:
-    output += '!';
-    console.log(output);
-    break;
-  default:
-    console.log('Будь ласка, оберіть число від 0 до 5!');
-}
- -

Результат цього прикладу:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ЗначенняВиведений текст
foo дорівнює NaN або не 1, 2, 3, 4, 5 чи 0Будь ласка, оберіть число від 0 до 5!
0Результат: То як тебе звати?
1Результат: як тебе звати?
2Результат: тебе звати?
3Результат: звати?
4Результат: ?
5Результат: !
- -

Змінні блочної області видимості у інструкціях switch

- -

Маючи підтримку ECMAScript 2015 (ES6) у більшості сучасних веб-переглядачів, у певних випадках ви захочете використати оператори {{jsxref("Statements/let", "let")}} та {{jsxref("Statements/const", "const")}} для оголошення змінних блочної області видимості.

- -

Погляньте на цей приклад:

- -
const action = 'скажи_привіт';
-switch (action) {
-  case 'скажи_привіт':
-    let message = 'привіт';
-    console.log(message);
-    break;
-  case 'скажи_бувай':
-    let message = 'бувай';
-    console.log(message);
-    break;
-  default:
-    console.log('Отримана порожня дія.');
-    break;
-}
- -

Цей приклад спричинить помилку Uncaught SyntaxError: Identifier 'message' has already been declared, яку ви, можливо, не очікували.

- -

Все тому, що перше оголошення let message = 'привіт'; конфліктує з другим оголошенням let message = 'бувай'; хоча вони й розташовані у окремих блоках case 'скажи_привіт': та case 'скажи_бувай':. Зрештою, це відбувається тому, що обидва оголошення let інтерпретуються як дублюючі оголошення однієї змінної всередині тієї самої блочної області видимості.

- -

Ми можемо легко це виправити, огорнувши наші блоки case у дужки:

- -
const action = 'скажи_привіт';
-switch (action) {
-  case 'скажи_привіт': { // додані дужки
-    let message = 'привіт';
-    console.log(message);
-    break;
-  } // додані дужки
-  case 'скажи_бувай': { // додані дужки
-    let message = 'бувай';
-    console.log(message);
-    break;
-  } // додані дужки
-  default: { // додані дужки
-    console.log('Отримана порожня дія.');
-    break;
-  } // додані дужки
-}
- -

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

- -

Специфікації

- - - - - - - - - - - - -
Специфікація
{{SpecName('ESDraft', '#sec-switch-statement', 'switch statement')}}
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.switch")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/throw/index.html b/files/uk/web/javascript/reference/statements/throw/index.html deleted file mode 100644 index 96b8974f40..0000000000 --- a/files/uk/web/javascript/reference/statements/throw/index.html +++ /dev/null @@ -1,198 +0,0 @@ ---- -title: throw -slug: Web/JavaScript/Reference/Statements/throw -tags: - - JavaScript - - throw - - виняток -translation_of: Web/JavaScript/Reference/Statements/throw ---- -
{{jsSidebar("Statements")}}
- -

Оператор throw викидає визначений користувачем виняток. Виконання поточної функції буде зупинено (оператори після throw не будуть виконані), а контроль буде передано до першого блоку catch у стеку викликів. Якщо жодного блоку catch не існує, виконання програми переривається.

- -
{{EmbedInteractiveExample("pages/js/statement-throw.html")}}
- - - -

Синтаксис

- -
throw expression;
- -
-
expression
-
Вираз, що викидається.
-
- -

Опис

- -

Скористайтеся оператором throw, щоб викинути виняток. Коли викидаєте виняток, expression вказує значення винятка. Кожна з наступних команд викидає виняток:

- -
throw 'Error2'; // генерує виняток, що має рядкове значення
-throw 42;       // генерує виняток, що має значення 42
-throw true;     // генерує виняток, що має значення true
-throw new Error('Required');  // генерує об'єкт помилки з повідомленням Required
-
- -

Також зазначте, що на оператор throw впливає автоматична вставка крапки з комою (automatic semicolon insertion, ASI), оскільки між ключовим словом throw та виразом не дозволяється вставляти символи закінчення рядка.

- -

Приклади

- -

Викидання об'єкта

- -

Ви можете вказати об'єкт, коли викидаєте виняток. Після цього ви можете звертатися до властивостей об'єкта у блоці catch. Наступний приклад створює об'єкт типу UserException, і далі використовує його з оператором throw.

- -
function UserException(message) {
-   this.message = message;
-   this.name = 'UserException';
-}
-function getMonthName(mo) {
-   mo = mo - 1; // Припасувати номер місяця до індексу масиву (1 = Січ, 12 = Груд)
-   var months = ['Січ', 'Лют', 'Берез', 'Квіт', 'Трав', 'Черв', 'Лип',
-      'Серп', 'Верес', 'Жовт', 'Листоп', 'Груд'];
-   if (months[mo] !== undefined) {
-      return months[mo];
-   } else {
-      throw new UserException('InvalidMonthNo');
-   }
-}
-
-try {
-   // команди до виконання
-   var myMonth = 15; // 15 не входить у визначені межі й викликає виняток
-   var monthName = getMonthName(myMonth);
-} catch (e) {
-   monthName = 'unknown';
-   console.error(e.message, e.name); // передати об'єкт винятку до обробника помилок
-}
-
- -

Ще один приклад викидання об'єкта

- -

Наступний приклад перевіряє наданий текстовий рядок на формат поштового індексу. Якщо поштовий індекс використовує неправильний формат, оператор throw викидає виняток, створюючи об'єкт типу ZipCodeFormatException.

- -
/*
- * Створює об'єкт ZipCode.
- *
- * Дозволені формати поштового індексу:
- *    12345
- *    12345-6789
- *    123456789
- *    12345 6789
- *
- * Якщо аргумент, переданий до конструктора ZipCode, не відповідає
- * жодному з цих шаблонів, викидається виняток.
- */
-
-function ZipCode(zip) {
-   zip = new String(zip);
-   pattern = /[0-9]{5}([- ]?[0-9]{4})?/;
-   if (pattern.test(zip)) {
-      // значення поштового індексу буде першим збігом у рядку
-      this.value = zip.match(pattern)[0];
-      this.valueOf = function() {
-         return this.value
-      };
-      this.toString = function() {
-         return String(this.value)
-      };
-   } else {
-      throw new ZipCodeFormatException(zip);
-   }
-}
-
-function ZipCodeFormatException(value) {
-   this.value = value;
-   this.message = 'не відповідає очікуваному формату поштового індексу';
-   this.toString = function() {
-      return this.value + this.message;
-   };
-}
-
-/*
- * Це можна вставити у скрипт, який перевіряє дані адреси
- * на відповідність формату адрес.
- */
-
-const ZIPCODE_INVALID = -1;
-const ZIPCODE_UNKNOWN_ERROR = -2;
-
-function verifyZipCode(z) {
-   try {
-      z = new ZipCode(z);
-   } catch (e) {
-      if (e instanceof ZipCodeFormatException) {
-         return ZIPCODE_INVALID;
-      } else {
-         return ZIPCODE_UNKNOWN_ERROR;
-      }
-   }
-   return z;
-}
-
-a = verifyZipCode(95060);         // повертає 95060
-b = verifyZipCode(9560);          // повертає -1
-c = verifyZipCode('a');           // повертає -1
-d = verifyZipCode('95060');       // повертає 95060
-e = verifyZipCode('95060 1234');  // повертає 95060 1234
-
- -

Повторне викидання винятку

- -

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

- -
try {
-   throw n; // викидає виняток з числовим значенням
-} catch (e) {
-   if (e <= 50) {
-      // команди для обробки винятків 1-50
-   } else {
-      // неможливо обробити цей виняток, тому викидаємо його повторно
-      throw e;
-   }
-}
-
- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ES3')}}{{Spec2('ES3')}}Початкове визначення. Реалізоване у JavaScript 1.4
{{SpecName('ES5.1', '#sec-12.13', 'throw statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-throw-statement', 'throw statement')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-throw-statement', 'throw statement')}}{{Spec2('ESDraft')}}
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.throw")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/try...catch/index.html b/files/uk/web/javascript/reference/statements/try...catch/index.html deleted file mode 100644 index 9d506beb60..0000000000 --- a/files/uk/web/javascript/reference/statements/try...catch/index.html +++ /dev/null @@ -1,319 +0,0 @@ ---- -title: try...catch -slug: Web/JavaScript/Reference/Statements/try...catch -tags: - - Error - - JavaScript - - виняток - - помилка -translation_of: Web/JavaScript/Reference/Statements/try...catch ---- -
{{jsSidebar("Statements")}}
- -

Конструкція try...catch позначає блок команд, які треба виконати, та визначає реакцію в разі, якщо буде викинуто виняток.

- -
{{EmbedInteractiveExample("pages/js/statement-trycatch.html")}}
- - - -

Синтаксис

- -
try {
-  try_statements
-}
-[catch (exception_var_1 if condition_1) { // нестандартна форма
-  catch_statements_1
-}]
-...
-[catch (exception_var_2) {
-  catch_statements_2
-}]
-[finally {
-  finally_statements
-}]
-
- -
-
try_statements
-
Команди, які треба виконати.
-
- -
-
catch_statements_1, catch_statements_2
-
Команди, що виконуються, якщо викинуто виняток у блоці try.
-
- -
-
exception_var_1, exception_var_2
-
Ідентифікатор, що містить об'єкт винятку для відповідного блоку catch.
-
- -
-
condition_1
-
Умовний вираз.
-
- -
-
finally_statements
-
Команди, що виконуються після завершення блоку try. Ці команди виконуються незалежно від того, чи було викинуто або перехоплено виняток.
-
- -

Опис

- -

Вираз try містить одну або більше команд у блоці try. Фігурні дужки {} є обов'язковими, навіть для однієї команди. Має бути присутній принаймні один блок catch або finally. Це утворює три можливі форми виразу try:

- -
    -
  1. try...catch
    2. -
  2. try...finally
    3. -
  3. try...catch...finally
    4. -
- -

Блок catch містить команди, які визначають, що робити, якщо викинуто виняток у блоці try. Отже, ви хочете, щоб блок try виконався успішно, а в разі неуспіху ви хочете передати контроль до блоку catch. В разі, якщо будь-який вираз всередині блоку try (або функція, викликана зсередини блоку try) викидає виняток, контроль негайно переходить до блоку catch. Якщо жодних винятків у блоці try не було викинуто, блок catch пропускається.

- -

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

- -

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

- -

Ви також можете використовувати try, щоб обробляти винятки JavaScript. Ви знайдете більше інформації щодо винятків JavaScript у Посібнику JavaScript.

- -

Безумовний catch

- -

Коли використовується один безумовний блок catch, перехід у catch відбувається у випадку викидання будь-якого винятку. Наприклад, коли виняток стається у наступному коді, контроль передається до блоку catch.

- -
try {
-  throw 'myException'; // генерує виняток
-}
-catch (e) {
-  // команди обробки будь-яких винятків
-  logMyErrors(e); // передає об'єкт винятку до обробника помилок
-}
-
- -

Блок catch вказує ідентифікатор (e у наведеному прикладі), який містить значення, визначене у операторі throw. Блок catch унікальний тим, що JavaScript створює цей ідентифікатор при вході у блок catch, а також додає його у область видимості; ідентифікатор "живе" тільки протягом виконання блоку catch; коли catch завершується, ідентифікатор більше недоступний.

- -

Умовний блок catch

- -

{{non-standard_header}}

- -

Ви також можете використати один або декілька умовних блоків catch для обробки специфічних винятків. В цьому випадку вхід у відповідний блок catch відбувається, коли викидається вказаний виняток. У наступному прикладі код у блоці try може викинути один з трьох винятків: {{jsxref("TypeError")}}, {{jsxref("RangeError")}} або {{jsxref("EvalError")}}. Коли виникає виняток, контроль передається до відповідного блоку catch. Якщо виняток не є одним із вказаних, і був знайдений безумовний блок catch, контроль передається до цього блоку catch.

- -

Якщо ви використовуєте безумовний catch з одним або кількома умовними блоками catch, безумовний catch має бути вказаний останнім. Інакше безумовний catch перехоплюватиме всі види винятків до того, як вони потраплять в умовні блоки.

- -

Нагадування: ця функціональність не є частиною специфікації ECMAScript і ніколи не прибиралася з Firefox 59. Вона більше не підтримується у жодних сучасних веб-переглядачах.

- -
try {
-  myroutine(); // може викинути три типи винятків
-} catch (e if e instanceof TypeError) {
-  // команди обробки винятків типу TypeError
-} catch (e if e instanceof RangeError) {
-  // команди обробки винятків типу RangeError
-} catch (e if e instanceof EvalError) {
-  // команди обробки винятків типу EvalError
-} catch (e) {
-  // команди обробки не вказаних типів винятків
-  logMyErrors(e); // передати об'єкт винятку до обробника помилок
-}
-
- -

Ось такі ж "Умовні блоки catch", написані кодом, що відповідає специфікації ECMAScript (він доволі багатослівний, зате працює всюди):

- -
try {
-  myroutine(); // може викинути три типи винятків
-} catch (e) {
-  if (e instanceof TypeError) {
-    // команди обробки винятків типу TypeError
-  } else if (e instanceof RangeError) {
-    // команди обробки винятків типу RangeError
-  } else if (e instanceof EvalError) {
-    // команди обробки винятків типу EvalError
-  } else {
-    // команди обробки не вказаних типів винятків
-    logMyErrors(e); // передати об'єкт винятку до обробника помилок
-  }
-}
-
- -

Ідентифікатор винятку

- -

Коли викидається виняток у блоці try, ідентифікатор exception_var (наприклад, e у catch (e)) містить значення, вказане у виразі throw. Ви можете скористатись цим ідентифікатором, щоб отримати інформацію про виняток. Це локальний ідентифікатор блоку catch. Тобто, він створюється при вході у catch, а після того, як виконання блоку catch завершується, ідентифікатор більше недоступний.

- -
function isValidJSON(text) {
-  try {
-    JSON.parse(text);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
- -

Блок finally

- -

Блок finally містить команди, які виконуються після виконання блоків try та catch, але до команд, що розташовані після конструкції  try...catch...finally. Зверніть увагу, що finally виконується незалежно від того, чи був викинутий виняток. Також, якщо виняток було викинуто, команди блоку finally виконуються навіть якщо немає блоку catch, щоб обробити виняток.

- -

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

- -

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

- -

Наприклад, якщо станеться інший виняток всередині catch цього try, будь-який код, що не був виконаний у зовнішньому try, що замикає цей try...catch (або у головному потоці, якщо виконувався не зовнішній try), не буде виконаний, оскільки контроль негайно перейде до блоку catch зовнішнього try (або до внутнішнього генератора помилок, якщо виконується не блок try).

- -

Таким чином, будь який поточний код очистки, що виконується у цій зовнішній (або головній) секції перед закінченням, буде пропущений. Однак, якщо вираз try містить блок finally, то спочатку буде виконаний код блоку finally, дозволяючи зробити очистку, і тільки ПОТІМ контроль буде передано до блоку catch іншого try (або до генератора помилок) для обробки винятку.

- -

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

- -

Наступний приклад відкриває файл і далі виконує команди, які використовують цей файл (JavaScript на стороні сервера дозволяє звертатись до файлів). Якщо викидається виняток, доки файл відкритий, блок finally закриває цей файл до того, як скрипт переривається. Код у блоці finally також виконується з явним поверненням з блоку try або catch.

- -
openMyFile();
-try {
-  // прив'язати ресурс
-  writeMyFile(theData);
-}
-finally {
-  closeMyFile(); // завжди закривати ресурс
-}
-
- -

Приклади

- -

Вкладені блоки try

- -

Спочатку подивимось, що відбувається тут:

- -
try {
-  try {
-    throw new Error('ой-ой');
-  }
-  finally {
-    console.log('finally');
-  }
-}
-catch (ex) {
-  console.error('зовнішній', ex.message);
-}
-
-// Результат:
-// "finally"
-// "зовнішній" "ой-ой"
-
- -

Тепер, якщо ми вже перехопили виняток у внутрішньому try, додавши блок catch.

- -
try {
-  try {
-    throw new Error('ой-ой');
-  }
-  catch (ex) {
-    console.error('внутрішній', ex.message);
-  }
-  finally {
-    console.log('finally');
-  }
-}
-catch (ex) {
-  console.error('зовнішній', ex.message);
-}
-
-// Результат:
-// "внутрішній" "ой-ой"
-// "finally"
-
- -

А тепер викинемо цю помилку повторно.

- -
try {
-  try {
-    throw new Error('ой-ой');
-  }
-  catch (ex) {
-    console.error('внутрішній', ex.message);
-    throw ex;
-  }
-  finally {
-    console.log('finally');
-  }
-}
-catch (ex) {
-  console.error('зовнішній', ex.message);
-}
-
-// Результат:
-// "внутрішній" "ой-ой"
-// "finally"
-// "зовнішній" "ой-ой"
-
- -

Будь-який виняток буде перехоплений лише один раз найближчим замикаючим блоком catch, якщо тільки він не був викинутий повторно.  Звісно, будь-які нові винятки, викинуті у "внутрішньому" блоці (бо код у блоці catch може зробити те, що викине помилку), будуть перехоплені "зовнішнім" блоком.

- -

Повернення значень з блоку finally

- -

Якщо блок finally повертає значення, це значення повертається усією конструкцією try-catch-finally, не зважаючи на будь-які інші оператори return у блоках try та catch. Це стосується й винятків, викинутих всередині блоку catch:

- -
(function() {
-  try {
-    try {
-      throw new Error('ой-ой');
-    }
-    catch (ex) {
-      console.error('внутрішній', ex.message);
-      throw ex;
-    }
-    finally {
-      console.log('finally');
-      return;
-    }
-  }
-  catch (ex) {
-    console.error('зовнішній', ex.message);
-  }
-})();
-
-// Результат:
-// "внутрішній" "ой-ой"
-// "finally"
- -

Зовнішній "ой-ой" не викидається через return у блоці finally. Те саме стосувалося б будь-якого значення, що поверталося б з блоку catch.

- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ES3')}}{{Spec2('ES3')}}Початкове визначення. Реалізоване у JavaScript 1.4
{{SpecName('ES5.1', '#sec-12.14', 'try statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-try-statement', 'try statement')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-try-statement', 'try statement')}}{{Spec2('ESDraft')}}Не є частиною нинішнього стандарту ECMA-262: Використання кількох блоків catch та умовні блоки (розширення SpiderMonkey, JavaScript 1.5).
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.try_catch")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/var/index.html b/files/uk/web/javascript/reference/statements/var/index.html deleted file mode 100644 index 5044c8cfc5..0000000000 --- a/files/uk/web/javascript/reference/statements/var/index.html +++ /dev/null @@ -1,226 +0,0 @@ ---- -title: var -slug: Web/JavaScript/Reference/Statements/var -tags: - - JavaScript - - Довідка - - Оператор -translation_of: Web/JavaScript/Reference/Statements/var ---- -
{{jsSidebar("Заяви")}}
- -

Оператор var оголошує змінну, з необов'язковим наданням їй початкового значення.

- -
{{EmbedInteractiveExample ("pages/js/statement-var.html")}}
- - - -

Синтаксис

- -
var varname1 [= value1] [, varname2 [= value2] … [, varnameN [= valueN]]] ;
- -
-
varnameN
-
Ім'я змінної. Може бути будь-яким дозволеним ідентифікатором.
-
- -
-
valueN
-
Початкове значення змінної. Може бути будь-яким дозволеним виразом. Якщо відсутнє, початковим значенням буде undefined.
-
- -

Опис

- -

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

- -

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

- -

Присвоєння значення неоголошеній змінній просто створює її як глобальну змінну (вона стає властивістю глобального об'єкта) під час виконання присвоєння. Відмінності між оголошеними та неоголошеними змінними наступні:

- -

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

- -
function x() {
-  y = 1;  // у строгому режимі викидає ReferenceError
-  var z = 2;
-}
-
-x();
-
-console.log(y);  // 1
-console.log(z);  // викидає ReferenceError: z не визначено за межами x
- -

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

- -
console.log(a); // викидає ReferenceError
-console.log('виконання триває…');  // ніколи не виконається
-
- -
var a;
-console.log(a); // "undefined" чи "", залежно від переглядача
-console.log('виконання триває…'); // виконання триває…
- -

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

- -
var a = 1;
-b = 2;
-
-delete this.а;  // у строгому режимі викидає TypeError, поза ним просто не спрацьовує
-delete this.b;
-
-console.log(a, b);  // викидає ReferenceError
-// Властивість 'b' була видалена й більше не існує.
- -

Через ці відмінності використання неоголошених змінних, ймовірно, матиме несподівані наслідки. Тож, рекомендується завжди оголошувати змінні, незалежно від того, чи розташовані вони всередині функціі, чи у глобальній області видимості. У строгому режимі ECMAScript 5 присвоєння у неоголошену змінну викидає помилку.

- -

Підняття var

- -

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

- -
bla = 2;
-var bla;
-
-// ...неявно означає таке:
-
-var bla;
-bla = 2;
- -

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

- -

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

- -
function do_something() {
-  console.log(bar);  // undefined
-  var bar = 111;
-  console.log(bar);  // 111
-}
-
-// ...неявно означає таке:
-
-function do_something() {
-  var bar;
-  console.log(bar);  // undefined
-  bar = 111;
-  console.log(bar);  // 111
-}
- -

Приклади

- -

Оголошення та ініціалізація двох змінних

- -
var a = 0, b = 0;
- -

Присвоєння двом змінним одного рядкового значення

- -
var a = 'А';
-var b = a;
-
-// ...те саме, що й:
-
-var a, b = a = 'А';
- -

Зважайте на порядок:

- -
var x = y, y = 'А';
-console.log(x, y);  // undefinedА
- -

Тут x та y оголошуються до виконання коду, але присвоєння значень відбувається пізніше. Під час обчислення "x = y" змінна y вже існує, тому ReferenceError не викидається, а її значенням є undefined. Отже, змінна x дістане значення undefined. Далі змінній y присвоюється значення 'А'. Отже, після першого рядка x === undefined && y === 'A', звідси результат.

- -

Ініціалізація кількох змінних

- -
var x = 0;
-function f() {
-  var x = y = 1; // Оголошує x локально; оголошує y глобально.
-}
-
-f();
-
-console.log (x, y); // 0 1
-
-// У нестрогому режимі:
-// глобальна змінна x, як і очікувалось;
-// Але змінна y просочилась за межі функції!
- -

Той самий приклад, але у строгому режимі:

- -
'use strict';
-
-var x = 0;
-function f() {
-  var x = y = 1; // Викидає ReferenceError у строгому режимі.
-}
-f();
-
-console.log(x, y);
- -

Неявні глобальні змінні та область видимості зовнішньої функції

- -

Змінні, що виглядають неявними глобальними змінними, можуть бути посиланнями на змінні області видимості зовнішньої функції:

- -
var x = 0;  // оголошує змінну х в межах файлу та присвоює їй значення 0
-
-console.log(typeof z);  // "undefined", позаяк змінна z ще не існує
-
-function a() {
-  var y = 2;  // Оголошує змінну y в області видимості функції a, та присвоює їй значення 2
-
-  console.log (x, y);  // 0 2 
-
-  function b() {
-    x = 3;  // Присвоює 3 оголошеній в межах файлу змінній x.
-    у = 4;  // Присвоює 4 оголошеній зовнішній змінній y.
-    z = 5;  // Створює нову глобальну змінну z та присвоює їй значення 5.
-            // (Викидає ReferenceError у строгому режимі.)
-  }
-
-  b();  // Створює змінну z в глобальній області видимості.
-  console.log(x, y, z);  // 3 4 5 
-}
-
-a();  // Також викликає b.
-console.log(x, z);  // 3 5
-console.log(typeof y);  // "undefined", бо y є локальною змінною функції a
- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName ('ES1')}}{{Spec2('ES1')}}Початкова виознака. Запроваджено у JavaScript 1.0.
{{SpecName ('ES5.1', '#sec-12.2', 'var statement')}}{{Spec2('ES5.1')}}
{{SpecName ('ES6', '#sec-variable-statement', 'variable statement')}}{{Spec2('ES6')}}
{{SpecName ('ESDraft', '#sec-variable-statement', 'variable statement')}}{{Spec2('ESDraft')}}
- -

Підтримка веб-переглядачами

- - - -

{{Compat ("javascript.statements.var")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/while/index.html b/files/uk/web/javascript/reference/statements/while/index.html deleted file mode 100644 index bddac682fb..0000000000 --- a/files/uk/web/javascript/reference/statements/while/index.html +++ /dev/null @@ -1,104 +0,0 @@ ---- -title: while -slug: Web/JavaScript/Reference/Statements/while -tags: - - JavaScript - - while -translation_of: Web/JavaScript/Reference/Statements/while ---- -
{{jsSidebar("Statements")}}
- -

Оператор while створює цикл, який виконує вказану інструкцію, доки перевірочна умова оцінюється як true. Умова оцінюється перед виконанням інструкції.

- -
{{EmbedInteractiveExample("pages/js/statement-while.html")}}
- - - -

Синтаксис

- -
while (condition)
-  statement
-
- -
-
condition
-
Вираз, який оцінюється перед кожним проходом циклу. Якщо ця умова оцінюється як true, statement виконується. Коли умова оцінюється як false, виконання продовжується з інструкції, що розташована після циклу while.
-
statement
-
Необов'язкова інструкція, яка виконується, поки умова оцінюється як true. Для виконання кількох інструкцій у циклі, скористайтесь блоком ({ ... }), щоб згрупувати ці інструкції.
-
- Заувага: Використовуйте оператор break, щоб зупинити цикл раніше, ніж умова буде оцінена як false.
-
- -

Приклади

- -

Наступний цикл while виконується, поки n менше трьох.

- -
var n = 0;
-var x = 0;
-
-while (n < 3) {
-  n++;
-  x += n;
-}
- -

На кожній ітерації цикл збільшує змінну n на один та додає її до x. Отже, x та n приймають наступні значення:

- - - -

Після завершення третього проходу умова n < 3 більше не дорівнює true, тому цикл переривається.

- -

Специфікації

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
СпецифікаціяСтатусКоментар
{{SpecName('ESDraft', '#sec-while-statement', 'while statement')}}{{Spec2('ESDraft')}}
{{SpecName('ES6', '#sec-while-statement', 'while statement')}}{{Spec2('ES6')}}
{{SpecName('ES5.1', '#sec-12.6.2', 'while statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES3', '#sec-12.6.2', 'while statement')}}{{Spec2('ES3')}}
{{SpecName('ES1', '#sec-12.6.1', 'while statement')}}{{Spec2('ES1')}}Початкове визначення
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.while")}}

- -

Див. також

- - diff --git a/files/uk/web/javascript/reference/statements/with/index.html b/files/uk/web/javascript/reference/statements/with/index.html deleted file mode 100644 index fca48fda25..0000000000 --- a/files/uk/web/javascript/reference/statements/with/index.html +++ /dev/null @@ -1,107 +0,0 @@ ---- -title: with -slug: Web/JavaScript/Reference/Statements/with -tags: - - JavaScript - - Оператор - - не рекомендований -translation_of: Web/JavaScript/Reference/Statements/with ---- -
Використання оператора with не рекомендоване, оскільки може бути джерелом заплутаних помилок та проблем із сумісністю. Дивіться абзац "Мінуси для однозначності" у розділі "Опис", щоб дізнатись більше.
- -
{{jsSidebar("Statements")}}
- -

Оператор with розширює ланцюжок областей видимості для інструкції.

- -

Синтаксис

- -
with (expression)
-  statement
-
- -
-
expression
-
Додає наданий вираз до ланцюжка областей видимості, який використовується під час обчислення інструкції. Круглі дужки навколо виразу є обов'язковими.
-
statement
-
Будь-яка інструкція. Щоб виконати більше однієї інструкції, скористайтесь блоком ({ ... }), щоб згрупувати ці інструкції.
-
- -

Опис

- -

JavaScript шукає некваліфіковане ім'я у ланцюжку областей видимості, пов'язаних з контекстом виконання скрипта чи функції, що містить це некваліфіковане ім'я. Оператор 'with' додає наданий об'єкт у початок цього ланцюжка під час обчислення своїх інструкцій. Якщо некваліфіковане ім'я, що використовується у інструкціях, співпадає з властивістю з ланцюжка областей видимості, це ім'я зв'язується з властивістю та об'єктом, що містить цю властивість. Інакше, викидається помилка {{jsxref("ReferenceError")}}.

- -
Використання with не рекомендоване та заборонене у строгому режимі ECMAScript 5. Рекомендованою альтернативою є присвоєння об'єкта, чиї властивості вам потрібні, тимчасовій змінній.
- -

Плюси та мінуси для швидкодії

- -

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

- -

Мінуси: Оператор with спочатку спричиняє пошук усіх імен на вказаному об'єкті. Таким чином, усі ідентифікатори, що не є членами вказаного об'єкта, шукатимуться у блоці 'with' набагато повільніше. У випадках, коли швидкодія важлива, 'with' слід використовувати лише у тих блоках коду, які звертаються до членів вказаного об'єкта.

- -

Мінуси для однозначності

- -

Мінус: З оператором with стає важко зрозуміти, людині чи компілятору JavaScript, чи буде некваліфіковане ім'я знайдене у ланцюжку областей видимості, і, якщо так, то в якому об'єкті. Отже, у наступному прикладі:

- -
function f(x, o) {
-  with (o) {
-    console.log(x);
-  }
-}
- -

Лише коли функція f викликана, змінна x або буде знайдена, або ні, а, якщо буде знайдена, то або в o, або (якщо такої властивості не існує) у об'єкті активації f, де x іменує перший формальний аргумент. Якщо ви забудете визначити x у об'єкті, який передаєте другим аргументом, або в разі якоїсь схожої помилки чи плутанини, ви не отримаєте помилку -- лише неочікувані результати.

- -

Мінус: Код, що використовує with, може бути несумісним знизу вгору, особливо при використанні з чимось інакшим, ніж простий об'єкт. Розглянемо цей приклад:

- -
-
function f(foo, values) {
-  with (foo) {
-    console.log(values);
-  }
-}
-
- -

Якщо ви викличете f([1,2,3], obj) у середовищі ECMAScript 5, то посилання values всередині блоку with поверне obj. Однак, ECMAScript 2015 вводить властивість values у {{jsxref("Array.prototype")}} (таким чином, доступну у кожному масиві). Отже, у середовищі JavaScript, яке підтримує ECMAScript 2015, посилання values всередині блоку with може повернути [1,2,3].values. Однак, конкретно у цьому прикладі {{jsxref("Array.prototype")}} було визначено з values у об'єкті {{jsxref("Symbol.unscopables")}}. Якби не це, ми б побачили, як важко було б його відлагоджувати.

-
- -

Приклади

- -

Використання with

- -

Наступний оператор with вказує, що об'єкт Math є об'єктом за замовчуванням. Інструкції, що йдуть після with, посилаються на властивість PI, а також методи cos та sin без зазначення об'єкта. JavaScript припускає, що об'єктом цих посилань є Math.

- -
var a, x, y;
-var r = 10;
-
-with (Math) {
-  a = PI * r * r;
-  x = r * cos(PI);
-  y = r * sin(PI / 2);
-}
- -

Специфікації

- - - - - - - - - - -
Специфікація
{{SpecName('ESDraft', '#sec-with-statement', 'with statement')}}
- -

Сумісність з веб-переглядачами

- - - -

{{Compat("javascript.statements.with")}}

- -

Див. також

- - -- cgit v1.2.3-54-g00ecf