recursal/MDN huggingface dataset:
TypeError: Reduce of empty array with no initial value(Тип ошибки: уменьшение пустого массива без начального значения)
======================================================================================================================

Сообщение
---------
```

TypeError: уменьшение пустого массива без начального значения
```

Тип ошибки
----------

`TypeError`Что пошло не так?
-----------------

В JavaScript существует несколько уменьшающих функций :

* `Array.prototype.reduce()`, `Array.prototype.reduceRight()` и
* `TypedArray.prototype.reduce()` (en-US), `TypedArray.prototype.reduceRight()` (en-US)).

Эти функции дополнительно принимают значение initialValue (которое будет использоваться в качестве первого аргумента для первого вызова колбэка). Однако если начальное значение не указано, будет использоваться первый элемент `Array` или `TypedArray` в качестве начального значения. Эта ошибка возникает, когда предоставляется пустой массив, так как в этом случае не может быть возвращено начальное значение.

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

### Неправильные примеры

Эта проблема часто возникает в сочетании с фильтром (`Array.prototype.filter()`, `TypedArray.prototype.filter()` (en-US)) который удалит все элементы списка. Таким образом, не оставляя ни одного для использования в качестве начального значения.


```js
var ints = [0, -1, -2, -3, -4, -5];
ints
  .filter((x) => x > 0) // удаление всех элементов
  .reduce((x, y) => x + y); // no more elements to use for the initial value.
```


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


```js
var names = document.getElementsByClassName("names");
var name_list = Array.prototype.reduce.call(
  names,
  (acc, name) => acc + ", " + name,
);
```

### Правильные примеры

Эти проблемы могут быть решены двумя различными способами.

Один из способов - фактически предоставить initialValue в качестве нейтрального элемента оператора, например 0 для сложения, 1 для умножения или пустую строку для объединения


```js
var ints = [0, -1, -2, -3, -4, -5];
ints
  .filter((x) => x < 0) // removes all elements
  .reduce((x, y) => x + y, 0); // the initial value is the neutral element of the addition
```


Другим способом было бы два для обработки пустого случая, или перед вызовом reduce, или в обратном вызове после добавления неожиданного фиктивного начального значения.


```js
var names = document.getElementsByClassName("names");

var name_list1 = "";
if (names1.length >= 1)
  name_list1 = Array.prototype.reduce.call(
    names,
    (acc, name) => acc + ", " + name,
  );
// name\_list1 == "" when names is empty.

var name_list2 = Array.prototype.reduce.call(
  names,
  (acc, name) => {
    if (acc == "")
      // initial value
      return name;
    return acc + ", " + name;
  },
  "",
);
// name\_list2 == "" when names is empty.
```

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

* `Array.prototype.reduce()`
* `Array.prototype.reduceRight()`
* `TypedArray.prototype.reduce()` (en-US)
* `TypedArray.prototype.reduceRight()` (en-US)
* `Array`
* `TypedArray`
* `Array.prototype.filter()`
* `TypedArray.prototype.filter()` (en-US)
Warning: -file- is being assigned a //# sourceMappingURL, but already has one
=============================================================================

Предупреждение "-file- is being assigned a //# sourceMappingURL, but already has one." возникает, когда для JavaScript-файла исходная карта была указана несколько раз.

Сообщение
---------
```

Warning: -file- is being assigned a //# sourceMappingURL, but already has one.
```

Тип ошибки
----------

Предупреждение. Выполнение скрипта не будет остановлено.

Что не так?
-----------

Для данного источника JavaScript исходная карта была указана несколько раз.

Источники JavaScript часто объединяются и минимизируются, чтобы сделать их доставку с сервера более эффективной. С помощью сопоставлений исходного кода отладчик может сопоставить выполняемый код с исходными файлами. Существует два способа назначения исходной карты: с помощью комментария или путём установки заголовка для файла JavaScript.

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

Настройка исходной карты с помощью комментария в файле:


```js
//# sourceMappingURL=http://example.com/path/to/your/sourcemap.map
```


Или, в качестве альтернативы, вы можете установить заголовок на ваш JavaScript-файл:


```http
X-SourceMap: /path/to/file.js.map
```

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

* Использование исходных карт in the Firefox source docs
* Введение в исходные карты в JavaScript on developer.chrome.com (2012)
static
======

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

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

* Learn more
* See full compatibility
* Report feedback
Для того, чтобы объявить статический метод класса, необходимо использовать ключевое слово **static**.

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

static methodName() { ... }
```

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

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

Вызов статических методов
-------------------------

### Вызов из другого статического метода

Чтобы вызвать статический метод в другом статическом методе того же класса, вы можете использовать ключевое слово `this`.


```js
class StaticMethodCall {
  static staticMethod() {
    return "Вызван статический метод";
  }
  static anotherStaticMethod() {
    return this.staticMethod() + " из другого статического метода";
  }
}
StaticMethodCall.staticMethod();
// 'Вызван статический метод'

StaticMethodCall.anotherStaticMethod();
// 'Вызван статический метод из другого статического метода'
```

### Вызов из конструктора класса и других методов

Статические методы недоступны напрямую, используя ключевое слово `this` из нестатических методов. Вам нужно вызвать их с помощью имени класса: `CLASSNAME.STATIC_METHOD_NAME()` или вызовом метода как свойства конструктора: `this.constructor.STATIC_METHOD_NAME()`.


```js
class StaticMethodCall {
  constructor() {
    console.log(StaticMethodCall.staticMethod());
    // 'вызван статический метод.'

    console.log(this.constructor.staticMethod());
    // 'вызван статический метод.'
  }

  static staticMethod() {
    return "вызван статический метод.";
  }
}
```

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

Следующий пример демонстрирует:

1. Как статический метод реализуется в классе.
2. Как переопределить статический метод при наследовании.
3. Как можно и как нельзя вызывать статические методы.


```js
class Triple {
  static triple(n) {
    if (n === undefined) {
      n = 1;
    }
    return n \* 3;
  }
}

class BiggerTriple extends Triple {
  static triple(n) {
    return super.triple(n) \* super.triple(n);
  }
}

console.log(Triple.triple()); // 3
console.log(Triple.triple(6)); // 18

var tp = new Triple();

console.log(BiggerTriple.triple(3));
// 81 (не затрагивается экземпляром родителя)

console.log(tp.triple());
// Выведет сообщение, что "tripple" не является
// функцией ('tp.tripple is not a function').
```

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

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

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

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

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

* `class` expression
* `class` declaration
* Classes
extends
=======

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

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

* Learn more
* See full compatibility
* Report feedback
Ключевое слово **`extends`** используется в объявлении класса или в выражениях класса для создания дочернего класса.

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

class ChildClass extends ParentClass { ... }
```

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

Ключевое слово **`extends`** может быть использовано для создания дочернего класса для уже существующего класса или встроенного объекта.

Свойство **`.prototype`** родительского класса или объекта должно быть `Object` или `null`.

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

### Использование `extends`

В первом примере создаётся дочерний класс с именем `Square` от класса с именем `Polygon`. Этот пример был взят из live demo (source).


```js
class Square extends Polygon {
  constructor(length) {
    // Здесь вызывается конструктор родительского класса,
    // в который передаётся свойство length в качестве
    // аргументов, соответствующих полям width и height,
    // класса Polygon
    super(length, length);
    // Примечание:
    // В конструкторе класса, метод super() должен быть вызван
    // перед использованием this. В противном случае, будет
    // выброшена ошибка.
    this.name = "Square";
  }

  get area() {
    return this.height \* this.width;
  }
}
```

### Расширение встроенных объектов с помощью `extends`

Этот пример расширяет встроенный объект `Date`. Пример взят из live demo (source).


```js
class myDate extends Date {
  constructor() {
    super();
  }

  getFormattedDate() {
    var months = [
      "Jan",
      "Feb",
      "Mar",
      "Apr",
      "May",
      "Jun",
      "Jul",
      "Aug",
      "Sep",
      "Oct",
      "Nov",
      "Dec",
    ];
    return (
      this.getDate() + "-" + months[this.getMonth()] + "-" + this.getFullYear()
    );
  }
}
```

### Расширение `null`

Расширение `null` работает как и с обычным классом, за исключением того, что прототип объекта не наследует `Object.prototype` (en-US).


```js
class nullExtends extends null {
  constructor() {}
}

Object.getPrototypeOf(nullExtends); // Function.prototype
Object.getPrototypeOf(nullExtends.prototype); // null

new nullExtends(); //ReferenceError: this is not defined
```

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

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

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

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

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

* Classes
* super
continue
========

Сводка
------

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

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

continue [ label ];
```


`label`

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

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

По сравнению с инструкцией `break`, `continue` прерывает выполнение цикла не полностью, вместо этого:

* В цикле `while` оно переносит поток выполнения к условию.

* В цикле `for` оно переносит поток выполнения к финальному выражению в описании цикла.

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

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

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

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


```js
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`.

Смотрите также `label`.


```js
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);
}
```


Вывод:


```js
"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";
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-continue-statement |

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

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

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

* `break`
* `label`
Пустая инструкция
=================

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

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

;
```

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

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

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

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

Пустая инструкция используется в выражениях циклов. Смотрите следующий пример с пустым телом цикла:


```js
var arr = [1, 2, 3];

// Приравняет все значения массива к 0
for (i = 0; i < arr.length; arr[i++] = 0 /\* выражения \*/);

console.log(arr);
// [0, 0, 0]
```


**Заметьте:** Это хорошая идея: комментировать намеренное использование пустых инструкций, т.к. не очевидно отличить их от нормальной точки с запятой. В следующем примере использование, вероятно, ненамеренное:


```js
if (condition) // Внимание, этот if ничего не делает!
  killTheUniverse(); // Это всегда выполняется!!!
```


Другой пример: `if...else` без фигурных скобок (`{}`). Если `three` истинно, ничего не произойдёт, `four` не важна, и функция `launchRocket()` тоже не запустится.


```js
if (one) doOne();
else if (two) doTwo();
else if (three) // nothing here
else if (four) doFour();
else launchRocket();
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-empty-statement |

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

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

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

* `Блок`
do...while
==========

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

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

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

do
   выражение
while (условие);
```


`выражение`

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


`условие`

Выражение, которое вычисляется после каждого шага цикла. Если `условие` истинно, то `выражение` выполняется ещё раз. Когда `условие` ложно, выполняется выражение, следующее после `do...while`.

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

### Использование `do...while`

В примере, цикл `do...while` выполняется до тех пор, пока `i` не перестанет быть меньше 5.

### HTML


```html
<div id="example"></div>
```

### JavaScript


```js
var result = "";
var i = 0;
do {
  i += 1;
  result += i + " ";
} while (i > 0 && i < 5); // Несмотря на то, что i == 0, цикл всё равно продолжится, так как начинается без теста
document.getElementById("example").innerHTML = result;
```

### Результат

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-do-while-statement |

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

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

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

* `while`
* `for`
export
======

Инструкция **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`

Идентификатор для экспорта (чтобы он мог быть импортирован с помощью `import` в другом файле (скрипте)).

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

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

* Именованный экспорт:

```js
export { myFunction }; // экспорт ранее объявленной функции
export const foo = Math.sqrt(2); // экспорт константы
```

* Дефолтный экспорт (экспорт по умолчанию) (один на скрипт):

```js
export default function () {} // или 'export default class {}'
// тут не ставится точка с запятой
```


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

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

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

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

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


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


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


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

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

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


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


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


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

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-exports |

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

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

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

* `import`
* ES6 in Depth: Modules, Hacks blog post by Jason Orendorff
* Axel Rauschmayer's book: "Exploring JS: Modules"
Блок
====

**Блок инструкций** (или **сложная инструкция** в других языках) используется для группировки нуля или более инструкций. Блок отделяется парой фигурных скобок и может опционально быть `поименован`:

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

[имя:] {
  инструкция_1;
  инструкция_2;
  ...
  инструкция_n;
}
```


`инструкция_1`, `инструкция_2`, `инструкция_n`

Инструкции, сгруппированные внутри блока инструкций.

имя

Необязательное `имя` для визуальной идентификации или использования как точки выхода для оператора `break`.

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

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


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


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

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

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

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

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


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


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

#### С `let` и `const`

Наоборот, идентификаторы, объявленные с помощью `let` и `const` **имеют** блочную область видимости:


```js
let x = 1;
{
  let x = 2;
}
console.log(x); // выводит 1
```


`x = 2` ограничено рамками области видимости блока, в котором оно было определено.

То же самое и для `const`:


```js
const c = 1;
{
  const c = 2;
}
console.log(c); // выводит 1 и не выбрасывает SyntaxError...
```


Обратите внимание, что объявленная внутри блока `const c = 2` *не* кидает `SyntaxError: Identifier 'c' has already been declared` (`идентификатор 'c' уже был объявлен`) потому что она может быть объявлена единожды внутри блока.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-block |

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

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

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

* `while`
* `if...else`
* `let`
debugger
========

Выражение **debugger** открывает доступ к любому доступному в конкретном окружении отладочной функциональности, например к установке точек останова (т.н. брейкпоинтов). Если функциональность отладки в среде выполнения недоступен, данное выражение не будет иметь никакого эффекта.

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

debugger;
```

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

Следующий пример показывает код, содержащий выражение **debugger**. Это позволяет вызвать функциональность отладки (если таковой может быть использован) при вызове функции.


```js
function potentiallyBuggyCode() {
  debugger;
  // чтобы протестировать работу отладчика, поместите здесь код, заведомо содержащий ошибку
}
```


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

![Paused at a debugger statement.](/ru/docs/Web/JavaScript/Reference/Statements/debugger/screen_shot_2014-02-07_at_9.14.35_am.png)

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-debugger-statement |

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

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

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

* Debugging JavaScript
* The Debugger in the Firefox Developer Tools