recursal/MDN huggingface dataset:
import.meta
===========

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

Синтаксис
---------
```

import.meta
```

Описание
--------

Объект `import.meta` состоит из ключевого слова `import`, точки и свойства с именем `meta`. Обычно выражение `import.` служит для доступа к свойству, но здесь `import.`, в действительности, не является объектом.

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

Примеры
-------

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


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


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


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


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

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

| Specification |
| --- |
| ECMAScript Language Specification # prod-ImportMeta |
| HTML Standard # hostgetimportmetaproperties |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `import`
* `export`
new.target
==========

Свойство **`new.target`** позволяет определить была ли функция или конструктор вызваны с помощью оператора new. В конструкторах и функциях инстанциированных с помощью оператора new, `new.target` возвращает ссылку на конструктор или функцию. При обычном вызове функции `new.target` имеет значение `undefined`.Синтаксис
---------
```

new.target
```

Описание
--------

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

Свойство `new.target` это мета свойство которое доступно во всех функциях. В стрелочных функция, `new.target` ссылается на `new.target` внешней функции.

Примеры
-------

### new.target в вызове функции

При обычном вызове функции (в противоположность вызову в качестве конструктора), `new.target` имеет значение `undefined`. Это позволяет определить была ли вызвана функция как конструктор через new или нет.


```js
function Foo() {
  if (!new.target) throw "Foo() must be called with new";
  console.log("Foo instantiated with new");
}

new Foo(); // выведет "Foo instantiated with new"
Foo(); // ошибка "Foo() must be called with new"
```

### new.target в конструкторе

В конструкторе класса, `new.target` ссылается на конструктор, который был непосредственно вызван `new`. Это верно и для случая, когда `new.target` находится в конструкторе родительского класса, а тот в свою очередь вызывается из конструктора дочернего класса.


```js
class A {
  constructor() {
    console.log(new.target.name);
  }
}

class B extends A {
  constructor() {
    super();
  }
}

var a = new A(); // вернёт "A"
var b = new B(); // вернёт "B"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-built-in-function-objects |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* Functions
* Classes
* `new`
* `this`
Присваивание (=)
================

Простой оператор присваивания (`=`) используется для присваивания значения переменной. Операция присваивания вычисляется в присваиваемую величину. Присваивание по цепочке (*chaining*) используется для назначения нескольким переменным одинакового значения.

Интерактивный пример
--------------------

Синтаксис
---------
```

Оператор: x = y
```

Примеры
-------

### Простое и цепное присваивание


```js
// Предположим следующие переменные и их значения
// x = 5
// y = 10
// z = 25

x = y; // x будет присвоено значение 10
x = y = z; // x, y и z будут равны 25
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-assignment-operators |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* Assignment operators in the JS guide
null
====

Значение `null` представляет отсутствие какого-либо объектного значения. В JavaScript, `null` является примитивом, и в контексте логических операций, рассматривается как ложное (falsy).

Интерактивный пример
--------------------

Синтаксис
---------
```

null
```

Описание
--------

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


```js
// переменная foo не существует - она не была определена и никогда не инициализировалась:
> foo
'ReferenceError: foo is not defined'

// переменная foo существует, но она не имеет ни типа, ни значения:
> var foo = null; foo
'null'
```

### Отличия между `null` и `undefined`

`null` является определённым значением отсутствия объекта, тогда как `undefined` обозначает неопределённость. Например:


```js
var element;
// значение переменной element до её инициализации не определённо: undefined

element = document.getElementById("not-exists");
// здесь при попытке получения несуществующего элемента, метод getElementById возвращает null
// переменная element теперь инициализирована значением null, её значение определено
```


При проверке на `null` или `undefined`, помните о различии между операторами равенства (==) и идентичности (===): с первым, выполняется преобразование типов.


```js
typeof null; // object (не "null" из соображений обратной совместимости)
typeof undefined; // undefined
null === undefined; // false
null == undefined; // true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-null-value |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `undefined`
* `NaN`
Логическое НЕ (!)
=================

Логический оператор НЕ (`!`) (логическое отрицание) меняет логическое значение операнда с истины в ложь и наоборот. Обычно он используется с `булевыми` (логическими) значениями. При использовании с любыми другими значениями, если операнд может быть преобразован в `true`, то вернёт `false`; в противном случае он возвращается `true`.

Интерактивный пример
--------------------

Синтаксис
---------


```js
!expr;
```

Описание
--------

Возвращает `false`, если операнд может быть преобразован в `true`; в противном случае возвращается `true`.

Если значение может быть преобразовано в `true`, то оно рассматривается как истинноподобное (truthy). Если же значение может быть преобразовано в `false`, то оно называется ложноподобным (falsy).

Примеры выражений, которые могут быть преобразованы в `false`:

* `null`;
* `NaN`;
* `0`;
* пустая строка (`""`, `''`, ````);
* `undefined`.

Несмотря на то, что оператор `!` может использоваться с операндами, значения которых не относится к типу Boolean, это всё равно булевый оператор, поскольку его возвращаемое значение всегда можно преобразовать в булевый примитив. Чтобы явно преобразовать возвращаемое значение этого оператора (или вообще любое выражение) в соответствующее значение булевого типа, используйте двойной оператор НЕ (en-US) или конструктор `Boolean` (en-US).

Примеры
-------

### Использование логического НЕ

В следующем коде показаны примеры использования оператора `!` (логическое НЕ).


```js
n1 = !true; // !t вернёт false
n2 = !false; // !f вернёт true
n3 = !""; // !f вернёт true
n4 = !"Cat"; // !t вернёт false
```

### Двойное НЕ (`!!`)

 Можно один за другим использовать пару операторов НЕ, чтобы явным образом принудительно преобразовать любое значение в соответствующий булевый примитив.
 Преобразование основано на "истинноподобности" или "ложноподобности" значения (см. truthy и falsy)).

Точно такое же преобразование может быть выполнено с помощью функции `Boolean` (en-US).


```js
n1 = !!true; // !!truthy вернёт true
n2 = !!{}; // !!truthy вернёт true: любой объект - истинноподобный...
n3 = !!new Boolean(false); // ...даже Boolean-объект со значением false из вызова .valueOf()!
n4 = !!false; // !!falsy вернёт false
n5 = !!""; // !!falsy вернёт false
n6 = !!Boolean(false); // !!falsy вернёт false
```

### Конвертация операторов НЕ

Следующая операция с **булевыми значениями**:


```js
!!bCondition;
```


всегда эквивалентна:


```js
bCondition;
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-logical-not-operator |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `Boolean`
* Truthy
* Falsy
class expression
================

**Class expression** это способ определения класса в ECMAScript 2015 (ES6). Схожий с function expressions, class expressions может быть именованным либо не иметь имени. Если он именованный, то его имя доступно только внутри класса. JavaScript классы используют прототипно-ориентирование наследование.

Синтаксис
---------
```

var MyClass = class [className] [extends] {
  // тело класса
};
```

Описание
--------

Class expression имеет схожий синтаксис с class declaration (statement). Однако в class expression можно опустить имя класса ("binding identifier"), что не допустимо с class declaration. Также class expression позволяет повторно объявить уже существующий класс и это **не приведёт к ошибке типа**, как при использовании class declaration. Свойство конструктора является опциональным. Результатом вызова оператора `typeof` на классах, сгенерированных при помощи class expression, всегда будет "function".

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


```js
"use strict";
var Foo = class {}; // свойство конструктора опционально
var Foo = class {}; // повторное объявление разрешено

typeof Foo; // возвращает "function"
typeof class {}; // возвращает "function"

Foo instanceof Object; // true
Foo instanceof Function; // true
class Foo {} // Throws TypeError, doesn't allow re-declaration
```

Примеры
-------

### Простой class expression

Простой анонимный class expression, на который можно сослаться с помощью переменной "Foo".


```js
var Foo = class {
  constructor() {}
  bar() {
    return "Hello World!";
  }
};

var instance = new Foo();
instance.bar(); // "Hello World!"
Foo.name; // "Foo"
```

### Именованный class expression

Если вы хотите сослаться на конкретный класс внутри тела класса, вы можете создать именованный class expression. Это имя будет доступно только внутри области видимости самого class expression.


```js
var Foo = class NamedFoo {
  constructor() {}
  whoIsThere() {
    return NamedFoo.name;
  }
};
var bar = new Foo();
bar.whoIsThere(); // "NamedFoo"
NamedFoo.name; // ReferenceError: NamedFoo is not defined
Foo.name; // "NamedFoo"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-class-definitions |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `function` expression
* `class` statement
* Classes
Оператор Запятая
================

**Оператор запятая** выполняет каждый из его операндов (слева направо) и возвращает значение последнего операнда.

Интерактивный пример
--------------------

Синтаксис
---------
```

expr1, expr2, expr3...
```

Параметры
---------

`expr1`, `expr2, expr3...`

Любые выражения.

Описание
--------

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

Примеры
-------

Если `a` это двумерный массив элементов размерностью 10 х 10, то приведённый ниже код использует оператор запятая для одновременного изменения двух переменных за раз.

Следующий код выводит в консоль значения диагональных элементов массива:


```js
for (let i = 0, j = 9; i <= 9; i++, j--)
  console.log("a[" + i + "][" + j + "] = " + a[i][j]);
```


Заметьте, что запятая при объявлении переменной `var`, `let` или `const` **не** является оператором запятая, так как в данном случае она находится не в выражении. Скорее, это спец символ в объявлении переменных, комбинирующий их множество в одно выражение. Практически, эта запятая ведёт себя почти так же, как и запятая.


```js
// подобное объявление запрещено в строгом режиме(strict mode)

(a = b = 3), (c = 4); // возвращает 4 в консоль
console.log(a); // 3
x = ((y = 5), (z = 6)); // возвращает 6 в консоль
console.log(x); // 6
```


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

### Вычисления и возврат значения

Другой пример использования оператора запятой – вычисления перед возвратом значения. Как было указано ранее, будет возвращён только последний элемент, но все предыдущие также будут вычислены. Таким образом можно сделать:


```js
function myFunc() {
  let x = 0;

  return (x += 1), x; // то же самое, что return ++x;
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-comma-operator |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* for loop
await
=====

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since April 2017.

* Learn more
* See full compatibility
* Report feedback
Оператор `await` используется для ожидания окончания `Promise`. Может быть использован только внутри `async function` или на верхнем уровне модуля.

Синтаксис
---------
```

[rv] = await expression;
```


`expression`

`Promise` или любое другое значение для ожидания разрешения.

`rv`

Возвращает полученное из `Promise` значение, либо само значение, если оно не является `Promise.`

Описание
--------

Оператор `await` заставляет функцию, объявленную с использованием оператора `async`, ждать выполнения `Promise` и продолжать выполнение после возвращения `Promise` значения. Впоследствии возвращает полученное из `Promise` значение. Если типом значения, к которому был применён оператор `await`, является не `Promise`, то значение приводится к успешно выполненному `Promise`.

Если `Promise` отклоняется, то `await` генерирует исключение с отклонённым значением.

Примеры
-------

`await` ожидает разрешения `Promise` и возвращает полученное значение.


```js
function resolveAfter2Seconds(x) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(x);
    }, 2000);
  });
}

async function f1() {
  var x = await resolveAfter2Seconds(10);
  console.log(x); // 10
}
f1();
```


Если типом значения является не `Promise`, значение преобразуется к успешно выполненному `Promise`.


```js
async function f2() {
  var y = await 20;
  console.log(y); // 20
}
f2();
```


Если `Promise` отклонён, то выбрасывается исключение с переданным значением.


```js
async function f3() {
  try {
    var z = await Promise.reject(30);
  } catch (e) {
    console.log(e); // 30
  }
}
f3();
```


Обработка отклонённого `Promise` без `try/catch` блока.


```js
var response = await promisedFunction().catch((err) => {
  console.log(err);
});
// response получит значение undefined, если Promise будет отклонён
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-async-function-definitions |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

See also
--------

* `async function`
* `async function expression`
* `AsyncFunction` object
async function expression
=========================

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since April 2017.

* Learn more
* See full compatibility
* Report feedback
Ключевое слово **`async function`** используется для определения асинхронной функции внутри выражений.

Вы также можете определить асинхронные функции при помощи инструкции async function.

Синтаксис
---------
```

async function [name]([param1[, param2[, ..., paramN]]]) {
   statements
}
```


Согласно спецификации ES2015, вы также можете использовать стрелочные функции.

### Параметры

`name`

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

`paramN`

Имя аргумента, передаваемого функции.

`statements`

Инструкции, составляющие тело функции.

Описание
--------

Выражение `async function` очень похоже, и имеет почти тот же синтаксис, что и `async function statement`. Главное отличие между выражениями async `function` и объявлениями async `function` заключается в *имени функции,* которое может быть опущено в выражении `async function` для создания *анонимной* функции. Выражение `async function` можно использовать в виде IIFE (Immediately Invoked Function Expression), и оно будет запущено сразу после объявления. Смотрите также главу о функциях.

Примеры
-------

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


```js
function resolveAfter2Seconds(x) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(x);
    }, 2000);
  });
}

(async function (x) {
  // выражение асинхронной функции в виде IIFE
  var a = resolveAfter2Seconds(20);
  var b = resolveAfter2Seconds(30);
  return x + (await a) + (await b);
})(10).then((v) => {
  console.log(v); // выведет 60 после 2 секунд.
});

var add = async function (x) {
  // назначение выражения асинхронной функции переменной
  var a = await resolveAfter2Seconds(20);
  var b = await resolveAfter2Seconds(30);
  return x + a + b;
};

add(10).then((v) => {
  console.log(v); // выведет 60 после 4 секунд.
});
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-async-function-definitions |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* `async function`
* `AsyncFunction` object
* `await`
Условный (тернарный) оператор
=============================

**Условный (тернарный) оператор** - единственный оператор в JavaScript, принимающий три операнда: условие, за которым следует знак вопроса (?), затем выражение, которое выполняется, если условие истинно, сопровождается двоеточием (:), и, наконец, выражение, которое выполняется, если условие ложно. Он часто используется в качестве сокращённого варианта инструкции `if...else`.

Синтаксис
---------
```

условие ? выражение1 : выражение2
```

### Параметры

`условие`

Выражение, принимающее значение `true` или `false`.


`выражение1`, `выражение2`

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

Описание
--------

Оператор возвращает значение `выражения1`, если `условие` верно, и значение `выражения2` в противном случае. Например, чтобы вывести сообщение, текст которого зависит от значения переменной `isMember`, можно использовать такое выражение:


```js
function getFee(isMember) {
  return "The fee is " + (isMember ? "$2.00" : "$10.00");
}

console.log(getFee(true));
// Выводит в консоль: "$2.00"

console.log(getFee(false));
// Выводит в консоль: "$10.00"
```


Также можно присваивать значения переменным на основе результатов работы тернарного оператора :


```js
const elvisLives = Math.PI > 4 ? "Да" : "Нет";
console.log(elvisLives); // "Нет"
```


Возможны множественные тернарные операции (обратите внимание: условный оператор ассоциативен справа):


```js
const firstCheck = false;
const secondCheck = false;
const access = firstCheck
  ? "Доступ запрещён"
  : secondCheck
    ? "Доступ запрещён"
    : "Доступ разрешён";

console.log(access); // выводит в консоль "Доступ разрешён"
```


Тернарные операции можно использовать и сами по себе - для выполнения различных операций:


```js
const age = 16;
let stop = false;

age > 18 ? location.assign("continue.html") : (stop = true);
```


Также возможно выполнять несколько операций на каждое сравнение, разделив их запятыми:


```js
const age = 23;
let stop = false;

age > 18
  ? (alert("Хорошо, вы можете продолжить."), location.assign("continue.html"))
  : ((stop = true), alert("Простите, вы ещё так юны!"));
```


При присвоении значения также возможно выполнение более одной операции. В этом случае переменной **будет присвоено то значение,** ***которое стоит последним в списке значений, разделённых запятой***.


```js
const age = 16;

const url =
  age > 18
    ? (alert("Хорошо, вы можете продолжить."),
      // alert вернёт "undefined", но это будет проигнорировано, потому что
      // не является последним в списке значений, разделённых запятой
      "continue.html") // значение будет присвоено, если age > 18
    : (alert("Вы слишком молоды!"), alert("Простите :-("), "stop.html"); // значение будет присвоено, если age < 18

location.assign(url); // "stop.html"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-conditional-operator |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* Инструкция if...else
yield
=====

Ключевое слово `yield` используется для остановки и возобновления функций-генераторов (`function*` или legacy generator function (en-US)).

Интерактивный пример
--------------------

Синтаксис
---------
```

 [rv] = yield [[выражение]];
```


`выражение`

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

`rv`

Возвращает необязательное значение, которое передаётся в `next()` генератора, чтобы возобновить его выполнение.

Описание
--------

Ключевое слово `yield` вызывает остановку функции-генератора и возвращает текущее значение выражения, указанного после ключевого слова `yield`. Его можно рассматривать как аналог ключевого слова `return` в функции-генераторе.

На самом деле ключевое слово `yield` возвращает объект с двумя параметрами, `value` и `done`. При этом, `value` является результатом вычисления выражения после `yield`, а `done` указывает, была ли завершена функция-генератор.

Во время остановки на операторе `yield`, выполнение кода в функции-генераторе не возобновится, пока не будет вызван метод `next()` возвращаемого функцией объекта-генератора. Это предоставляет непосредственный контроль за выполнением генератора и возвратом его значений.

Примеры
-------

Следующий фрагмент кода содержит определение функции-генератора и вспомогательной функции:


```js
function\* foo() {
  var index = 0;
  while (index <= 2)
    // при достижении 2, done в yield станет true, а value undefined;
    yield index++;
}
```


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


```js
var iterator = foo();
console.log(iterator.next()); // { value:0, done:false }
console.log(iterator.next()); // { value:1, done:false }
console.log(iterator.next()); // { value:2, done:false }
console.log(iterator.next()); // { value:undefined, done:true }
```

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

| Specification |
| --- |
| ECMAScript Language Specification # prod-YieldExpression |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

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

* Итераторы
* Генераторы