From 074785cea106179cb3305637055ab0a009ca74f2 Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:42:52 -0500 Subject: initial commit --- .../reference/statements/async_function/index.html | 179 +++++++++ .../reference/statements/break/index.html | 140 +++++++ .../reference/statements/class/index.html | 183 +++++++++ .../reference/statements/const/index.html | 135 +++++++ .../reference/statements/continue/index.html | 200 ++++++++++ .../reference/statements/debugger/index.html | 124 ++++++ .../reference/statements/default/index.html | 116 ++++++ .../reference/statements/do...while/index.html | 94 +++++ .../reference/statements/empty/index.html | 148 ++++++++ .../reference/statements/export/index.html | 131 +++++++ .../reference/statements/for-await...of/index.html | 139 +++++++ .../reference/statements/for...in/index.html | 197 ++++++++++ .../reference/statements/for...of/index.html | 302 +++++++++++++++ .../javascript/reference/statements/for/index.html | 194 ++++++++++ .../reference/statements/for_each...in/index.html | 126 ++++++ .../reference/statements/function/index.html | 125 ++++++ .../reference/statements/function_star_/index.html | 202 ++++++++++ .../reference/statements/if...else/index.html | 213 +++++++++++ .../reference/statements/import.meta/index.html | 68 ++++ .../reference/statements/import/index.html | 271 +++++++++++++ .../web/javascript/reference/statements/index.html | 162 ++++++++ .../reference/statements/label/index.html | 179 +++++++++ .../javascript/reference/statements/let/index.html | 414 ++++++++++++++++++++ .../reference/statements/return/index.html | 156 ++++++++ .../reference/statements/switch/index.html | 184 +++++++++ .../reference/statements/throw/index.html | 240 ++++++++++++ .../reference/statements/try...catch/index.html | 422 +++++++++++++++++++++ .../javascript/reference/statements/var/index.html | 221 +++++++++++ .../reference/statements/while/index.html | 143 +++++++ .../reference/statements/with/index.html | 177 +++++++++ .../\320\261\320\273\320\276\320\272/index.html" | 177 +++++++++ 31 files changed, 5762 insertions(+) create mode 100644 files/ru/web/javascript/reference/statements/async_function/index.html create mode 100644 files/ru/web/javascript/reference/statements/break/index.html create mode 100644 files/ru/web/javascript/reference/statements/class/index.html create mode 100644 files/ru/web/javascript/reference/statements/const/index.html create mode 100644 files/ru/web/javascript/reference/statements/continue/index.html create mode 100644 files/ru/web/javascript/reference/statements/debugger/index.html create mode 100644 files/ru/web/javascript/reference/statements/default/index.html create mode 100644 files/ru/web/javascript/reference/statements/do...while/index.html create mode 100644 files/ru/web/javascript/reference/statements/empty/index.html create mode 100644 files/ru/web/javascript/reference/statements/export/index.html create mode 100644 files/ru/web/javascript/reference/statements/for-await...of/index.html create mode 100644 files/ru/web/javascript/reference/statements/for...in/index.html create mode 100644 files/ru/web/javascript/reference/statements/for...of/index.html create mode 100644 files/ru/web/javascript/reference/statements/for/index.html create mode 100644 files/ru/web/javascript/reference/statements/for_each...in/index.html create mode 100644 files/ru/web/javascript/reference/statements/function/index.html create mode 100644 files/ru/web/javascript/reference/statements/function_star_/index.html create mode 100644 files/ru/web/javascript/reference/statements/if...else/index.html create mode 100644 files/ru/web/javascript/reference/statements/import.meta/index.html create mode 100644 files/ru/web/javascript/reference/statements/import/index.html create mode 100644 files/ru/web/javascript/reference/statements/index.html create mode 100644 files/ru/web/javascript/reference/statements/label/index.html create mode 100644 files/ru/web/javascript/reference/statements/let/index.html create mode 100644 files/ru/web/javascript/reference/statements/return/index.html create mode 100644 files/ru/web/javascript/reference/statements/switch/index.html create mode 100644 files/ru/web/javascript/reference/statements/throw/index.html create mode 100644 files/ru/web/javascript/reference/statements/try...catch/index.html create mode 100644 files/ru/web/javascript/reference/statements/var/index.html create mode 100644 files/ru/web/javascript/reference/statements/while/index.html create mode 100644 files/ru/web/javascript/reference/statements/with/index.html create mode 100644 "files/ru/web/javascript/reference/statements/\320\261\320\273\320\276\320\272/index.html" (limited to 'files/ru/web/javascript/reference/statements') diff --git a/files/ru/web/javascript/reference/statements/async_function/index.html b/files/ru/web/javascript/reference/statements/async_function/index.html new file mode 100644 index 0000000000..df0368c62a --- /dev/null +++ b/files/ru/web/javascript/reference/statements/async_function/index.html @@ -0,0 +1,179 @@ +--- +title: async function +slug: Web/JavaScript/Reference/Statements/async_function +translation_of: Web/JavaScript/Reference/Statements/async_function +--- +
{{jsSidebar("Statements")}}
+ +
Объявление async function определяет асинхронную функцию, которая возвращает объект {{jsxref("Global_Objects/AsyncFunction","AsyncFunction")}}.
+ +
+

Вы также можете  определить async-функции, используя  {{jsxref("Operators/async_function", "выражение async function")}}.

+
+ +

Синтаксис

+ +
async function name([param[, param[, ... param]]]) {
+   statements
+}
+
+ +
+
name
+
Имя функции.
+
+ +
+
param
+
Имя аргумента, который будет передан в функцию.
+
+ +
+
statements
+
Выражение, содержащее тело функции.
+
+ +

Описание

+ +

После вызова функция async возвращает {{jsxref("Promise")}}. Когда результат был получен, Promise завершается, возвращая полученное значение.  Когда функция async выбрасывает исключение, Promise ответит отказом с выброшенным (throws) значением.

+ +

Функция async может содержать выражение {{jsxref("Operators/await", "await")}}, которое приостанавливает выполнение функции async и ожидает ответа от переданного Promise, затем возобновляя выполнение функции async и возвращая полученное значение.

+ +

Ключевое слово await допустимо только в асинхронных функциях. В другом контексте вы получите ошибку SyntaxError.

+ +
+

Цель функций async/await упростить использование promises синхронно и воспроизвести некоторое действие над группой  Promises. Точно так же как Promises подобны структурированным callback-ам, async/await подобна комбинации генераторов и promises.

+
+ +

Примеры

+ +

Простой пример

+ +
function resolveAfter2Seconds(x) {
+  return new Promise(resolve => {
+    setTimeout(() => {
+      resolve(x);
+    }, 2000);
+  });
+}
+
+async function add1(x) {
+  const a = await resolveAfter2Seconds(20);
+  const b = await resolveAfter2Seconds(30);
+  return x + a + b;
+}
+
+add1(10).then(v => {
+  console.log(v);  // prints 60 after 4 seconds.
+});
+
+async function add2(x) {
+  const a = resolveAfter2Seconds(20);
+  const b = resolveAfter2Seconds(30);
+  return x + await a + await b;
+}
+
+add2(10).then(v => {
+  console.log(v);  // prints 60 after 2 seconds.
+});
+
+ +
+

Не путайте await и Promise.all

+ +

Функция add1 приостанавливается на 2 секунды для первого await и еще на 2 для второго. Второй таймер создается только после срабатывания первого. В функции add2 создаются оба и оба же переходят в состояние await. В результате функция add2 завершится скорее через две, чем через четыре секунды, поскольку таймеры работают одновременно. Однако запускаются они все же не паралелльно, а друг за другом - такая конструкция не означает автоматического использования Promise.all. Если два или более Promise должны разрешаться параллельно, следует использовать Promise.all.

+
+ +

Когда функция async выбрасывает исключение

+ +
async function throwsValue() {
+    throw new Error('oops');
+}
+throwsValue()
+    .then((resolve) => {
+            console.log("resolve:" + resolve);
+        },
+        (reject) => {
+            console.log("reject:" + reject);
+        });
+//prints "reject:Error: oops"
+//or
+throwsValue()
+    .then((resolve) => {
+        console.log("resolve:" + resolve);
+    })
+    .catch((reject) => {
+        console.log("reject:" + reject);
+    });
+//prints "reject:Error: oops"
+
+ +

Перепись цепочки promise с использованием функции async

+ +

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

+ +
function getProcessedData(url) {
+  return downloadData(url) // returns a promise
+    .catch(e => {
+      return downloadFallbackData(url) // returns a promise
+    })
+    .then(v => {
+      return processDataInWorker(v); // returns a promise
+    });
+}
+
+ +

он может быть переписан с одним использованием функции async:

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

Заметьте, что пример выше не содержит await на return, потому что возвращаемое значение функции async неявно обернуто в {{jsxref("Promise.resolve")}}.

+ +

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

+ + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ESDraft', '#sec-async-function-definitions', 'async function')}}{{Spec2('ESDraft')}}Initial definition in ES2017.
{{SpecName('ES8', '#sec-async-function-definitions', 'async function')}}{{Spec2('ES8')}}
+ +

Поддержка браузерами

+ +
+ + +

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

+
+ +

Смотрите также

+ + diff --git a/files/ru/web/javascript/reference/statements/break/index.html b/files/ru/web/javascript/reference/statements/break/index.html new file mode 100644 index 0000000000..dfb5840659 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/break/index.html @@ -0,0 +1,140 @@ +--- +title: break +slug: Web/JavaScript/Reference/Statements/break +tags: + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/break +--- +
{{jsSidebar("Statements")}}
+ +

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

+ +

 

+ +

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

+ + + +

Синтаксис

+ +
break [label];
+ +
+
label
+
Опционально. Идентификатор связанной метки. Если прерываемое выражение не цикл или {{jsxref("Statements/switch", "switch")}}, метка является обязательной.
+
+ +

Описание

+ +

Инструкция break включает необязательную метку для возможности выхода из блочного выражения. При таком использовании break должен находиться внутри отмеченного блока, который соответствует метке. Отмеченная инструкция может быть любой {{jsxref("Statements/block", "блочной")}} инструкцией; она не обязательно должна являться циклом.

+ +

Пример

+ +

Следующая функция использует инструкцию 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;
+}
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
ECMAScript 1-е Издание.СтандартИзначальное определение. Версия без метки.
ECMAScript 3-е Издание.СтандартДобавлена поддержка метки.
{{SpecName('ES5.1', '#sec-12.8', 'Break statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-break-statement', 'Break statement')}}{{Spec2('ES6')}} 
+ +

Совместимость с браузерами

+ +

{{ CompatibilityTable() }}

+ +
+ + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari
Базовая поддержка{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +

Смотрите также

+ + diff --git a/files/ru/web/javascript/reference/statements/class/index.html b/files/ru/web/javascript/reference/statements/class/index.html new file mode 100644 index 0000000000..3aab01ee9a --- /dev/null +++ b/files/ru/web/javascript/reference/statements/class/index.html @@ -0,0 +1,183 @@ +--- +title: class +slug: Web/JavaScript/Reference/Statements/class +translation_of: Web/JavaScript/Reference/Statements/class +--- +
{{jsSidebar("Statements")}}
+ +

Class declaration создает новый класс с данным именем на основе прототипного наследования.

+ +
+

Можно так же определить класс, используя {{jsxref("Operators/class", "class expression", "", 1)}}. Но в отличае от class expression, class declaration не позволяет снова объявить уже существующий класс, это приведёт к ошибке типа.

+
+ +

Синтаксис

+ +
class name [extends] {
+  // тело класса
+}
+
+ +

Описание

+ +

Как и class expression, тело class declaration будет исполняться в {{jsxref("Strict_mode", "строгом режиме", "", 1)}}. Свойство конструктора является опциональным.

+ +

Class declaration не {{Glossary("Hoisting", "поднимается")}} (в отличие от декларируемых функций).

+ +

Примеры

+ +

Простой class declaration

+ +

В следующем примере сначала определяется класс с именем 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 declaration вызовет ошибку типа.

+ +
class Foo {};
+class Foo {}; // Uncaught TypeError: Identifier 'Foo' has already been declared
+
+ +

Та же ошибка будет вызвана, если класс был определен перед использованием class declaration.

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

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ES6', '#sec-class-definitions', 'Class definitions')}}{{Spec2('ES6')}}Initial definition.
{{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}}{{Spec2('ESDraft')}}
+ +

Поддержка брузерами

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatChrome(42.0)}}{{CompatGeckoDesktop(45)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
Array subclassing{{CompatChrome(43.0)}}{{CompatNo}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
Allowed in sloppy mode{{CompatChrome(49.0)}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidAndroid WebviewFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Basic support{{CompatNo}}{{CompatChrome(42.0)}}{{CompatGeckoMobile(45)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatChrome(42.0)}}
Array subclassing{{CompatNo}}{{CompatChrome(43.0)}}{{CompatNo}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatChrome(43.0)}}
Allowed in sloppy mode{{CompatNo}}{{CompatChrome(49.0)}}{{CompatChrome(49.0)}}
+
+ +

Смотри также

+ + diff --git a/files/ru/web/javascript/reference/statements/const/index.html b/files/ru/web/javascript/reference/statements/const/index.html new file mode 100644 index 0000000000..351580e6dc --- /dev/null +++ b/files/ru/web/javascript/reference/statements/const/index.html @@ -0,0 +1,135 @@ +--- +title: const +slug: Web/JavaScript/Reference/Statements/const +tags: + - ECMAScript6 + - JavaScript + - const + - Константы +translation_of: Web/JavaScript/Reference/Statements/const +--- +
{{jsSidebar("Statements")}}
+ +
Значение констант не может быть изменено новым присваиванием, а также не может быть переопределено. Константы (const) подчиняются области видимости уровня блока так же, как переменные, объявленные с использованием ключевого слова let.
+ +
+ +

Синтаксис

+ +
const name1 = value1 [, name2 = value2 [, ... [, nameN = valueN]]];
+ +
+
nameN
+
Имя константы. Подчиняется тем же правилам, что и {{Glossary("identifier", "идентификаторы")}} обычных переменных.
+
valueN
+
Значение константы. Может быть любым из тех типов, которые могут быть для переменных, включая функцию.
+
+ +

Описание

+ +

Это объявление создаёт константу, чья область действия может быть как глобальной, так и локальной внутри блока, в котором она объявлена. Глобальные константы не становятся свойствами объекта window, в отличие от var-переменных. Инициализация константы обязательна; необходимо указать значение одновременно с объявлением (смысл в том, что потом это значение изменить уже нельзя).

+ +

const создаёт константу (новую именованную ссылку на область памяти), доступную только для чтения. Это не означает, что указываемое значение неизменно, но это означает, что идентификатор не может быть переназначен. Например, если константа указывает на объект, то сам объект может быть изменён.

+ +

Все соображения по поводу временных мёртвых зон, применимы и к let и к const.

+ +

Имена констант не могут совпадать с именами функций или переменных той же области видимости.

+ +

Примеры

+ +

Ниже описаны примеры, демонстрирующие поведение const. Попробуйте их выполнить в простом JavaScript-редакторе или в консоли браузера.

+ +
// Примечание: Идентификаторы констант могут быть объявлены как в верхнем,
+// так и в нижнем регистре. Но правилом хорошего тона является использование
+// верхнего регистра.
+
+// определим MY_FAV как константу и присвоим ей значение 7
+const MY_FAV = 7;
+
+// данное присваивание выдаст ошибку - Uncaught TypeError: Assignment to constant variable.
+MY_FAV = 20;
+
+// напечатает 7
+console.log("my favorite number is: " + MY_FAV);
+
+// попробуем переопределить константу, будет брошено исключение - Uncaught SyntaxError: Identifier 'MY_FAV' has already been declared
+const MY_FAV = 20;
+
+// имя MY_FAV зарезервированно константой выше, данная операция
+// выкинет исключение
+var MY_FAV = 20;
+
+// здесь также будет ошибка
+let MY_FAV = 20;
+
+// Важно отметить свойства области видимости уровня блока
+if (MY_FAV === 7) {
+    // Всё нормально. Создать константу или переменную MY_FAV можно.
+    // (работает так же как и let при объявлении в блоке переменных, которые не const)
+    const MY_FAV = 20;
+
+    // MY_FAV теперь 20
+    console.log("my favorite number is " + MY_FAV);
+
+    // это попадёт в глобальный контекст и выдаст ошибку
+    var MY_FAV = 20;
+}
+
+// MY_FAV все ещё имеет значение 7
+console.log("my favorite number is " + MY_FAV);
+
+// Выдаст ошибку, потому что константа не инициализирована - Uncaught SyntaxError: Missing initializer in const declaration
+const FOO;
+
+// const также работает с объектами
+const MY_OBJECT = {"key": "value"};
+
+// Попытка переопределить ссылку на объект вызовет исключение - Uncaught TypeError: Assignment to constant variable.
+MY_OBJECT = {"OTHER_KEY": "value"};
+
+// но, свойства объекта (ключи) можно изменять
+MY_OBJECT.key = "otherValue"; // Используйте Object.freeze() для того, чтобы сделать объект неизменяемым
+
+// То же самое применимо к массивам
+const MY_ARRAY = [];
+// Например, можно добавлять элементы в массив
+MY_ARRAY.push("A"); // ["A"]
+// Но менять ссылку на объект массива нельзя. Это вызовет исключение - Uncaught TypeError: Assignment to constant variable
+MY_ARRAY = ["B"]
+
+ +

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

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

Поддержка браузерами

+ + + +

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

+ +

Смотрите также

+ + diff --git a/files/ru/web/javascript/reference/statements/continue/index.html b/files/ru/web/javascript/reference/statements/continue/index.html new file mode 100644 index 0000000000..5cb41da72a --- /dev/null +++ b/files/ru/web/javascript/reference/statements/continue/index.html @@ -0,0 +1,200 @@ +--- +title: continue +slug: Web/JavaScript/Reference/Statements/continue +tags: + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/continue +--- +
{{jsSidebar("Statements")}}
+ +

Сводка

+ +

Инструкция continue прерывает выполнение текущей итерации текущего или отмеченного цикла, и продолжает его выполнение на следующей итерации.

+ +

Синтаксис

+ +
continue [ label ];
+ +
+
label
+
Идентификатор, являющийся меткой (label) инструкции.
+
+ +

Описание

+ +

По сравнению с инструкцией {{jsxref("Statements/break", "break")}}, continue прерывает выполнение цикла не полностью, вместо этого:

+ + + + + +

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

+ +

Примеры

+ +

Использование continue с циклом while

+ +

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

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

Использование continue вместе с меткой

+ +

В примере цикл, отмеченный checkiandj, содержит внутри себя цикл, отмеченный checkj. Если встретится инструкция continue, выполнение кода продолжится в начале блока кода checkj. При каждом вызове continue цикл checkj будет начинать новую итерацию, пока условие не начнёт возвращать false. Когда это случится, продолжится выполнение оставшейся части цикла checkiandj.

+ +

Если бы continue имело метку checkiandj, программа продолжала бы свою работу с начала цикла checkiandj.

+ +

Смотрите также {{jsxref("Statements/label", "label")}}.

+ +
var i = 0,
+    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"
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
ECMAScript 1-е Издание.СтандартИзначальное определение. Версия без метки.
ECMAScript 3-е Издание.СтандартДобавлена поддержка метки.
{{SpecName('ES5.1', '#sec-12.7', 'Continue statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-continue-statement', 'Continue statement')}}{{Spec2('ES6')}}
+ +

Поддержка браузерами

+ +

{{ CompatibilityTable() }}

+ +
+ + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari
Базовая поддержка{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +

Смотрите также

+ + diff --git a/files/ru/web/javascript/reference/statements/debugger/index.html b/files/ru/web/javascript/reference/statements/debugger/index.html new file mode 100644 index 0000000000..f6f1c58674 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/debugger/index.html @@ -0,0 +1,124 @@ +--- +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')}}Упоминается только в качестве зарезервированного слова.
+ +

Поддержка браузеров

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari
Базовая поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

См. также

+ + diff --git a/files/ru/web/javascript/reference/statements/default/index.html b/files/ru/web/javascript/reference/statements/default/index.html new file mode 100644 index 0000000000..5a6438e9c7 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/default/index.html @@ -0,0 +1,116 @@ +--- +title: default +slug: Web/JavaScript/Reference/Statements/default +tags: + - JavaScript + - Keyword + - Switch + - export +translation_of: Web/JavaScript/Reference/Statements/switch +--- +
{{jsSidebar("Statements")}}
+ +

В JavaScript ключевое слово default используется в двух случаях: внутри конструкции {{jsxref("Statements/switch", "switch")}} или с конструкцией {{jsxref("Statements/export", "export")}}.

+ +

Синтаксис

+ +

В конструкции {{jsxref("Statements/switch", "switch")}}:

+ +
switch (expression) {
+  case value1:
+    // Выражение выполнится, когда значение expression соответствует value1
+    [break;]
+  default:
+    // Выражение выполнится, когда ни одно из значений не будет соответствовать значению expression
+    [break;]
+}
+ +

С конструкцией {{jsxref("Statements/export", "export")}}:

+ +
export default nameN
+ +

Описание

+ +

Для получения дополнительной информации смотрите:

+ + + +

Примеры

+ +

Использование default в  switch

+ +

В следующем примере, если expr имеет значение  "Апельсины" или "Яблоки", то программа сопоставит это значение с "Апельсины" или с "Яблоки", а затем выполнит соответствующее выражение. В других случаях поможет ключевое слово default,  выполня связанное выражение.

+ +
switch (expr) {
+  case 'Апельсины':
+    console.log('Апельсины стоят $0.59 за фунт.');
+    break;
+  case 'Яблоки':
+    console.log('Яблоки стоят $0.32 за фунт.');
+    break;
+  default:
+    console.log(`Извините, у нас закончились ${expr}.`);
+}
+ +

Использование default с export

+ +

При необходимости экспорта единственного значения или резервирования (fallback) значения для модуля, можно воспользоваться экспортом по-умолчанию: 

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

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

+ +
// модуль "my-module.js"
+import myFunction from 'my-module';
+console.log(myFunction(3)); // 27
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ES6', '#sec-switch-statement', 'switch statement')}}{{Spec2('ES6')}}
{{SpecName('ES6', '#sec-exports', 'Exports')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-switch-statement', 'switch statement')}}{{Spec2('ESDraft')}}
{{SpecName('ESDraft', '#sec-exports', 'Exports')}}{{Spec2('ESDraft')}}
+ +

Совместимость с браузерами

+ +

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

+ +

Смотрите также

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

Выражение do...while создает цикл, который выполняет указанное выражение до тех пор, пока условие не станет ложным. Условие проверяется после выполнения выражения, то есть выражение выполнится как минимум один раз.

+ +

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

+ +

Синтаксис

+ +
do
+   выражение
+while (условие);
+
+ +
+
выражение
+
Выражение, которое выполняется как минимум один раз и выполняется на каждом шаге цикла, пока условие истинно. Выражение может содержать несколько строк, для этого необходимо сгруппировать код в {{jsxref("Statements/block", "блок")}} ({ ... }).
+
+ +
+
условие
+
Выражение, которое вычисляется после каждого шага цикла. Если условие истинно, то выражение выполняется еще раз. Когда условие ложно, выполняется выражение, следующее после 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('Примеры') }}

+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{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/ru/web/javascript/reference/statements/empty/index.html b/files/ru/web/javascript/reference/statements/empty/index.html new file mode 100644 index 0000000000..89956bf163 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/empty/index.html @@ -0,0 +1,148 @@ +--- +title: Пустая инструкция +slug: Web/JavaScript/Reference/Statements/Empty +tags: + - 'Statement, инструкция, пустая инструкция' +translation_of: Web/JavaScript/Reference/Statements/Empty +--- +
{{jsSidebar("Statements")}}
+ +

Пустая инструкция используется, когда инструкция не нужна, хотя синтаксис JavaScript будет предполагать её.

+ +

Синтаксис

+ +
;
+
+ +

Описание

+ +

Пустая инструкция - точка с запятой (;) оповещает о том, что ни одно выражение не будет выполняться, даже если синтаксис 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 истинно, ничего не пройзойдет, four не важна, и функция launchRocket() тоже не запустится.

+ +
if (one)
+  doOne();
+else if (two)
+  doTwo();
+else if (three)
+  ; // nothing here
+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')}}Изначальное определение
+ +

Поддержка браузерами

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari
Базовая поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Смотрите также

+ + diff --git a/files/ru/web/javascript/reference/statements/export/index.html b/files/ru/web/javascript/reference/statements/export/index.html new file mode 100644 index 0000000000..4eca1d3d1b --- /dev/null +++ b/files/ru/web/javascript/reference/statements/export/index.html @@ -0,0 +1,131 @@ +--- +title: export +slug: Web/JavaScript/Reference/Statements/export +tags: + - ECMAScript6 + - JavaScript + - Statement + - export + - Инструкция + - Модули +translation_of: Web/JavaScript/Reference/Statements/export +--- +
{{jsSidebar("Statements")}}
+ +

Инструкция export используется для экспорта функций, объектов или примитивов из файла (или модуля).

+ +
+

Примечание: Эта функциональность не реализована в браузерах на данный момент, но она реализована во многих транспилерах, таких как Traceur Compiler, Babel or Rollup.

+
+ +

Синтаксис

+ +
export { name1, name2, …, nameN };
+export { variable1 as name1, variable2 as name2, …, nameN };
+export let name1, name2, …, nameN; // или var
+export let name1 = …, name2 = …, …, nameN; // или var, const
+
+export default выражение;
+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 …;
+ +
+
nameN
+
Идентификатор для экспорта (чтобы он мог быть импортирован с помощью {{jsxref("Statements/import", "import")}} в другом файле (скрипте)).
+
+ +

Описание

+ +

Существует два типа экспорта, каждый из которых описан ниже:

+ + + +

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

+ +

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

+ +

Примеры

+ +

Использование именованного экспорта

+ +

Мы могли бы использовать следующий код в модуле:

+ +
// модуль"my-module.js"
+function cube(x) {
+  return x * x * x;
+}
+const foo = Math.PI + Math.SQRT2;
+export { cube, foo };
+
+ +

Таким образом в другом скрипте при помощи импорта (см. import) мы могли бы получить следующее:

+ +
import { cube, foo } from 'my-module';
+console.log(cube(3)); // 27
+console.log(foo);    // 4.555806215962888
+ +

Использование export default

+ +

Если мы хотим экспортировать единственное значение или иметь резервное значение (fallback) для данного модуля, мы можем использовать export default.

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

Затем, в другом скрипте можно импортировать это значение по умолчанию таким образом:

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

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

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

Совместимость с браузерами

+ + + +

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

+ +

Смотри также

+ + diff --git a/files/ru/web/javascript/reference/statements/for-await...of/index.html b/files/ru/web/javascript/reference/statements/for-await...of/index.html new file mode 100644 index 0000000000..72200e4004 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/for-await...of/index.html @@ -0,0 +1,139 @@ +--- +title: for await...of +slug: Web/JavaScript/Reference/Statements/for-await...of +tags: + - JavaScript + - async + - Асинхронность + - ДжаваСкрипт +translation_of: Web/JavaScript/Reference/Statements/for-await...of +--- +
{{jsSidebar("Statements")}}
+ +

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

+ + + +

Синтаксис

+ +
for await (variable of iterable) {
+  statement
+}
+
+ +
+
variable
+
На каждой итерации значение другого свойства присваивается variable. variable может быть объявлена с помощью ключевых слов const, let, or var.
+
iterable
+
Объект, чьи итерируемые свойства будут повторяться.
+
+ +

Итерирование по асинхронным переменным

+ +

Вы также можете перебрать объект, который явно реализует асинхронный итерируемый протокол.

+ +
var 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
+
+ +

Итерирование по асинхронным генераторам.

+ +

Поскольку асинхронные генераторы реализуют асинхронный протокол Iterator, по ним можно пройти циклом с помощью for await... of

+ +
async function* asyncGenerator() {
+  var 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* streamAsyncIterator(stream) {
+  const reader = stream.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        return;
+      }
+      yield value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+// Fetches data from url and calculates response size using the async generator.
+async function getResponseSize(url) {
+  const response = await fetch(url);
+  // Will hold the size of the response, in bytes.
+  let responseSize = 0;
+  // The for-await-of loop. Async iterates over each portion of the response.
+  for await (const chunk of streamAsyncIterator(response.body)) {
+    // Incrementing the total response length.
+    responseSize += chunk.length;
+  }
+
+  console.log(`Response Size: ${responseSize} bytes`);
+  // expected output: "Response Size: 1071472"
+  return responseSize;
+}
+getResponseSize('https://jsonplaceholder.typicode.com/photos');
+ +

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

+ + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ESDraft', '#sec-for-in-and-for-of-statements', 'ECMAScript Language: The for-in, for-of, and for-await-of Statements')}}{{Spec2('ESDraft')}}
+ +

Браузерная совместимость

+ + + +

Смотрите также

+ + diff --git a/files/ru/web/javascript/reference/statements/for...in/index.html b/files/ru/web/javascript/reference/statements/for...in/index.html new file mode 100644 index 0000000000..6cca45033b --- /dev/null +++ b/files/ru/web/javascript/reference/statements/for...in/index.html @@ -0,0 +1,197 @@ +--- +title: for...in +slug: Web/JavaScript/Reference/Statements/for...in +tags: + - JavaScript + - Выражение + - Цикл +translation_of: Web/JavaScript/Reference/Statements/for...in +--- +
{{jsSidebar("Statements")}}
+ +

Цикл for...in проходит через перечисляемые свойства объекта. Он пройдёт по каждому отдельному элементу.

+ +

Синтаксис

+ +
for (variable in object) {...
+}
+ +
+
variable
+
Другое (очередное) имя свойства назначается переменной на каждой итерации.
+
object
+
Объект, по чьим свойствам мы проходим
+
+ +

Описание

+ +

Цикл for...in проходит только по перечисляемым свойствам. Объекты, созданные встроенными конструкторами, такими как Array и Object имеют неперечисляемые свойства от Object.prototype и String.prototype, например, от {{jsxref("String")}}-это {{jsxref("String.indexOf", "indexOf()")}}, а от {{jsxref("Object")}} - метод {{jsxref("Object.toString", "toString()")}}. Цикл пройдёт по всем перечисляемым свойствам объекта, а также тем, что он унаследует от конструктора прототипа (свойства объекта в цепи прототипа).

+ +

Удаление, добавление и модификация свойств

+ +

Цикл 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")}}. Кроме того, если вы знаете, что не будет вмешательства в код извне, вы можете расширить встроенные прототипы методом проверки.

+ +

Примеры

+ +

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

+ +
var obj = {a:1, b:2, c:3};
+
+for (var 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 (var prop in obj) {
+  if( obj.hasOwnProperty( prop ) ) {
+    console.log("obj." + prop + " = " + obj[prop]);
+  }
+}
+
+// Выведет:
+// "obj.color = red"
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ES6', '#sec-for-in-and-for-of-statements', 'for...in statement')}}{{Spec2('ES6')}} 
{{SpecName('ES5.1', '#sec-12.6.4', 'for...in statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES3', '#sec-12.6.4', 'for...in statement')}}{{Spec2('ES3')}} 
{{SpecName('ES1', '#sec-12.6.3', 'for...in statement')}}{{Spec2('ES1')}}Изначальное определение
+ +

Поддержка браузерами

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari
Базовая поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Поддержка: инициализатор переменных

+ +

До SpiderMonkey 40 {{geckoRelease(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/ru/web/javascript/reference/statements/for...of/index.html b/files/ru/web/javascript/reference/statements/for...of/index.html new file mode 100644 index 0000000000..0074719d06 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/for...of/index.html @@ -0,0 +1,302 @@ +--- +title: for...of +slug: Web/JavaScript/Reference/Statements/for...of +tags: + - ECMAScript6 + - JavaScript + - Оператор + - Экспериментальный +translation_of: Web/JavaScript/Reference/Statements/for...of +--- +
{{jsSidebar("Statements")}}
+ +

Сводка

+ +

Оператор for...of выполняет цикл обхода итерируемых объектов (включая {{jsxref("Array")}}, {{jsxref("Map")}}, {{jsxref("Set")}}, объект аргументов и подобных), вызывая на каждом шаге итерации операторы для каждого значения из различных свойств объекта.

+ +

Синтаксис

+ +
for (variable of iterable) {
+  statement
+}
+
+ +
+
variable
+
На каждом шаге итерации variable присваивается значение нового свойства объекта iterable. Переменная 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 = 'boo';
+
+for (let value of iterable) {
+  console.log(value);
+}
+// "b"
+// "o"
+// "o"
+ +

Обход {{jsxref("TypedArray")}}

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

Обход {{jsxref("Map")}}

+ +
let iterable = new Map([['a', 1], ['b', 2], ['c', 3]]);
+
+for (let entry of iterable) {
+  console.log(entry);
+}
+// ['a', 1]
+// ['b', 2]
+// ['c', 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
+ +

Обход объекта {{jsxref("arguments")}} 

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

Обход DOM коллекций

+ +

Обход DOM коллекций наподобие {{domxref("NodeList")}}: следующий пример добавляет класс read параграфам, являющимся непосредственными потомками статей:

+ +
// Примечание: работает только на платформах, где
+// реализован 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; //  итератор закрывается, возврат
+}
+
+ +

Обход генераторов

+ +

Вы можете выполнять обход генераторов, вот пример:

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

Не пытайтесь повторно использовать генератор

+ +

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

+ +
var 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); // Не будет вызван
+}
+ +

Обход итерируемых объектов

+ +

Кроме того, можно сделать обход объекта, явно реализующего iterable:

+ +
var iterable = {
+  [Symbol.iterator]() {
+    return {
+      i: 0,
+      next() {
+        if (this.i < 3) {
+          return { value: this.i++, done: false };
+        }
+        return { value: undefined, done: true };
+      }
+    };
+  }
+};
+
+for (var 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 = 'hello';
+
+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 = 'hello';
+ +

Каждый объект унаследует метод 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 и hello поскольку они не являются перечисляемыми, фактически они вообще не являются свойствами, они являютя значениями. Выводятся же имена свойств и методов, например arrCustom и objCustom. Если вы еще не совсем поняли, по каким свойствам осуществляется обход, вот дополнительное объяснение того, как работает {{jsxref("Statements/for...in", "array iteration and for...in", "#Array_iteration_and_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/ru/web/javascript/reference/statements/for/index.html b/files/ru/web/javascript/reference/statements/for/index.html new file mode 100644 index 0000000000..40945dffda --- /dev/null +++ b/files/ru/web/javascript/reference/statements/for/index.html @@ -0,0 +1,194 @@ +--- +title: for +slug: Web/JavaScript/Reference/Statements/for +translation_of: Web/JavaScript/Reference/Statements/for +--- +
+
{{jsSidebar("Statements")}}
+
+ +

Введение

+ +

Выражение for создаёт цикл, состоящий из 3 необязательных выражений в круглых скобках, разделённых точками с запятой.

+ +

Синтаксис

+ +
for ([инициализация]; [условие]; [финальное выражение])выражение
+
+ +
+
инициализация
+
Выражение (в том числе выражения присвоения) или определение переменных. Обычно используется, чтобы инициализировать счётчик. Это выражение может опционально объявлять новые переменные с помощью ключевого слова var. Эти переменные видимы не только в цикле, т.е. в той же области области видимости, что и цикл for. Результат этого выражения отбрасывается.
+
условие
+
Выражение, выполняющееся на каждой интерации цикла. Если выражение истинно, цикл выполняется. Условие не является обязательным. Если его нет, условие всегда считается истиной. Если выражение ложно, выполнение переходит к первому выражению, следующему за for.
+
финальное выражение
+
Выражение, выполняющееся в конце интерации цикла. Происходит до следующего выполнения условия. Обычно используется для обновления или увеличения переменной счётчика.
+
выражение
+
Выражение, которое выполняется, когда условие цикла истинно. Чтоб выполнить множество выражений в цикле, используйте блок ({ ... }) для группировки этих выражений. Чтобы не выполнять никакого выражения в цикле, используйте пустое выражение (;).
+
+ +

Примеры

+ +

Использование for

+ +

Следующий цикл for начинается объявлением переменной i и задания ей значения 0. Затем проверяет, что i меньше девяти, выполняет выражения внутри цикла и увеличивает i на 1 каждый раз.

+ +
for (var i = 0; i < 9; i++) {
+   console.log(i);
+   // ещё какие-то выражения
+}
+
+ +

Необязательные выражения в  for

+ +

Все 3 выражения в цикле for не обязательны.

+ +

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

+ +
var i = 0;
+for (; i < 9; i++) {
+    console.log(i);
+    // ещё выражения
+}
+
+ +

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

+ +
for (var i = 0;; i++) {
+   console.log(i);
+   if (i > 3) break;
+   // тут какой-то код
+}
+ +

Вы можете пропустить все 3 блока. Снова убедитесь, что используете break, чтоб закончить цикл, а также изменить счётчик, так что условие для break было истинно в нужный момент.

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

Использование for без блока выражений

+ +

Следующий цикл for вычисляет смещение позиции узла в секции [финальное выражение], и, следовательно, не требует использования выражения внутри цикла или блока, пустое выражение используется вместо этого.

+ +
function showOffsetPos (sId) {
+  var nLeft = 0, nTop = 0;
+
+  for (var oItNode = document.getElementById(sId); // инициализация
+       oItNode; // условие
+       nLeft += oItNode.offsetLeft, nTop += oItNode.offsetTop, oItNode = oItNode.offsetParent) // финальное выражение
+       /* пустое выражение */ ;
+
+  console.log("Смещение позиции элемента \"" + sId + "\":\n left: " + nLeft + "px;\n top: " + nTop + "px;");
+}
+
+// Пример вызова:
+
+showOffsetPos("content");
+
+// Выводит:
+// "Смещение позиции элемента "content":
+// left: 0px;
+// top: 153px;"
+ +
Замечание: В этом случае, когда вы не используете условие внутри цикла, точка с запятой ставится сразу после выражения цикла.
+ +

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

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

Поддержка в браузерах

+ +

{{ CompatibilityTable() }}

+ +
+ + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari
Базовая поддержка{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +

Также можете просмотреть

+ + diff --git a/files/ru/web/javascript/reference/statements/for_each...in/index.html b/files/ru/web/javascript/reference/statements/for_each...in/index.html new file mode 100644 index 0000000000..c609f436c0 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/for_each...in/index.html @@ -0,0 +1,126 @@ +--- +title: for each...in +slug: Web/JavaScript/Reference/Statements/for_each...in +translation_of: Archive/Web/JavaScript/for_each...in +--- +
{{jsSidebar("Statements")}}
+ +
+

Конструкция for each...in заявлена как "deprecated", как часть стандарта ECMA-357 (E4X). Поддержка E4X была удалена. Вместо for each...in рассмотрите использование for...of. (Пожалуйста обратите внимание: {{ bug("791343")}}.)
+
+ Firefox теперь предупреждает об использовании for each...in и for each...in удаляется из ночных сборок. Пожалуйста, посмотрите Warning: JavaScript 1.6's for-each-in loops are deprecated для помощи в миграции.

+
+ +

Выражение for each...in выполняет перебор свойств указанного объекта. Для каждого свойства выполняется указанный оператор.

+ +

Синтаксис

+ +
for each (variable in object) {
+  statement
+}
+ +
+
variable
+
Variable to iterate over property values, optionally declared with the var keyword. This variable is local to the function, not to the loop.
+
+ +
+
object
+
Object for which the properties are iterated.
+
+ +
+
statement
+
A statement to execute for each property. To execute multiple statements within the loop, use a block statement ({ ... }) to group those statements.
+
+ +

Description

+ +

Some built-in properties are not iterated over. These include all built-in methods of objects, e.g. String's indexOf method. However, all user-defined properties are iterated over.

+ +

Examples

+ +

Using for each...in

+ +

Warning: Never use a loop like this on arrays. Only use it on objects. See for...in for more details.

+ +

The following snippet iterates over an object's properties, calculating their sum:

+ +
var sum = 0;
+var obj = {prop1: 5, prop2: 13, prop3: 8};
+
+for each (var item in obj) {
+  sum += item;
+}
+
+console.log(sum); // logs "26", which is 5+13+8
+ +

Specifications

+ +

Not part of a current ECMA-262 specification. Implemented in JavaScript 1.6 and deprecated.

+ +

Браузерная совместимость

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatNo}}{{CompatGeckoDesktop("1.8")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("1.0")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

Firefox specific note

+ + + +

Смотрите также

+ + diff --git a/files/ru/web/javascript/reference/statements/function/index.html b/files/ru/web/javascript/reference/statements/function/index.html new file mode 100644 index 0000000000..37ccac9a29 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/function/index.html @@ -0,0 +1,125 @@ +--- +title: function +slug: Web/JavaScript/Reference/Statements/function +tags: + - JavaScript + - Функция +translation_of: Web/JavaScript/Reference/Statements/function +--- +
{{jsSidebar("Statements")}}
+ +

Объявление функции определяет функцию с указанными аргументами.

+ +

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

+ +

Синтаксис

+ +
function name([param,[, param,[..., param]]]) {
+   [statements]
+}
+
+ +
+
name
+
Имя функции.
+
paramN
+
Имя аргумента, переданного в функцию. Максимальное количество аргументов, которое может принять функция, может варьироваться в зависимости от движков.
+
statements
+
Инструкции, которые составляют тело функции.
+
+ +

Описание

+ +

Функция, созданная через объявление функции, является объектом Function и обладает всеми свойствами, методами и поведением объектов такого типа. Смотрите {{jsxref("Function")}} для подробной информации о функциях.

+ +

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

+ +

По умолчанию функции возвращают undefined. Чтобы вернуть другое значение, функция должна содержать инструкцию {{jsxref("Statements/return", "return")}}, которая указывает, какое значение возвращать.

+ +

Функции, создаваемые по условию

+ +

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

+ +

Поднимание объявленной функции

+ +

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

+ +
hoisted(); // выводит "foo"
+
+function hoisted() {
+  console.log("foo");
+}
+
+ +

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

+ +
notHoisted(); // TypeError: notHoisted не является функцией
+
+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/ru/web/javascript/reference/statements/function_star_/index.html b/files/ru/web/javascript/reference/statements/function_star_/index.html new file mode 100644 index 0000000000..69567963bb --- /dev/null +++ b/files/ru/web/javascript/reference/statements/function_star_/index.html @@ -0,0 +1,202 @@ +--- +title: function* +slug: Web/JavaScript/Reference/Statements/function* +tags: + - ECMAScript6 + - JavaScript + - Итератор + - Функция + - Экспериментальный +translation_of: Web/JavaScript/Reference/Statements/function* +--- +
{{jsSidebar("Statements")}}
+ +

Сводка

+ +

function* (ключевое слово function со звёздочкой) определяет функцию-генератор.

+ +

Синтаксис

+ +
function* name([param[, param[, ... param]]]) { statements }
+
+ +
+
name
+
Имя функции.
+
param
+
Именованные аргументы функции (параметры). Функция-генератор может иметь 255 аргументов.
+
statements
+
Инструкции составляющие тело функции.
+
+ +

Описание

+ +

Генераторы являются функциями с возможностью выхода и последующего входа. Их контекст исполнения (значения переменных) сохраняется при последующих входах.

+ +

Когда вызывается функция-генератор, её тело исполняется не сразу; вместо этого возвращается объект-итератор. При вызове метода next() итератора тело функции-генератора исполняется до первого встреченного оператора yield, который определяет возвращаемое значение или делегирует дальнейшее выполнение другому генератору при помощи yield* anotherGenerator(). Метод next() возвращает объект со свойством value, содержащим отданное значение, и свойством done, которое указывает, что генератор уже отдал своё последнее значение. Вызов метода next() с аргументом прекращает выполнение функции-генератора, и заменяет инструкцию yield на которой было приостановлено выполнение  на аргумент переданный в next().

+ +

Примеры

+ +

Простой пример

+ +
function* idMaker() {
+  var index = 0;
+  while (index < 3)
+    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); // undefined
+// ...
+ +

Пример с 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
+ +

Передача аргументов в генератор

+ +
function* logGenerator() {
+  console.log(yield);
+  console.log(yield);
+  console.log(yield);
+}
+
+var gen = logGenerator();
+
+// первый вызов next выполняется от начала функции
+// и до первого оператора yield
+gen.next();
+gen.next('pretzel'); // pretzel
+gen.next('california'); // california
+gen.next('mayonnaise'); // mayonnaise
+ +

Инструкция return в генераторе

+ +
function* yieldAndReturn() {
+  yield "Y";
+  return "R";
+  yield "unreachable";
+}
+
+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 }
+ +

Генераторы не могут быть инстанцированы (not constructable)

+ +
function* f() {}
+var obj = new f; // throws "TypeError: f is not a constructor"
+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
Предложение HarmonyЧерновикНачало работы над стандартом.
{{SpecName('ES2015', '#sec-generator-function-definitions', 'Генераторы')}}{{Spec2('ES2015')}}Изначальное определение в стандарте ECMA.
+ +

Совместимость с браузерами

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari (WebKit)
Базовая поддержка39{{CompatGeckoDesktop("26.0")}}{{CompatNo}}26{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidFirefox Mobile (Gecko)IE PhoneOpera MobileSafari Mobile
Базовая поддержкаyes (when?){{CompatGeckoMobile("27.0")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

Генераторы и итераторы до версии Firefox 26

+ +

В старых версиях Firefox была реализована иная версия генераторов. В ней генераторы определялись обычным ключевым словом function (без звёздочки) и имели некоторые другие отличия.

+ +

Смотрите также

+ + diff --git a/files/ru/web/javascript/reference/statements/if...else/index.html b/files/ru/web/javascript/reference/statements/if...else/index.html new file mode 100644 index 0000000000..1f9d474145 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/if...else/index.html @@ -0,0 +1,213 @@ +--- +title: if...else +slug: Web/JavaScript/Reference/Statements/if...else +tags: + - Выражение + - Условие +translation_of: Web/JavaScript/Reference/Statements/if...else +--- +
{{jsSidebar("Statements")}}
+ +

Инструкция if выполняет инструкцию, если указанное условие выполняется (истинно). Если условие не выполняется (ложно), то может быть выполнена другая инструкция.

+ +

Синтаксис

+ +
if (условие)
+   инструкция1
+[else
+   инструкция2]
+
+ +
+
условие
+
Выражение, которое является либо истинным, либо ложным.
+
+ +
+
инструкция1
+
Инструкция, выполняемая в случае, если значение "условиe" истинно (true). Может быть любой инструкцией в том числе и вложенным if. Для группировки нескольких инструкций используется блок ({...}), Когда никакого действия не требуется, может использоваться пустая инструкция.
+
+ +
+
инструкция2
+
Инструкция, выполняемая в случае, если значение "условиe" ложно (false). Может быть любой инструкцией, в том числе и вложенным if. Инструкции тоже  можно группировать в блок.
+
+ +

Описание

+ +

Несколько команд if ... else могут быть вложены для создания условия else if. Обратите внимание, что в JavaScript нет ключевого слова elseif (в одно слово).

+ +
if (условие1)
+   инструкция1
+else if (условие2)
+   инструкция2
+else if (условие3)
+   инструкция3
+...
+else
+   инструкцияN
+
+
+ +

Чтобы увидеть, как это работает, ниже представлен пример правильного вложения с отступами:

+ +
if (условие1)
+   инструкция1
+else
+   if (условие2)
+      инструкция2
+   else
+      if (условие3)
+...
+
+ +

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

+ +
if (условие) {
+   инструкции1
+} else {
+   инструкции2
+}
+
+ +

Не путайте примитивные логические значения true и false с правдивостью или ложностью булева объекта. Любое значение, которое не undefined, null, 0, NaN или пустая строка (""), и любой объект, включая объект Boolean, значение которого является ложным, считается правдивым при использовании в качестве условия. Например:

+ +
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 > 5) {
+
+} else if (x > 50) {
+
+} 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')}}Начальное определение
+ +

Совместимость браузеров

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
СвойствоChromeFirefox (Gecko)Internet ExplorerOperaSafari
Основная поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
СвойствоAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Основная поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Смотрите также

+ + diff --git a/files/ru/web/javascript/reference/statements/import.meta/index.html b/files/ru/web/javascript/reference/statements/import.meta/index.html new file mode 100644 index 0000000000..ac60a71494 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/import.meta/index.html @@ -0,0 +1,68 @@ +--- +title: import.meta +slug: Web/JavaScript/Reference/Statements/import.meta +tags: + - Модули +translation_of: Web/JavaScript/Reference/Statements/import.meta +--- +
{{JSSidebar("Statements")}}
+ +

Объект import.meta это мета-свойство, указывающее мета-данные JavaScript модуля в зависимости от контекста. Он содержит информацию о модуле, например, URL модуля.

+ +

Синтакс

+ +
import.meta
+ +

Описание

+ +

Объект import.meta состоит из ключевого слова {{JSxRef("Statements/import","import")}}, точки и свойства с именем meta. Обычно выражение import. служит для доступа к свойству, но здесь import., в действительности, не является объектом.

+ +

Объект import.meta создан по реализации ECMAScript с прототипом объекта {{JSxRef("null")}}. Этот объект расширяем, и его свойства являются записываемыми, настраиваемыми и перечисляемыми.

+ +

Примеры

+ +

Допустим, есть модуль my-module.js

+ +
<script type="module" src="my-module.js"></script>
+
+ +

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

+ +
console.log(import.meta); // { url: "file:///home/user/my-module.js" }
+ +

Это возвращает объект со свойством url показывающее базовый URL этого модуля. Это может быть либо URL с которого скрипт был получен (для внешних скриптов), либо базовый URL содержащего его документа (для внутренних скриптов).

+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
Предложен import.metaStage 3Первичное определение
{{SpecName("HTML WHATWG", "webappapis.html#hostgetimportmetaproperties", "import.meta")}}{{Spec2("HTML WHATWG")}}Определяет свойства import.meta в HTML.
+ +

Совместимость браузеров

+ + + +

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

+ +

Смотрите также

+ + diff --git a/files/ru/web/javascript/reference/statements/import/index.html b/files/ru/web/javascript/reference/statements/import/index.html new file mode 100644 index 0000000000..bc4a369f52 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/import/index.html @@ -0,0 +1,271 @@ +--- +title: import +slug: Web/JavaScript/Reference/Statements/import +tags: + - ECMAScript 2015 + - ECMAScript6 + - JavaScript + - import + - Инструкция + - Модули + - динамический импорт + - импорт +translation_of: Web/JavaScript/Reference/Statements/import +--- +
{{jsSidebar("Statements")}}
+ +

Инструкция import используется для импорта ссылок на значения, экспортированные из внешнего модуля. Импортированные модули находятся в {{JSxRef ("Strict_mode", "строгом режиме")}} независимо от того, объявляете ли вы их как таковые или нет. Для работы инструкции во встроенных скриптах нужно прописать у тэга script type="module".

+ +

Существует также function-like динамический import(), который не требует скриптов с типом "module".

+ +

Обратная совместимость может быть обеспечена с помощью атрибута nomodule тега script.

+ +

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

+ +
+

Внимание: На данный момент эта функциональность только начинает поддерживаться браузерами. Полноценная реализация присутствует во многих транспайлерах, таких как TypeScript и Babel, а также в сборщиках, например, в Rollup и Webpack.

+
+ +

Синтаксис

+ +
import defaultExport from "module-name";
+import * as name from "module-name";
+import { export } from "module-name";
+import { export as alias } from "module-name";
+import { export1 , export2 } from "module-name";
+import { export1 , export2 as alias2 , […] } from "module-name";
+import defaultExport, { export [ , […] ] } from "module-name";
+import defaultExport, * as name from "module-name";
+import "module-name";
+import("/module-name.js").then(module => {…}) // Динамический импорт
+
+ +
+
defaultExport
+
Имя объекта, который будет ссылаться на значение экспорта по умолчанию (дефолтный экспорт) из модуля.
+
module-name
+
Имя модуля для импорта. Это зачастую относительный или абсолютный путь к .js файлу модуля без указания расширения .js. Некоторые сборщики могут разрешать или даже требовать использования расширения; проверяйте своё рабочее окружение. Допускаются только строки с одиночными или двойными кавычками.
+
name
+
Имя локального обьекта, который будет использован как своего рода пространство имен, ссылающееся на импортируемые значения.
+
+ +
+
export, exportN
+
Имена значений, которые будут импортированы.
+
+ +
+
alias, aliasN
+
Имена, которые будут ссылаться на импортируемые значения.
+
+ +

Описание

+ +

Параметр name это имя локального обьекта, который будет использован как своего рода пространство имен, ссылающееся на импортируемые значения. Параметры export определяют отдельные именованные значения, в то время как import * as name импортирует все значения. Примеры ниже объясняют синтаксис.

+ +

Импорт всего содержимого модуля

+ +

Этот код вставляет объект myModule в текущую область видимости, содержащую все экспортированные значения из модуля, находящегося в файле /modules/my-module.js.

+ +
import * as myModule from '/modules/my-module.js';
+ +

В данном случае, доступ к импортируемым значениям можно осуществить с использованием имени модуля (в данном случае "myModule") в качестве пространства имен. Например, если импортируемый выше модуль включает в себя экспорт метода doAllTheAmazingThings(), вы можете вызвать его так:

+ +
myModule.doAllTheAmazingThings();
+ +

Импорт единичного значения из модуля

+ +

Определенное ранее значение, названное myExport, которое было экспортировано из модуля my-module либо неявно (если модуль был экспортирован целиком), либо явно (с использованием инструкции {{jsxref("Statements/export", "export")}}), позволяет вставить myExport в текущую область видимости.

+ +
import {myExport} from '/modules/my-module.js';
+ +

Импорт нескольких единичных значений

+ +

Этот код  вставляет оба значения foo и bar в текущую область видимости.

+ +
import {foo, bar} from '/modules/my-module.js';
+ +

Импорт значений с использованием более удобных имен

+ +

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

+ +
import {reallyReallyLongModuleExportName as shortName}
+  from '/modules/my-module.js';
+ +

Переименование нескольких значений в одном импорте

+ +

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

+ +
import {
+  reallyReallyLongModuleExportName as shortName,
+  anotherLongModuleName as short
+} from '/modules/my-module.js';
+ +

Импорт модуля для использования его побочного эффекта

+ +

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

+ +
import '/modules/my-module.js';
+
+ +

Импорт значения по умолчанию

+ +

Есть возможность задать дефолтный {{jsxref("Statements/export", "export")}} (будь то объект, функция, класс или др.). Инструкция import затем может быть использована для импорта таких значений.

+ +

Простейшая версия прямого импорта значения по умолчанию:

+ +
import myDefault from '/modules/my-module.js';
+
+ +

Возможно также использование такого синтаксиса с другими вариантами из перечисленных выше (импорт пространства имен или именованный импорт). В таком случае, импорт значения по умолчанию должен быть определён первым. Для примера:

+ +
import myDefault, * as myModule from '/modules/my-module.js';
+// myModule использовано как пространство имен
+ +

или

+ +
import myDefault, {foo, bar} from '/modules/my-module.js';
+// именованный импорт конкретных значений
+ +

Импорт переменных

+ +

Если вы импортируете переменные, то в данной области видимости они ведут себя как константы.

+ +

Такой код выведет ошибку:

+ +
my-module.js
+ +
export let a = 2;
+export let b = 3;
+
+ +
main.js
+ +
import {a, b} from '/modules/my-module.js';
+a = 5;
+b = 6;
+// Uncaught TypeError: Assignment to constant variable.
+ +

Для импорта можно воспользоваться объектом в котором хранятся эти переменные.

+ +

Такой код будет рабочим:

+ +
my-module.js
+ +
export let obj = {a:2, b:4};
+
+ +
main.js
+ +
import {obj} from '/modules/my-module.js';
+
+obj.a = 1;
+obj.b = 4;
+ +

Учитывая, что import хранит именно ссылки на значения, экспортированные из внешнего модуля, то это можно использовать как замыкания.

+ +

Динамический импорт

+ +

Ключевое слово import можно использовать как функцию для динамического импорта модулей. Вызов import() возвращает Promise.

+ +
import('/modules/my-module.js')
+  .then(module => {
+    // Делаем что-нибудь с модулем
+  })
+
+ +

Как следствие возврата Promise, с динамическим импортом можно использовать ключевое слово await

+ +
let module = await import('/modules/my-module.js');
+ +

Обратите внимание, что несмотря на то, что динамический импорт выглядит как вызов функции, он им по сути не является, т.е. не наследует от Function.prototype и, как следствие, его невозможно использовать вместе с методами .call, .apply и .bind

+ +

Примеры

+ +

Импорт из вспомогательного модуля для помощи в обработке запроса AJAX JSON.

+ +

Модуль: file.js

+ +
function getJSON(url, callback) {
+  let xhr = new XMLHttpRequest();
+  xhr.onload = function () {
+     callback(this.responseText)
+  };
+  xhr.open('GET', url, true);
+  xhr.send();
+}
+
+export function getUsefulContents(url, callback) {
+  getJSON(url, data => callback(JSON.parse(data)));
+}
+
+ +

Основной код: main.js

+ +
import { getUsefulContents } from '/modules/file.js';
+
+getUsefulContents('http://www.example.com',
+    data => { doSomethingUseful(data); });
+ +

Динамический импорт

+ +

Этот пример показывает, как можно загрузить на страницу дополнительный модуль в зависимости от действий пользователя (в данном случае, по клику на кнопку), а затем использовать функции из загруженного модуля. Промисы - это не единственный способ использовать динамический импорт. Функция import() также может использоваться совместно с await.

+ +
const main = document.querySelector("main");
+for (const link of document.querySelectorAll("nav > a")) {
+  link.addEventListener("click", e => {
+    e.preventDefault();
+
+    import('/modules/my-module.js')
+      .then(module => {
+        module.loadPageInto(main);
+      })
+      .catch(err => {
+        main.textContent = err.message;
+      });
+  });
+}
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомменарий
{{SpecName('ES2015', '#sec-imports', 'Imports')}}{{Spec2('ES2015')}}Начальное определение.
{{SpecName('ES2020', '#sec-imports', 'Imports')}}{{Spec2('ES2020')}}
{{SpecName('ESDraft', '#sec-imports', 'Imports')}}{{Spec2('ESDraft')}}
+ +

Совместимость

+ + + +

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

+ +

Смотри также

+ + diff --git a/files/ru/web/javascript/reference/statements/index.html b/files/ru/web/javascript/reference/statements/index.html new file mode 100644 index 0000000000..11c44fdf08 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/index.html @@ -0,0 +1,162 @@ +--- +title: Инструкции и объявления +slug: Web/JavaScript/Reference/Statements +tags: + - JavaScript + - Reference + - statements +translation_of: Web/JavaScript/Reference/Statements +--- +
+ {{jsSidebar("Statements")}}
+

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

+

Инструкции и объявления по категориям

+

Алфавитный список смотрите в боковой панели слева.

+

Управление потоком выполнения

+
+
+ {{jsxref("Statements/block", "Блок", "", 1)}}
+
+ Блок используется для группировки нуля и более инструкций. Блок отделяется парой фигурных скобок.
+
+ {{jsxref("Statements/break", "break")}}
+
+ Прерывает текущую инструкцию цикла, ветвления или инструкцию с меткой и передаёт управление на инструкцию, следующую за прерываемой.
+
+ {{jsxref("Statements/continue", "continue")}}
+
+ Прерывает выполнение инструкции в текущей итерации текущего цикла или цикла с меткой и продолжает выполнение цикла со следующей итерации.
+
+ {{jsxref("Statements/Empty", "Пустая инструкция", "", 1)}}
+
+ Пустая инструкция используется тогда, когда никакой инструкции быть не должно, а по синтаксису JavaScript она требуется.
+
+ {{jsxref("Statements/if...else", "if...else")}}
+
+ Выполняет инструкцию, если указанное условие является истинным. Если условие ложно, выполняет другую инструкцию.
+
+ {{jsxref("Statements/switch", "switch")}}
+
+ Вычисляет выражение, сопоставляет вычисленное значение с выражением выбора и выполняет инструкции, ассоциированные с этим выбором.
+
+ {{jsxref("Statements/throw", "throw")}}
+
+ Выбрасывает пользовательское исключение.
+
+ {{jsxref("Statements/try...catch", "try...catch")}}
+
+ Помечает блок инструкций и определяет реакцию на возникновение исключения внутри помеченного блока инструкций.
+
+

Объявления

+
+
+ {{jsxref("Statements/var", "var")}}
+
+ Объявляет переменную, необязательно инициализирует её значением.
+
+ {{experimental_inline}} {{jsxref("Statements/let", "let")}}
+
+ Объявляет локальную переменную в области видимости блока, необязательно инициализирует её значением.
+
+ {{experimental_inline}} {{jsxref("Statements/const", "const")}}
+
+ Объявляет именованную константу только для чтения.
+
+

Функции

+
+
+ {{jsxref("Statements/function", "function")}}
+
+ Объявляет функцию с указанными параметрами.
+
+ {{experimental_inline}} {{jsxref("Statements/function*", "function*")}}
+
+ Функции-генераторы, упрощающие написание итераторов.
+
+ {{jsxref("Statements/return", "return")}}
+
+ Определяет значение, возвращаемое из функции.
+
+ {{experimental_inline}} {{jsxref("Statements/yield", "yield")}}
+
+ Смотрите статьи Что нового в JavaScript 1.7 и Итераторы и генераторы.
+
+

Итерации

+
+
+ {{jsxref("Statements/do...while", "do...while")}}
+
+ Создаёт цикл, выполняющий указанную инструкцию до тех пор, пока проверяющее условие равно false. Условие вычисляется после выполнения инструкции, так что указанная инструкция выполнится хотя бы один раз.
+
+ {{jsxref("Statements/for", "for")}}
+
+ Создаёт цикл, состоящий из трёх необязательных выражений, заключённых в круглые скобки и разделённым точками с запятой с последующей инструкцией, выполняющейся в цикле.
+
+ {{deprecated_inline}} {{non-standard_inline}} {{jsxref("Statements/for_each...in", "for each...in")}}
+
+ Проходит указанной переменной по всем значениям свойств объекта. Выполняет инструкции для каждого уникального свойства.
+
+ {{jsxref("Statements/for...in", "for...in")}}
+
+ В случайном порядке проходит по перечислимым свойствам объекта. Выполняет инструкции для каждого уникального свойства.
+
+ {{experimental_inline}} {{jsxref("Statements/for...of", "for...of")}}
+
+ Проходит по итерируемым объектам (включающим в себя {{jsxref("Global_Objects/Array", "массивы", "", 1)}}, массивоподобные объекты и итераторы с генераторами), выполняя пользовательский хук с инструкциями, исполняющимися для значения каждого уникального свойства.
+
+ {{jsxref("Statements/while", "while")}}
+
+ Создаёт цикл, выполняющий указанную инструкцию до тех пор, пока проверяющее условие равно true. Условие вычисляется перед выполнением инструкции..
+
+

Прочее

+
+
+ {{jsxref("Statements/debugger", "debugger")}}
+
+ Вызывает любую доступную функциональность отладки. Если функциональность отладки не доступна, эта инструкция ничего не делает.
+
+ {{obsolete_inline}} {{jsxref("Statements/export", "export")}}
+
+ Используется для экспорта подписанным скриптом свойств, функций и объектов в другие подписанные или неподписанные скрипты. Эта древняя функциональность Netscape была удалена и будет пересмотрена модулями ECMAScript 6.
+
+ {{obsolete_inline}} {{jsxref("Statements/import", "import")}}
+
+ Используется для импорта скриптом свойств, функций и объектов из подписанного скрипта, который предоставил эту информацию. Эта древняя функциональность Netscape была удалена и будет пересмотрена модулями ECMAScript 6.
+
+ {{jsxref("Statements/label", "label")}}
+
+ Предоставляет инструкцию с идентификатором, на который вы можете сослаться с помощью инструкций break или continue.
+
+ {{deprecated_inline}} {{jsxref("Statements/with", "with")}}
+
+ Расширяет цепочку областей видимости инструкции.
+
+

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

+ + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
ECMAScript 1-е издание.СтандартИзначальное определение.
{{SpecName('ES5.1', '#sec-12', 'Инструкции')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-ecmascript-language-statements-and-declarations', 'Язык ECMAScript: инструкции и объявления')}}{{Spec2('ES6')}}Новое в этой спецификации: {{jsxref("Statements/function*", "function*")}}, {{jsxref("Statements/let", "let")}}, {{jsxref("Statements/for...of", "for...of")}}, {{jsxref("Statements/yield", "yield")}}.
+

Смотрите также

+ diff --git a/files/ru/web/javascript/reference/statements/label/index.html b/files/ru/web/javascript/reference/statements/label/index.html new file mode 100644 index 0000000000..129afe8d3f --- /dev/null +++ b/files/ru/web/javascript/reference/statements/label/index.html @@ -0,0 +1,179 @@ +--- +title: label +slug: Web/JavaScript/Reference/Statements/label +tags: + - JavaScript + - Statement + - Метка +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
+
Инструкция. break может быть использован с любой отмеченной инструкцией, а continue только с метками около начала цикла.
+
+ +

Описание

+ +

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

+ +

В JavaScript нет оператора goto, вы можете использовать только метки с break или continue.

+ +

В строгом режиме вы не можете использовать "let" как имя метки. Это генерирует ошибку {{jsxref("SyntaxError")}} (let is a reserved identifier).

+ +

Примеры

+ +

Использование метки с continue с циклом for

+ +
var i, j;
+
+loop1:
+for (i = 0; i < 3; i++) {      //Первый цикл, обозначенный меткой "loop1"
+   loop2:
+   for (j = 0; j < 3; j++) {   //Второй цикл, обозначенный меткой "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

+ +
var i, j;
+
+loop1:
+for (i = 0; i < 3; i++) {      //Первый цикл, обозначенный меткой "loop1"
+   loop2:
+   for (j = 0; j < 3; j++) {   //Второй цикл, обозначенный меткой "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;
+    }
+ +

Помеченные объявления функция

+ +

Начиная с ECMAScript 2015, помеченные объявления функция являются стандартными для нестрогого режима.

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

Однако, в строгом режиме генерируется ошибка {jsxref("SyntaxError")}}:

+ +

In strict mode code, however, this will throw a {{jsxref("SyntaxError")}}:

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

Функции-генераторы не могут быть помечены ни в том, ни в другом режиме:

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

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
ECMAScript 3-е Издание.СтандартИзначальное определение. Реализован в JavaScript 1.2.
{{SpecName('ES5.1', '#sec-12.12', 'Labelled statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-labelled-statements', 'Labelled statement')}}{{Spec2('ES6')}}
+ +

Совместимость с браузерами

+ +

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

+ +

Смотрите также

+ + diff --git a/files/ru/web/javascript/reference/statements/let/index.html b/files/ru/web/javascript/reference/statements/let/index.html new file mode 100644 index 0000000000..ac3e59d716 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/let/index.html @@ -0,0 +1,414 @@ +--- +title: let +slug: Web/JavaScript/Reference/Statements/let +translation_of: Web/JavaScript/Reference/Statements/let +--- +
{{jsSidebar("Statements")}}
+ +
Директива let объявляет переменную с блочной областью видимости с возможностью инициализировать её значением.
+ +
+ +

Синтаксис

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

Параметры

+ +
+
var1, var2, …, varN
+
Имя переменной. Может использоваться любой допустимый идентификатор.
+
value1, value2, …, valueN
+
Значение переменной. Любое допустимое выражение.
+
+ +

Описание

+ +

Директива let позволяет объявить локальную переменную с областью видимости, ограниченной текущим блоком кода . В отличие от ключевого слова var, которое объявляет переменную глобально или локально во всей функции, независимо от области блока.

+ +

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

+ +

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

+ +

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

+ +
function varTest() {
+  var x = 1;
+  if (true) {
+    var x = 2;  // та же переменная!
+    console.log(x);  // 2
+  }
+  console.log(x);  // 2
+}
+
+function letTest() {
+  let x = 1;
+  if (true) {
+    let x = 2;  // другая переменная
+    console.log(x);  // 2
+  }
+  console.log(x);  // 1
+}
+
+ +

+ +

Чище код во вложенных функциях

+ +

let иногда делает код чище при использовании вложенных функций.

+ +
var list = document.getElementById("list");
+
+for (let i = 1; i <= 5; i++) {
+  let item = document.createElement('li');
+  item.appendChild(document.createTextNode('Item ' + i));
+
+  item.onclick = function(ev) {
+    console.log('Item ' + i + ' is clicked.');
+  };
+  list.appendChild(item);
+}
+
+// чтобы получить такой же эффект с использованием 'var'
+// необходимо создать новый контекст
+// используя замыкание, чтобы сохранить значение неизменённым
+for (var i = 1; i <= 5; i++) {
+  var item = document.createElement("li");
+  item.appendChild(document.createTextNode("Item " + i));
+
+    (function(i){
+        item.onclick = function(ev) {
+            console.log('Item ' + i + ' is clicked.');
+        };
+    })(i);
+  list.appendChild(item);
+}
+ +

Пример выше будет выполнен как и ожидается, так как пять экземпляров внутренней функции (анонимной) будут ссылаться на пять разных экземпляров переменной i. Пример будет выполнен неверно, если заменить директиву let на var, или удалить переменную i из параметров вложенной функции и использовать внешнюю переменную i во внутренней функции.

+ +

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

+ +
var x = 'global_x';
+let y = 'global_y';
+console.log(this.x); // 'global_x'
+console.log(this.y); // undefined
+
+ +

В выводе программы будет отображено слово "global_x" для this.x, но undefined для this.y.

+ +

Эмуляция приватных членов

+ +

При взаимодействии с конструкторами можно использовать выражение let чтобы открыть доступ к одному или нескольким приватным членам через использование замыканий:

+ +
var SomeConstructor;
+
+{
+    let privateScope = {};
+
+    SomeConstructor = function SomeConstructor() {
+        this.someProperty = 'foo';
+        privateScope.hiddenProperty = 'bar';
+    }
+
+    SomeConstructor.prototype.showPublic = function() {
+        console.log(this.someProperty); // foo
+    }
+
+    SomeConstructor.prototype.showPrivate = function() {
+        console.log(privateScope.hiddenProperty); // bar
+    }
+
+}
+
+var myInstance = new SomeConstructor();
+
+myInstance.showPublic();
+myInstance.showPrivate();
+
+console.log(privateScope.hiddenProperty); // error
+ +

Эта техника позволяет получить только "статичное" приватное состояние - в примере выше, все экземпляры полученные из конструктора SomeConstructor будут ссылаться на одну и ту же область видимости privateScope.

+ +

Временные мертвые зоны и ошибки при использовании let

+ +

Повторное объявление той же переменной в том же блоке или функции приведет к выбросу исключения SyntaxError.

+ +
if (x) {
+  let foo;
+  let foo; // SyntaxError thrown.
+}
+ +

В стандарте ECMAScript 2015 переменные, объявленные директивой let, переносятся в начало блока. Но если вы сошлетесь в блоке на переменную, до того как она объявлена директивой let, то это приведет к выбросу исключения ReferenceError, потому что переменная находится во "временной мертвой зоне" с начала блока и до места ее объявления. (В отличии от переменной, объявленной через var, которая просто будет содержать значение undefined)

+ +
function do_something() {
+  console.log(bar); // undefined
+  console.log(foo); // ReferenceError: foo is not defined
+  var bar = 1;
+  let foo = 2;
+}
+ +

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

+ +
switch (x) {
+  case 0:
+    let foo;
+    break;
+
+  case 1:
+    let foo; // Выброс SyntaxError из-за повторного объявления переменной
+    break;
+}
+ +

Использование let в циклах for

+ +

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

+ +
var i=0;
+for ( let i=i ; i < 10 ; i++ ) {
+  console.log(i);
+}
+
+ +

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

+ +
for (let expr1; expr2; expr3) statement
+
+ +

В этом примере expr2, expr3, statement  заключены в неявный блок, который содержит блок локальных переменных, объявленых конструкцией let expr1. Пример приведен выше.

+ +

Примеры

+ +

let vs var

+ +

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

+ +
var a = 5;
+var b = 10;
+
+if (a === 5) {
+  let a = 4; // The scope is inside the if-block
+  var b = 1; // The scope is inside the function
+
+  console.log(a);  // 4
+  console.log(b);  // 1
+}
+
+console.log(a); // 5
+console.log(b); // 1
+ +

let в циклах

+ +

Вы можете использовать ключевое слово let для привязки переменных к локальной области видимости цикла for, вместо того что бы использовать глобальные переменные (объявленные с помощью var).

+ +
for (let i = 0; i<10; i++) {
+  console.log(i); // 0, 1, 2, 3, 4 ... 9
+}
+
+console.log(i); // i is not defined
+ +

Нестандартизированные расширения let

+ +

let блок

+ +
+

Поддержка let блоков была убрана в Gecko 44  {{bug(1023609)}}.

+
+ +

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

+ +

Синтаксис

+ +
let (var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]]) block;
+
+ +

Описание

+ +

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

+ +

Пример

+ +
var x = 5;
+var y = 0;
+
+let (x = x+10, y = 12) {
+  console.log(x+y); // 27
+}
+
+console.log(x + y); // 5
+
+ +

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

+ +

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

+ +

Областью видимости переменных, объявленных директивой let, в блоке let является сам блок и все подблоки в нем, если они не содержат объявлений переменных с теми же именами. 

+ +

let выражения

+ +
+

Поддержка let выражений была убрана в Gecko 41  {{bug(1023609)}}.

+
+ +

let выражение позволяет объявить переменные с областью видимости ограниченной одним выражением.

+ +

Синтаксис

+ +
let (var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]]) expression;
+ +

Пример

+ +

Вы можете использовать let для объявления переменных, областью видимости которых является только одно выражение:

+ +
var a = 5;
+let(a = 6) console.log(a); // 6
+console.log(a); // 5
+ +

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

+ +

В данном let выражении:

+ +
let (decls) expr
+
+ +

expr оборачивается в неявный блок.

+ +

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

+ + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{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')}}
+ +

Поддержка браузерами

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support +

{{CompatChrome(41.0)}}

+ 		{{ CompatGeckoDesktop("1.8.1") }} [1]1117{{CompatUnknown}}
Temporal dead zone{{CompatUnknown}}{{ CompatGeckoDesktop("35") }} [1]{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
let expression {{non-standard_inline}}{{CompatNo}}{{ CompatGeckoDesktop("1.8.1") }} [1]{{CompatNo}}{{CompatNo}}{{CompatNo}}
let block {{non-standard_inline}}{{CompatNo}}{{ CompatGeckoDesktop("1.8.1") }} [1]{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatUnknown}} +

{{CompatChrome(41.0)}}

+ 		{{ CompatGeckoMobile("1.8.1") }} [1]{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
Temporal dead zone{{CompatUnknown}}{{CompatUnknown}}{{ CompatGeckoMobile("35") }} [1]{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
let expression {{non-standard_inline}}{{CompatNo}}{{CompatNo}}{{ CompatGeckoMobile("1.8.1") }} [1]{{CompatNo}}{{CompatNo}}{{CompatNo}}
let block {{non-standard_inline}}{{CompatNo}}{{CompatNo}}{{ CompatGeckoMobile("1.8.1") }} [1]{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

+ +

Особенности Firefox

+ + diff --git a/files/ru/web/javascript/reference/statements/return/index.html b/files/ru/web/javascript/reference/statements/return/index.html new file mode 100644 index 0000000000..107173c310 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/return/index.html @@ -0,0 +1,156 @@ +--- +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 [[выражение]];
+ +
+
выражение
+
Выражение, значение которого будет возвращено. Если не указано, вместо него возвращается undefined.
+
+ +

Описание

+ +

При вызове оператора return в функции её выполнение прекращается. Указанное значение возвращается в место вызова функции. Например, приведенная ниже функция возвращает возведенное в квадрат значение своего аргумента, x (где x – это число):

+ +
function square(x) {
+   return x * x;
+}
+var demo = square(3);
+// значение demo будет равняться 9
+
+ +

Если возвращаемое значение не указано, вместо него возращается undefined.

+ +

Следующие выражения всегда прерывают выполнение функции:

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

Автоматическая расстановка точек с запятыми

+ +

На выражение return влияет автоматическая расстановка точек с запятыми (ASI). Разрыв строки не допускается между ключевым словом return и выражением.

+ +
return
+a + b;
+ +

трансформируется ASI в:

+ +
return;
+a + b;
+ +

В консоли появится предупреждение "unreachable code after return statement".

+ +
Начиная с 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(x) {
+  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/ru/web/javascript/reference/statements/switch/index.html b/files/ru/web/javascript/reference/statements/switch/index.html new file mode 100644 index 0000000000..5d0ead0986 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/switch/index.html @@ -0,0 +1,184 @@ +--- +title: switch +slug: Web/JavaScript/Reference/Statements/switch +tags: + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/switch +--- +
{{jsSidebar("Statements")}}
+ +

Сводка

+ +

Инструкция switch сравнивает выражение со случаями, перечисленными внутри неё, а затем выполняет соответствующие инструкции.

+ +

Синтаксис

+ +
switch (expression) {
+  case value1:
+    //Здесь выполняются инструкции, если результат выражения равен value1
+    [break;]
+  case value2:
+    //Инструкции, соответствующие value2
+    [break;]
+  ...
+  case valueN:
+    //Инструкции, соответствующие значению valueN
+    //statementsN
+    [break;]
+  default:
+    //Здесь находятся инструкции, которые выполняются при отсутствии соответствующего значения
+    //statements_def
+    [break;]
+}
+ +
+
expression
+
Выражение, значение которого сравнивается со всеми случаями.
+
case valueN
+
Случай, который проверяется на соответствие выражению (expression).
+
statementsN
+
Инструкции, которые выполняются, если expression соответствуют случаю.
+
statements_def
+
Инструкции, выполняемые если expression не соответствует ни одному случаю.
+
+ +

Описание

+ +

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

+ +

Сначала программа пытается найти подходящий случай, значение которого равно значению искомого выражения (используется строгое сравнение, ===) и затем выполняет инструкции, соответствующие случаю. Если подходящего случая нет, ищется случай по умолчанию (default), который не является обязательным. Если случая по умолчанию нет, выполнение продолжается на инструкции, следующей сразу после switch. По соглашению, случай default описывается последним, но это не является строгим правилом.

+ +

Опциональная инструкция break выполняет выход из блока switch. Она может располагаться в каждом из случаев, но не является обязательной. Если её нет, то выполняется следующая инструкция из блока switch.

+ +

Примеры

+ +

Пример: Использование switch

+ +

В этом примере, если expr равно "Bananas", программа находит случай "Bananas" и выполняет соответствующие инструкции. При выполнении инструкции break, выполнение продолжится за пределами switch. Если бы break не было, то выполнились бы инструкции случая "Cherries".

+ +
switch (expr) {
+  case "Oranges":
+    console.log("Oranges are $0.59 a pound.");
+    break;
+  case "Apples":
+    console.log("Apples are $0.32 a pound.");
+    break;
+  case "Bananas":
+    console.log("Bananas are $0.48 a pound.");
+    break;
+  case "Cherries":
+    console.log("Cherries are $3.00 a pound.");
+    break;
+  case "Mangoes":
+  case "Papayas":
+    console.log("Mangoes and papayas are $2.79 a pound.");
+    break;
+  default:
+    console.log("Sorry, we are out of " + expr + ".");
+}
+
+console.log("Is there anything else you'd like?");
+
+ +

Пример: Что случится, если не использовать break?

+ +

Если вы не использовали инструкцию break, то будут выполнены инструкции следующего случая. И проверка на соответствие выражению не будет выполняться.

+ +
var foo = 0;
+switch (foo) {
+    case -1:
+        console.log('negative 1');
+        break;
+    case 0: // foo равно 0, случай соответствует выражению и эти инструкции будут выполнены
+        console.log(0)
+        // ПРИМЕЧАНИЕ: здесь могла находиться забытая инструкция break
+    case 1: // В случае 'case 0:' не было break, инструкции данного случая также будут выполнены
+        console.log(1);
+        break; // В конце расположен break, поэтому выполнение не перейдёт к случаю 'case 2:'
+    case 2:
+        console.log(2);
+        break;
+    default:
+        console.log('default');
+}
+ +

Пример: Использование нескольких значений для одного случая

+ +

Если вы хотите использовать один набор инструкций для соответствия нескольким случаям, можно использовать два способа. Первый способ является рекомендуемым, а второй - скорее трюком. Оба способа вызовут предупреждение с текстом "yes", если значение foo равно 0, 1, 2 или 3.

+ +

Исходники этих способов здесь:

+ +
    +
  1. Switch statement multiple cases in JavaScript (Stack Overflow)
    2. +
  2. Multiple Criteria Single Case Switch Statement (Stack Overflow)
    3. +
+ +

Первый способ

+ +

В первом способе используется то, что выполнение инструкции switch продолжится, если не использовать инструкцию break. Подробнее в примере "Что случится, если не использовать break?"

+ +
var foo = 1;
+switch (foo) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+        alert('yes');
+        break;
+    default:
+        alert('not');
+}
+ +

Второй способ

+ +

Другой способ, менее стандартный; во второй строке, где вы ожидали увидеть switch(foo), расположено постоянное значение true, и в случаях используются выражения вместо констант:

+ +
var foo = 1;
+switch (true) { // Постоянное значение true вместо foo
+    case foo >= 0 && foo <= 3:
+        alert('yes');
+        break;
+    default:
+        alert('not');
+}
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
ECMAScript 3-е Издание.СтандартИзначальное определение.
+ Реализован в JavaScript 1.2
{{SpecName('ES5.1', '#sec-12.11', 'Инструкция switch')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-switch-statement', 'Инструкция switch')}}{{Spec2('ES6')}}
+ +

Совместимость с браузерами

+ + + +

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

+ +

Смотрите также

+ + diff --git a/files/ru/web/javascript/reference/statements/throw/index.html b/files/ru/web/javascript/reference/statements/throw/index.html new file mode 100644 index 0000000000..7417c2f055 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/throw/index.html @@ -0,0 +1,240 @@ +--- +title: throw +slug: Web/JavaScript/Reference/Statements/throw +tags: + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Statements/throw +--- +
{{jsSidebar("Statements")}}
+ +

Основная информация

+ +

Инструкция throw позволяет генерировать исключения, определяемые пользователем. При этом выполнение текущей функции будет остановлено (инструкции после throw не будут выполнены), и управление будет передано в первый блок catch в стеке вызовов. Если catch блоков среди вызванных функций нет, выполнение программы будет остановлено.

+ +

Синтаксис

+ +
throw выражение;
+ +
+
выражение
+
Определяемое пользователем исключение.
+
+ +

Описание

+ +

Используйте инструкцию throw для генерирования исключения. Когда вы генерируете исключение (throw), выражение задает значение исключения. Каждое из следующих throw создает исключение:

+ +
throw "Error2"; // генерирует исключение, значением которого является строка
+throw 42;       // генерирует исключение, значением которого является число 42
+throw true;     // генерирует исключение, значением которого является логическое значение true
+ +

Также стоит отметить, что на инструкцию throw влияет автоматическая вставка точки с запятой (ASI). Поэтому не допускаются разрывы строк между инструкцией throw и выражением.

+ +

Примеры

+ +

Пример: Генерирование объекта в качестве исключения

+ +

Можно указать объект в качестве исключения. Затем можно получить ссылку на этот объект и доступ ко всем его свойствам в блоке catch. Следующий пример создает объект ошибки, который имеет тип UserException, и используется для генерации исключения.

+ +
function UserException(message) {
+   this.message = message;
+   this.name = "Исключение, определенное пользователем";
+}
+function getMonthName(mo) {
+   mo = mo-1; // Нужно скорректировать номер месяца согласно индексам массива (1=Jan, 12=Dec)
+   var months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul",
+      "Aug", "Sep", "Oct", "Nov", "Dec"];
+   if (months[mo] !== undefined) {
+      return months[mo];
+   } else {
+      throw new UserException("Неверно указан номер месяца");
+   }
+}
+
+try {
+   // statements to try
+   var myMonth = 15; // 15 находится вне границ массива, что приведет к исключению
+   var monthName = getMonthName(myMonth);
+} catch (e) {
+   monthName = "неизвестен";
+   logMyErrors(e.message, e.name); // передаем исключение в обработчик ошибок
+}
+
+ +

Пример: Другой пример генерации объекта в виде исключения

+ +

Следующий пример проверяет, является ли строка, переданная в функцию, почтовым индексом США. Если индекс имеет недопустимый формат, будет сгенерировано исключение посредством создания объекта, имеющего тип ZipCodeFormatException.

+ +
/*
+ * Создает объект ZipCode.
+ *
+ * Допустимые форматы почтового индекса:
+ *    12345
+ *    12345-6789
+ *    123456789
+ *    12345 6789
+ *
+ * Если агрумент, переданный в констуктор ZipCode не совпадает
+ * ни с одним из этих форматов, будет брошено исключение.
+ */
+
+function ZipCode(zip) {
+   zip = new String(zip);
+   var 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
+   };
+}
+
+/*
+ * Это может быть скрипт, который проверяет значение адреса
+ * для США.
+ */
+
+var ZIPCODE_INVALID = -1;
+var 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;
+   }
+}
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES3')}}{{Spec2('ES3')}}Initial definition.
+ Implemented in 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')}} 
+ +

Поддерживаемые браузеры

+ +

{{ CompatibilityTable() }}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +

Смотрите также

+ + diff --git a/files/ru/web/javascript/reference/statements/try...catch/index.html b/files/ru/web/javascript/reference/statements/try...catch/index.html new file mode 100644 index 0000000000..3609136b03 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/try...catch/index.html @@ -0,0 +1,422 @@ +--- +title: try...catch +slug: Web/JavaScript/Reference/Statements/try...catch +tags: + - JavaScript + - Исключение + - Ошибка +translation_of: Web/JavaScript/Reference/Statements/try...catch +--- +
{{jsSidebar("Statements")}}
+ +

Конструкция try...catch пытается выполнить инструкции в блоке try, и, в случае ошибки, выполняет блок catch.

+ +

Синтаксис

+ +
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 не было выброшено исключение, то блок catch не выполняется.

+ +

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

+ +

Вы можете использовать вложенные конструкции try. Если внутренняя конструкция try не имеет блока catch (такое может быть при её использовании в виде try {...} finaly {...}, потому что try {...} не может быть без блоков catch или finally), будет вызван сatch внешней конструкции try.

+ +

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

+ +

Безусловный блок catch

+ +

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

+ +
try {
+   throw 'myException'; // создание исключения
+}
+catch (e) {
+   // инструкции для обработки ошибок
+   logMyErrors(e); // передать объект исключения обработчику ошибок
+}
+
+ +

Блок catch задает идентификатор (e в примере выше) который содержит объект исключения (в примере выше — значение, переданное оператору throw). Область видимости этого объекта ограничивается блоком catch.

+ +

Условный блок catch

+ +

"Условные блоки catch" можно создавать, используя try...catch с if...else if...else, как здесь:

+ +
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 {
+  myRoutine();
+} catch(e) {
+  if (e instanceof RangeError) {
+    // обработка известного исключения, с которым
+    // понятно, что делать
+  } else {
+    throw e; // пробросить неизвестные ошибки
+  }
+}
+
+ +
+

Обратите внимание: Firefox раньше поддерживал краткую запись условных блоков catch:

+ +
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);
+}
+
+ +

Однако, такой синтаксис никогда не был частью спецификации ECMAScript и был удалён из Firefox после версии 59. Сейчас он не поддерживается ни в одном браузере.

+
+ +

Идентификатор исключения

+ +

Когда в блоке try выбрасывается исключение, exception_var (т. е. e в конструкции catch (e)) содержит значение исключения. Его можно использовать, чтобы получить больше информации об выброшенном исключении. Идентификатор доступен только в области видимости блока catch.

+ +
try {
+  if (!firstValidation()) {
+    throw 1;
+  }
+  if (!secondValidation()) {
+    throw 2;
+  }
+} catch (e) {
+  // Выводит 1 или 2 (если не произошло никакх других ошибок)
+  console.log(e);
+}
+ +

Блок finally

+ +

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

+ +

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

+ +
function expensiveCalculations() {
+  // Сложные вычисления
+}
+
+function maybeThrowError() {
+  // Функция, которая может выбросить исключение
+  if(Math.random() > 0.5) throw new Error()
+}
+
+try {
+  // Теперь при прокрутке страницы будут происходить
+  // сложные вычисления, что сильно скажется на
+  // производительности
+  window.addEventListener('scroll', expensiveCalculations)
+  maybeThrowError()
+} catch {
+  // Если функция maybeThrowError выбросит исключения,
+  // управление сразу перейдёт в блок catch и
+  // сложные вычисления продолжат выполняться до
+  // перезагрузки страницы
+  maybeThrowError()
+}
+window.removeEventListener('scroll', expensiveCalculations)
+ +

В этом примере, если функция maybeThrowError выбросит исключение внутри блока try, управление перейдёт в блок catch. Если и в блоке catch эта функция тоже выбросит исключение, то выполнение кода прервётся, и обработчик события не будет снят, пока пользователь не перезагрузит страницу, что плохо скажется на скорости работы. Для того, чтобы избежать таких ситуаций, следует использовать блок finally:

+ +
try {
+  window.addEventListener('scroll', expensiveCalculations)
+  maybeThrowError()
+} catch {
+  maybeThrowError()
+} finally {
+  window.removeEventListener('scroll', expensiveCalculations)
+}
+
+
+ +

Другой пример: работа с файлами. В следующем фрагменте кода показывается, как скрипт открывает файл и записывает в него какие-то данные (в серверном окружении JavaScript имеет доступ к файловой системе). Во время записи может произойти ошибка. Но после открытия файл очень важно закрыть, потому что незакрытый файл может привести к утечкам памяти. В таких случях используется блок finally:

+ +
openMyFile();
+try {
+   // Сделать что-то с файлом
+   writeMyFile(theData);
+}
+finally {
+   closeMyFile(); // Закрыть файл, что бы ни произошло
+}
+
+ +

Примеры

+ +

Вложенные блоки try

+ +

Для начала давайте посмотрим что делает этот код:

+ +
try {
+  try {
+    throw new Error('упс');
+  }
+  finally {
+    console.log('finally');
+  }
+}
+catch (e) {
+  console.error('внешний блок catch', e.message);
+}
+
+// Вывод:
+// "finally"
+// "внешний блок catch" "упс"
+
+ +

Теперь отловим исключение во внутреннем блоке try, добавив к нему блок catch:

+ +
try {
+  try {
+    throw new Error('упс');
+  }
+  catch (e) {
+    console.error('внутренний блок catch', e.message);
+  }
+  finally {
+    console.log('finally');
+  }
+}
+catch (e) {
+  console.error('внешний блок catch', e.message);
+}
+
+// Output:
+// "внутренний блок catch" "упс"
+// "finally"
+
+ +

Наконец, пробросим ошибку

+ +
try {
+  try {
+    throw new Error('упс');
+  }
+  catch (e) {
+    console.error('внутренний блок catch', e.message);
+    throw e;
+  }
+  finally {
+    console.log('finally');
+  }
+}
+catch (e) {
+  console.error('внешний блок catch', e.message);
+}
+
+// Вывод:
+// "внутренний блок catch" "oops"
+// "finally"
+// "внешний блок catch" "oops"
+
+ +

Любое исключение будет передано только в ближайший блок catch, если он не пробросит его дальше. Все исключения, выброшенными внутренними блоками (потому что код в блоке catch также может выбросить исключение), будут пойманы внешними.

+ +

Возвращение значения из блока finally

+ +

Если блок finally возвращает какое-либо значение, оно становится значением, которое возвращает вся конструкция try...catch...finally, вне зависимости от любых инструкций return в блоках try и catch. Также игнорируются исключения, выброшенные блоком catch.

+ +
try {
+  try {
+    throw new Error('упс');
+  }
+  catch (e) {
+    console.error('внутренний блок catch', e.message);
+    throw e;
+  }
+  finally {
+    console.log('finally');
+    return;
+  }
+}
+catch (e) {
+  console.error('внешний блок catch', e.message);
+}
+
+// Output:
+// "внутренний блок catch" "упс"
+// "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')}}Not part of the current ECMA-262 standard: Multiple catch clauses and conditional clauses (SpiderMonkey extension, JavaScript 1.5).
+ +

Совместимость

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatGeckoDesktop("6")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Conditional clauses
+ (non-standard)		{{CompatNo}}{{CompatVersionUnknown}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Conditional clauses
+ (non-standard)		{{CompatNo}}{{CompatNo}}{{CompatVersionUnknown}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

См. также

+ + diff --git a/files/ru/web/javascript/reference/statements/var/index.html b/files/ru/web/javascript/reference/statements/var/index.html new file mode 100644 index 0000000000..fa1df166fc --- /dev/null +++ b/files/ru/web/javascript/reference/statements/var/index.html @@ -0,0 +1,221 @@ +--- +title: var +slug: Web/JavaScript/Reference/Statements/var +translation_of: Web/JavaScript/Reference/Statements/var +--- +
{{jsSidebar("Statements")}}
+ +

Оператор var объявляет переменную, инициализируя ее, при необходимости.

+ +

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

+ +

Синтаксис

+ +
var varname1 [= value1 [, varname2 [, varname3 ... [, varnameN]]]];
+ +
+
varnameN
+
Имя переменной. Может использоваться любой допустимый идентификатор.
+
+ +
+
valueN
+
Значение переменной. Любое допустимое выражение. По-умолчанию значение undefined.
+
+ +

Описание

+ +

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

+ +

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

+ +

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('still going...'); // Не выполнится.
+ +
var a;
+console.log(a);                // Выведет "undefined" или "", в зависимости от браузера.
+console.log('still going...'); // Выведет "still going...".
+ +

3. Объявленные переменные, независимо от контекста выполнения, являются ненастраиваемыми свойствами. Необъявленные переменные это настраиваемые свойства (т.е. их можно удалять).

+ +
var a = 1;
+b = 2;
+
+delete this.a; // Возбудит TypeError в "строгом режиме". В "нестрогом режиме" будет ошибка без уведомления.
+delete this.b;
+
+console.log(a, b); // Возбудит ReferenceError.
+// Свойство 'b' было удалено и больше не существует.
+ +

Из-за перечисленных различий, использование необъявленных переменных может привести к непредсказуемым последствиям. Рекомендовано всегда объявлять переменные, вне зависимости, находятся они внутри функции или в глобальном контексте. Присваивание значения необъявленной переменной в строгом режиме ECMAScript 5 возбуждает ошибку.

+ +

Поднятие переменных

+ +

Объявление переменных (как и любые другие объявления) обрабатываются до выполнения кода. Где бы не находилось объявление, это равнозначно тому, что переменную объявили в самом начале кода. Это значит, что переменная становится доступной до того, как она объявлена. Такое поведение называется "поднятием" (в некоторых источниках "всплытием").

+ +
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 = "A";
+var b = a;
+
+// Равнозначно:
+
+var a, b = a = "A";
+
+ +

Следите за порядком присвоения значений переменным

+ +
var x = y, y = 'A';
+console.log(x + y); // undefinedA
+
+ +

В примере, x и y объявлены до выполнение кода, присвоение выполняется позже. Когда происходит присваивание "x = y", y уже существует со значением 'undefined', так что ошибка ReferenceError не генерируется. И переменной x присваивается неопределённое значение. Потом переменной y присваивается значение 'A'. Получается, что после выполнения первой строки кода 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; // Throws a ReferenceError in strict mode.
+}
+f();
+
+console.log(x, y);
+ +

Неявные глобальные переменные и внешняя область видимости

+ +

Переменные могут ссылаться на переменные внешней области видимости функции, и это может выглядеть неявно:

+ +
var x = 0;  // x объявлена глобально, затем присваивается значение 0
+
+console.log(typeof z); // undefined, пока еще z не существет
+
+function a() { // когда функция a вызванна,
+  var y = 2;   // y объявляется локально в функции a, затем присваивается 2
+
+  console.log(x, y);   // 0 2
+
+  function b() {       // когда функция b вызванна
+    x = 3;  // присваивается 3 существующей глобальной x
+    y = 4;  // присваивается 4 существующей внешней y
+    z = 5;  // создается новая глобальная переменная z и присваивается значение 5.
+  }         // (Порождает ReferenceError в strict mode(строгом режиме).)
+
+  b();     // вызов b создает z как глобальную переменную
+  console.log(x, y, z);  // 3 4 5
+}
+
+a();                   // вызов 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/ru/web/javascript/reference/statements/while/index.html b/files/ru/web/javascript/reference/statements/while/index.html new file mode 100644 index 0000000000..1baf54a1f4 --- /dev/null +++ b/files/ru/web/javascript/reference/statements/while/index.html @@ -0,0 +1,143 @@ +--- +title: while +slug: Web/JavaScript/Reference/Statements/while +tags: + - JavaScript + - Оператор + - Цикл +translation_of: Web/JavaScript/Reference/Statements/while +--- +
{{jsSidebar("Statements")}}
+ +

Оператор while создает цикл, выполняющий заданную инструкцию, пока истинно проверяемое условие. Логическое значение условия вычисляется перед исполнением тела цикла.

+ +

Синтаксис

+ +
while (условие) {
+  инструкция
+}
+ +
+
условие
+
Выражение, логическое значение которого проверяется каждый раз перед заходом в цикл. Если значение истинно, то исполняется инструкция. Когда значение становится ложным, выполняется код, следующий за циклом while.
+
инструкция
+
Инструкция, которая исполняется каждый раз, пока истинно условие. Чтобы выполнить несколько инструкций в цикле, используйте блочный оператор ({ ... }) для их группировки.
+
+ +

Примеры

+ +

Следующий цикл while исполняется, пока n не превышает трёх.

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

На каждой итерации цикла n увеличивается на единицу и прибавляется к x. Таким образом, x и n принимают следующие значения:

+ + + +

После окончания третьей итерации условие n < 3 больше не является истинным, поэтому цикл завершается.

+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{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')}}Изначальное определение
+ +

Совместимость с браузерами

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari
Базовая поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Смотрите также

+ + diff --git a/files/ru/web/javascript/reference/statements/with/index.html b/files/ru/web/javascript/reference/statements/with/index.html new file mode 100644 index 0000000000..7eb5d5d66a --- /dev/null +++ b/files/ru/web/javascript/reference/statements/with/index.html @@ -0,0 +1,177 @@ +--- +title: with +slug: Web/JavaScript/Reference/Statements/with +translation_of: Web/JavaScript/Reference/Statements/with +--- +
Использование оператора with не рекомендуемо, т.к. он может быть источником запутанных багов и проблем совместимости. Детальная информация в параграфе "Ambiguity Contra" раздела "Description".
+ +
{{jsSidebar("Statements")}}
+ +

Инструкция with расширяет цепочку областей видимости для инструкции.

+ +

Синтаксис

+ +
with (expression)
+  statement
+
+ +
+
expression
+
Добавляет данный exrpession в цепочку областей видимости используемое когда исследуется statement. Рекомендуется использовать круглые скобки вокруг выражения.
+
statement
+
Любое выражение. Чтобы использовать несколько выражений, используйте оператор block statement ({ ... }), чтобы сгруппировать их.
+
+ +

Описание

+ +

JavaScript ищет unqualified имя, исследуя  цепочку областей видимости, связанную с выполнением скрипта или функции, сожержащих это unqualified имя. Оператор 'with' добавляет данный объект в начало цепочки областей видимости в ходе исследования тела его оператора. Если unqualified имя используемое в теле соответствует свойству в цепочке областей видимости, тогда имя привязывается к свойству и объекту, содержащему это свойство. В противном случае возвращаетя {{jsxref("ReferenceError")}}.

+ +
Использование оператора with не рекомендуется, и недопустимо в строгом режиме (strict mode)  ECMAScript 5 . Рекомендуемой альтернативой может стать связывание объекта, чьи свойства Вы хотели получить, с коротким именем переменной.
+ +

Performance pro & contra

+ +

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

+ +

Contra: Оператор with заставляет указанный объект быть найденным сначала среди всех имен поиска.  Поэтому все идентификаторы, которые не относятся к указанному объекту, будут обнаруживаться медленнее в блоке «with.  Там, где важна производительность, «with» следует использовать только для охвата блоков кода, которые обращаются к членам указанного объекта.

+ +

Ambiguity contra

+ +

Contra: The with statement makes it hard for a human reader or JavaScript compiler to decide whether an unqualified name will be found along the scope chain, and if so, in which object. So given this example:

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

Only when f is called is x either found or not, and if found, either in o or (if no such property exists) in f's activation object, where x names the first formal argument. If you forget to define x in the object you pass as the second argument, or if there's some similar bug or confusion, you won't get an error -- just unexpected results.

+ +

Contra: Code using with may not be forward compatible, especially when used with something other than a plain object. Consider this example:

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

If you call f([1,2,3], obj) in an ECMAScript 5 environment, then the values reference inside the with statement will resolve to obj. However, ECMAScript 6 introduces a values property on Array.prototype (so that it will be available on every array). So, in a JavaScript environment that supports ECMAScript 6, the values reference inside the with statement will resolve to [1,2,3].values.

+
+ +

Примеры

+ +

Использование 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')}}{{Spec2('ESDraft')}} 
{{SpecName('ES6', '#sec-with-statement', 'with statement')}}{{Spec2('ES6')}} 
{{SpecName('ES5.1', '#sec-12.10', 'with statement')}}{{Spec2('ES5.1')}}Now forbidden in strict mode.
{{SpecName('ES3', '#sec-12.10', 'with statement')}}{{Spec2('ES3')}} 
{{SpecName('ES1', '#sec-12.10', 'with statement')}}{{Spec2('ES1')}}Начальное определение
+ +

Совместимость браузеров

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureChromeEdgeFirefox (Gecko)Internet ExplorerOperaSafari
Основная поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidEdgeFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Основная поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Смотрите также

+ + diff --git "a/files/ru/web/javascript/reference/statements/\320\261\320\273\320\276\320\272/index.html" "b/files/ru/web/javascript/reference/statements/\320\261\320\273\320\276\320\272/index.html" new file mode 100644 index 0000000000..4122fea24d --- /dev/null +++ "b/files/ru/web/javascript/reference/statements/\320\261\320\273\320\276\320\272/index.html" @@ -0,0 +1,177 @@ +--- +title: Блок +slug: Web/JavaScript/Reference/Statements/Блок +tags: + - JavaScript + - Инструкция + - Оператор + - справочник +translation_of: Web/JavaScript/Reference/Statements/block +--- +
{{jsSidebar("Statements")}}
+ +

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

+ +

Синтаксис

+ +
[имя:] {
+  инструкция_1;
+  инструкция_2;
+  ...
+  инструкция_n;
+}
+
+ +
+
инструкция_1, инструкция_2, инструкция_n
+
Инструкции, сгруппированные внутри блока инструкций.
+
имя
+
Необязательное {{jsxref("Statements/label", "имя")}} для визуальной идентификации или использования как точки выхода для оператора {{jsxref("Statements/break", "break")}}.
+
+ +

Описание

+ +

Эта инструкция широко используется с операторами управления потоком (н., {{jsxref("Statements/if...else", "if...else")}}, {{jsxref("Statements/for", "for")}}, {{jsxref("Statements/while", "while")}}). Например:

+ +
while (x < 10) {
+  x++;
+}
+
+ +

Обратите внимание, что блок инструкций не заканчивается точкой с запятой.

+ +

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

+ +

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

+ +

С использованием var

+ +

Переменные, объявленные через var, не имеют блочной области видимости. Переменные, введенные внутри блока, имеют областью видимости содержащую их функцию или скрипт, и последствия записи в них значения распространяются за границы, собственно, блока, в котором они объявлены. Другими словами, блок инструкций не вводит новую область видимости. Хотя "отдельностоящие" блоки не являются нарушением синтаксиса, не стоит использовать отдельностоящие блоки в JavaScript, потому что они не делают то, чего вы от них ожидаете, если вы ожидаете, что они будут себя вести аналогично блокам в C или Java. Например:

+ +
var x = 1;
+{
+  var x = 2;
+}
+console.log(x); // выводит 2
+
+ +

Тут выводится 2, потому что оператор var x внутри блока - в той же области видимости, что и оператор var x перед блоком. В C или Java подобный код вывел бы 1.

+ +

С 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 (идентификатор 'c' уже был объявлен) потому что она может быть объявлена единожды внутри блока.

+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{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.
+ +

Совместимость с браузерами

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari
Базовая поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

См. так же

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