From 074785cea106179cb3305637055ab0a009ca74f2 Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:42:52 -0500 Subject: initial commit --- .../global_objects/array/@@iterator/index.html | 138 +++++++ .../global_objects/array/@@species/index.html | 78 ++++ .../global_objects/array/@@unscopables/index.html | 76 ++++ .../global_objects/array/concat/index.html | 135 ++++++ .../global_objects/array/copywithin/index.html | 216 ++++++++++ .../global_objects/array/entries/index.html | 116 ++++++ .../global_objects/array/every/index.html | 195 +++++++++ .../reference/global_objects/array/fill/index.html | 159 ++++++++ .../global_objects/array/filter/index.html | 302 ++++++++++++++ .../reference/global_objects/array/find/index.html | 167 ++++++++ .../global_objects/array/findindex/index.html | 138 +++++++ .../reference/global_objects/array/flat/index.html | 160 ++++++++ .../global_objects/array/flatmap/index.html | 126 ++++++ .../global_objects/array/foreach/index.html | 388 ++++++++++++++++++ .../reference/global_objects/array/from/index.html | 216 ++++++++++ .../global_objects/array/includes/index.html | 171 ++++++++ .../reference/global_objects/array/index.html | 452 +++++++++++++++++++++ .../global_objects/array/indexof/index.html | 175 ++++++++ .../global_objects/array/isarray/index.html | 120 ++++++ .../reference/global_objects/array/join/index.html | 110 +++++ .../reference/global_objects/array/keys/index.html | 90 ++++ .../global_objects/array/lastindexof/index.html | 167 ++++++++ .../global_objects/array/length/index.html | 146 +++++++ .../reference/global_objects/array/map/index.html | 284 +++++++++++++ .../global_objects/array/observe/index.html | 138 +++++++ .../reference/global_objects/array/of/index.html | 99 +++++ .../reference/global_objects/array/pop/index.html | 99 +++++ .../global_objects/array/prototype/index.html | 171 ++++++++ .../reference/global_objects/array/push/index.html | 111 +++++ .../global_objects/array/reduce/index.html | 314 ++++++++++++++ .../global_objects/array/reduceright/index.html | 290 +++++++++++++ .../global_objects/array/reverse/index.html | 96 +++++ .../global_objects/array/shift/index.html | 139 +++++++ .../global_objects/array/slice/index.html | 242 +++++++++++ .../reference/global_objects/array/some/index.html | 215 ++++++++++ .../reference/global_objects/array/sort/index.html | 234 +++++++++++ .../global_objects/array/splice/index.html | 142 +++++++ .../global_objects/array/tolocalestring/index.html | 134 ++++++ .../global_objects/array/tosource/index.html | 94 +++++ .../global_objects/array/tostring/index.html | 122 ++++++ .../global_objects/array/unshift/index.html | 89 ++++ .../global_objects/array/values/index.html | 136 +++++++ 42 files changed, 7190 insertions(+) create mode 100644 files/ru/web/javascript/reference/global_objects/array/@@iterator/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/@@species/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/@@unscopables/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/concat/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/copywithin/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/entries/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/every/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/fill/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/filter/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/find/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/findindex/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/flat/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/flatmap/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/foreach/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/from/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/includes/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/indexof/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/isarray/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/join/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/keys/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/lastindexof/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/length/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/map/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/observe/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/of/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/pop/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/prototype/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/push/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/reduce/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/reduceright/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/reverse/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/shift/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/slice/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/some/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/sort/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/splice/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/tolocalestring/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/tosource/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/tostring/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/unshift/index.html create mode 100644 files/ru/web/javascript/reference/global_objects/array/values/index.html (limited to 'files/ru/web/javascript/reference/global_objects/array') diff --git a/files/ru/web/javascript/reference/global_objects/array/@@iterator/index.html b/files/ru/web/javascript/reference/global_objects/array/@@iterator/index.html new file mode 100644 index 0000000000..9de1e97f40 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/@@iterator/index.html @@ -0,0 +1,138 @@ +--- +title: 'Array.prototype[@@iterator]()' +slug: Web/JavaScript/Reference/Global_Objects/Array/@@iterator +tags: + - Array + - ECMAScript6 + - Experimental + - Expérimental(2) + - Iterator + - JavaScript + - Method + - Prototype + - Reference + - Référence(2) +translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@iterator +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Начальное значение свойства @@iterator является тем же самым функциональным объектом, что и начальное значение, возвращаемое методом {{jsxref("Array.prototype.values()", "values()")}}.

+ +

Синтаксис

+ +
arr[Symbol.iterator]()
+ +

Примеры

+ +

Пример: итерация посредством цикла for...of

+ +
var arr = ['w', 'y', 'k', 'o', 'p'];
+// ваш браузер должен поддерживать цикл for..of
+// и переменные с областью видимости let в циклах for
+for (let letter of arr) {
+  console.log(letter);
+}
+
+ +

Пример: альтернативный способ итерации

+ +
var arr = ['w', 'y', 'k', 'o', 'p'];
+var eArr = arr[Symbol.iterator]();
+console.log(eArr.next().value); // w
+console.log(eArr.next().value); // y
+console.log(eArr.next().value); // k
+console.log(eArr.next().value); // o
+console.log(eArr.next().value); // p
+
+ +

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

+ + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES6', '#sec-array.prototype-@@iterator', 'Array.prototype[@@iterator]()')}}{{Spec2('ES6')}}Изначальное определение.
+ +

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

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari
Базовая поддержка{{CompatChrome("38")}}{{CompatGeckoDesktop("17")}} (.iterator)
+ {{CompatGeckoDesktop("27")}} (["@@iterator"])
+ {{CompatGeckoDesktop("36")}} ([Symbol.iterator])		{{CompatNo}}{{CompatOpera("25")}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome для AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("17")}} (.iterator)
+ {{CompatGeckoMobile("27")}} (["@@iterator"])
+ {{CompatGeckoMobile("36")}} ([Symbol.iterator])		{{CompatNo}}{{CompatOpera("25")}}{{CompatNo}}
+
+ +

Примечания по Gecko

+ + + +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/@@species/index.html b/files/ru/web/javascript/reference/global_objects/array/@@species/index.html new file mode 100644 index 0000000000..696d2b6312 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/@@species/index.html @@ -0,0 +1,78 @@ +--- +title: 'get Array[@@species]' +slug: Web/JavaScript/Reference/Global_Objects/Array/@@species +tags: + - Array + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@species +--- +
{{JSRef}}
+ +

Метод Array[@@species]возвращает конструктор Array .

+ +

Синтаксис

+ +
Array[Symbol.species]
+
+ +

Возвращаемое значение

+ +

Конструктор {{jsxref("Array")}}.

+ +

Описание

+ +

Метод species  возвращает стандартный конструктор обьектов Array . Дочерние элементы могут переопределить метод для смены назначения конструктора.

+ +

Примеры

+ +

Метод species возвращает стандартное значение функции конструктора, то есть
+  Array конструктор для Array обьектов:

+ +
Array[Symbol.species]; // функция Array()
+ +

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

+ +
class MyArray extends Array {
+  //  Переписывает тип MyArray в родительский конструктор Array
+  static get [Symbol.species]() { return Array; }
+}
+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ES6', '#sec-get-array-@@species', 'get Array [ @@species ]')}}{{Spec2('ES6')}}Изначальное
+ определение.
{{SpecName('ESDraft', '#sec-get-array-@@species', 'get Array [ @@species ]')}}{{Spec2('ESDraft')}} 
+ +

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

+ +
+ + +

{{Compat("javascript.builtins.Array.@@species")}}

+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/@@unscopables/index.html b/files/ru/web/javascript/reference/global_objects/array/@@unscopables/index.html new file mode 100644 index 0000000000..7e4e7c9daa --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/@@unscopables/index.html @@ -0,0 +1,76 @@ +--- +title: 'Array.prototype[@@unscopables]' +slug: Web/JavaScript/Reference/Global_Objects/Array/@@unscopables +tags: + - ECMAScript 2015 + - JavaScript + - Property + - Prototype + - Массив +translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@unscopables +--- +
{{JSRef}}
+ +

Свойства символа @@unscopable содержат свойства имён, которые не были включены в ECMAScript до версии ES2015. Эти свойства исключены из привязок оператора with.

+ +

Синтаксис

+ +
arr[Symbol.unscopables]
+ +

Описание

+ +

Стандартные свойства массива, которые исключены из привязок  with: copyWithin, entries, fill, find, findIndex, includes, keys, и values.

+ +

См. {{jsxref("Symbol.unscopables")}} о том, как установить unscopables для Ваших собственных объектов.

+ +

{{js_property_attributes(0,0,1)}}

+ +

Примеры

+ +

Приведённый код отлично работает в ES5 и ниже. Однако в ECMAScript 2015 и более поздних версиях был введён метод  {{jsxref("Array.prototype.keys()")}}. Это означает, что внутри окружения with, "ключи" будут методом, а не пременной. Вот где теперь встроенные свойства символа {{jsxref("Array.prototype[@@unscopables]")}} вступают в игру и препятствуют тому, чтобы некоторые из методов Array были включены в оператор with.

+ +
var keys = [];
+
+with (Array.prototype) {
+  keys.push('что-то');
+}
+
+Object.keys(Array.prototype[Symbol.unscopables]);
+// ["copyWithin", "entries", "fill", "find", "findIndex",
+//  "includes", "keys", "values"]
+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ES2015', '#sec-array.prototype-@@unscopables', 'Array.prototype[@@unscopables]')}}{{Spec2('ES2015')}}Изначальное определение.
{{SpecName('ESDraft', '#sec-array.prototype-@@unscopables', 'Array.prototype[@@unscopables]')}}{{Spec2('ESDraft')}} 
+ +

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

+ +
+ + +

{{Compat("javascript.builtins.Array.@@unscopables")}}

+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/concat/index.html b/files/ru/web/javascript/reference/global_objects/array/concat/index.html new file mode 100644 index 0000000000..b3c2fa6eea --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/concat/index.html @@ -0,0 +1,135 @@ +--- +title: Array.prototype.concat() +slug: Web/JavaScript/Reference/Global_Objects/Array/concat +tags: + - Array + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/concat +--- +
{{JSRef}}
+ +

Метод concat() возвращает новый массив, состоящий из массива, на котором он был вызван, соединённого с другими массивами и/или значениями, переданными в качестве аргументов.

+ +
{{EmbedInteractiveExample("pages/js/array-concat.html")}}
+ + + +

Синтаксис

+ +
var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
+ +

Параметры

+ +
+
valueN
+
Массивы и/или значения, соединяемые в новый массив. Смотрите описание ниже.
+
+ +

Возвращаемое значение

+ +

Новый экземпляр {{jsxref("Array")}}.

+ +

Описание

+ +

Метод concat создаёт новый массив, состоящий из элементов в объекте, на котором он был вызван, за которыми по порядку следуют, для каждого аргумента, все его элементы (если аргумент является массивом), либо сам аргумент (если он массивом не является).

+ +

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

+ + + +
+

Примечание: Соединение массивов и/или значений в новый массив оставит соединяемые массивы/значения неизменными. Кроме того, любая операция над новым массивом (если только элемент не является ссылкой) не будет затрагивать исходные массивы и наоборот.

+
+ +

Примеры

+ +

Соединение двух массивов

+ +

Следующий код соединяет два массива:

+ +
var alpha = ['a', 'b', 'c'],
+    numeric = [1, 2, 3];
+
+var alphaNumeric = alpha.concat(numeric);
+
+console.log(alphaNumeric); // Результат: ['a', 'b', 'c', 1, 2, 3]
+
+ +

Соединение трёх массивов

+ +

Следующий код соединяет три массива:

+ +
var num1 = [1, 2, 3],
+    num2 = [4, 5, 6],
+    num3 = [7, 8, 9];
+
+var nums = num1.concat(num2, num3);
+
+console.log(nums); // Результат: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+ +

Соединение значений в массив

+ +

Следующий код соединяет три значения в массив:

+ +
var alpha = ['a', 'b', 'c'];
+
+var alphaNumeric = alpha.concat(1, [2, 3]);
+
+console.log(alphaNumeric); // Результат: ['a', 'b', 'c', 1, 2, 3]
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES3')}}{{Spec2('ES3')}}Изначальное определение. Реализована в JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.4.4.4', 'Array.prototype.concat')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-array.prototype.concat', 'Array.prototype.concat')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-array.prototype.concat', 'Array.prototype.concat')}}{{Spec2('ESDraft')}}
+ +

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

+ +
+ + +

{{Compat("javascript.builtins.Array.concat")}}

+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/copywithin/index.html b/files/ru/web/javascript/reference/global_objects/array/copywithin/index.html new file mode 100644 index 0000000000..a914888989 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/copywithin/index.html @@ -0,0 +1,216 @@ +--- +title: Array.prototype.copyWithin() +slug: Web/JavaScript/Reference/Global_Objects/Array/copyWithin +tags: + - Array + - ECMAScript6 + - Experimental + - JavaScript + - Method + - Prototype + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/copyWithin +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод copyWithin() копирует последовательность элементов массива внутри него в позицию, начинающуюся по индексу target. Копия берётся по индексам, задаваемым вторым и третьим аргументами start и end. Аргумент end является необязательным и по умолчанию равен длине массива.

+ +

Синтаксис

+ +
arr.copyWithin(target, start[, end = this.length])
+ +

Параметры

+ +
+
target
+
Начальный индекс позиции цели, куда копировать элементы.
+
start
+
Начальный индекс позиции источника, откуда начинать копировать элементы.
+
end
+
Необязательный параметр. Конечный индекс позиции источника, где заканчивать копировать элементы.
+
+ +

Описание

+ +

Аргументы target, start и end приводятся к {{jsxref("Global_Objects/Number", "Number")}} и обрезаются до целых значений.

+ +

Если аргумент start является отрицательным, он трактуется как length+start где length — это длина массива. Если аргумент end является отрицательным, он трактуется как length+end.

+ +

Функция copyWithin намеренно является обобщённой, она не требует, чтобы значение this внутри неё было объектом {{jsxref("Global_Objects/Array", "Array")}}, и кроме того, функция copyWithin является изменяющим методом, она изменит объект this и вернёт его, а не просто вернёт копию.

+ +

Примеры

+ +
[1, 2, 3, 4, 5].copyWithin(0, 3);
+// [4, 5, 3, 4, 5]
+
+[1, 2, 3, 4, 5].copyWithin(0, 3, 4);
+// [4, 2, 3, 4, 5]
+
+[1, 2, 3, 4, 5].copyWithin(0, -2, -1);
+// [4, 2, 3, 4, 5]
+
+[].copyWithin.call({length: 5, 3: 1}, 0, 3);
+// {0: 1, 3: 1, length: 5}
+
+// Типизированные массивы ES6 являются подклассами Array
+var i32a = new Int32Array([1, 2, 3, 4, 5]);
+
+i32a.copyWithin(0, 2);
+// Int32Array [3, 4, 5, 4, 5]
+
+// На платформах, которые ещё не совместимы с ES6:
+[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4);
+// Int32Array [4, 2, 3, 4, 5]
+
+ +

Полифилл

+ +
if (!Array.prototype.copyWithin) {
+  Array.prototype.copyWithin = function(target, start/*, end*/) {
+    // Шаги 1-2.
+    if (this == null) {
+      throw new TypeError('this is null or not defined');
+    }
+
+    var O = Object(this);
+
+    // Шаги 3-5.
+    var len = O.length >>> 0;
+
+    // Шаги 6-8.
+    var relativeTarget = target >> 0;
+
+    var to = relativeTarget < 0 ?
+      Math.max(len + relativeTarget, 0) :
+      Math.min(relativeTarget, len);
+
+    // Шаги 9-11.
+    var relativeStart = start >> 0;
+
+    var from = relativeStart < 0 ?
+      Math.max(len + relativeStart, 0) :
+      Math.min(relativeStart, len);
+
+    // Шаги 12-14.
+    var end = arguments[2];
+    var relativeEnd = end === undefined ? len : end >> 0;
+
+    var final = relativeEnd < 0 ?
+      Math.max(len + relativeEnd, 0) :
+      Math.min(relativeEnd, len);
+
+    // Шаг 15.
+    var count = Math.min(final - from, len - to);
+
+    // Шаги 16-17.
+    var direction = 1;
+
+    if (from < to && to < (from + count)) {
+      direction = -1;
+      from += count - 1;
+      to += count - 1;
+    }
+
+    // Шаг 18
+    while (count > 0) {
+      if (from in O) {
+        O[to] = O[from];
+      } else {
+        delete O[to];
+      }
+
+      from += direction;
+      to += direction;
+      count--;
+    }
+
+    // Шаг 19.
+    return O;
+  };
+}
+
+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES6', '#sec-array.prototype.copyWithin', 'Array.prototype.copyWithin')}}{{Spec2('ES6')}}Изначальное определение.
{{SpecName('ESDraft', '#sec-array.prototype.copyWithin', 'Array.prototype.copyWithin')}}{{Spec2('ESDraft')}} 
+ +

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

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerEdgeOperaSafari
Базовая поддержка{{CompatChrome("45")}}{{CompatGeckoDesktop("32")}}{{CompatNo}}12{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome для AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("32")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/entries/index.html b/files/ru/web/javascript/reference/global_objects/array/entries/index.html new file mode 100644 index 0000000000..291b14e5c0 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/entries/index.html @@ -0,0 +1,116 @@ +--- +title: Array.prototype.entries() +slug: Web/JavaScript/Reference/Global_Objects/Array/entries +tags: + - Array + - ECMAScript6 + - Experimental + - Iterator + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array/entries +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод entries() возвращает новый объект итератора массива Array Iterator, содержащий пары ключ / значение для каждого индекса в массиве.

+ +

Синтаксис

+ +
arr.entries()
+ +

Описание

+ +
var arr = ['a', 'b', 'c'];
+var eArr = arr.entries();
+
+console.log(eArr.next().value); // [0, 'a']
+console.log(eArr.next().value); // [1, 'b']
+console.log(eArr.next().value); // [2, 'c']
+
+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES6', '#sec-array.prototype.entries', 'Array.prototype.entries')}}{{Spec2('ES6')}}Изначальное определение.
{{SpecName('ESDraft', '#sec-array.prototype.entries', 'Array.prototype.entries')}}{{Spec2('ESDraft')}} 
+ +

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

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari
Базовая поддержка{{CompatChrome("38")}}{{CompatGeckoDesktop("28")}}{{CompatNo}}{{CompatOpera("25")}}{{CompatSafari("7.1")}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome для AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("28")}}{{CompatNo}}{{CompatNo}}iOS 8
+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/every/index.html b/files/ru/web/javascript/reference/global_objects/array/every/index.html new file mode 100644 index 0000000000..db333915d9 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/every/index.html @@ -0,0 +1,195 @@ +--- +title: Array.prototype.every() +slug: Web/JavaScript/Reference/Global_Objects/Array/every +tags: + - Array + - ECMAScript5 + - JavaScript + - JavaScript 1.6 + - Method + - Prototype + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/every +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод every() проверяет, удовлетворяют ли все элементы массива условию, заданному в передаваемой функции.

+ +
+

Обратите внимание: метод возвращает true при любом условии для пустого массива.

+
+ +

Синтаксис

+ +
arr.every(callback(currentValue[, index[, array]])[, thisArg])
+ +

Параметры

+ +
+
callback
+
Функция проверки каждого элемента, принимает три аргумента: +
+
currentValue
+
Текущий обрабатываемый элемент массива.
+
index{{Optional_inline}}
+
Индекс текущего обрабатываемого элемента массива.
+
array{{Optional_inline}}
+
Массив, по которому осуществляется проход.
+
+
+
thisArg{{Optional_inline}}
+
Необязательный параметр. Значение, используемое в качестве this при выполнении функции callback.
+
+ +

Возвращаемое значение

+ +

true если функция проверки возвращает {{Glossary("truthy")}} значение для каждого элемента массива. Иначе, false.

+ +

Описание

+ +

Метод every() вызывает переданную функцию callback один раз для каждого элемента, присутствующего в массиве до тех пор, пока не найдет такой, для которого callback вернет ложное значение (значение, становящееся равным false при приведении его к типу {{jsxref("Boolean")}}). Если такой элемент найден, метод every() немедленно вернёт false. В противном случае, если callback вернёт true для всех элементов массива, метод every() вернёт true. Функция callback вызывается только для индексов массива, имеющих присвоенные значения; она не вызывается для индексов, которые были удалены или которым значения никогда не присваивались.

+ +

Функция callback вызывается с тремя аргументами: значением элемента, индексом элемента и массивом, по которому осуществляется проход.

+ +

Если в метод every() был передан параметр thisArg, при вызове callback он будет использоваться в качестве значения this. В противном случае в качестве значения this будет использоваться значение {{jsxref("Global_Objects/undefined", "undefined")}}. В конечном итоге, значение this, наблюдаемое из функции callback, определяется согласно обычным правилам определения this, видимого из функции.

+ +

Метод every() не изменяет массив, для которого он был вызван.

+ +

Диапазон элементов, обрабатываемых методом every(), устанавливается до первого вызова функции callback. Элементы, добавленные в массив после начала выполнения метода every(), не будут посещены функцией callback. Если существующие элементы массива изменятся, значения, переданные в функцию callback, будут значениями на тот момент времени, когда метод every() посетит их; удалённые элементы посещены не будут.

+ +

Метод every() действует подобно квантору всеобщности в математике. В частности, он вернёт true для пустого массива. Это так называемая бессодержательная истина (vacuously true) — все элементы пустого множества (англ.) удовлетворяют любому заданному условию.

+ +

Примеры

+ +

Пример: проверка размера всех элементов массива

+ +

Следующий пример проверяет, являются ли все элементы массива числами, большими 10.

+ +
function isBigEnough(element, index, array) {
+  return element >= 10;
+}
+[12, 5, 8, 130, 44].every(isBigEnough);   // false
+[12, 54, 18, 130, 44].every(isBigEnough); // true
+
+ +

Пример: использование стрелочных функций

+ +

Стрелочные функции предоставляют более краткий синтаксис для подобных проверок.

+ +
[12, 5, 8, 130, 44].every(elem => elem >= 10);   // false
+[12, 54, 18, 130, 44].every(elem => elem >= 10); // true
+
+ +

Полифилл

+ +

Метод every() был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может не присутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать every() в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; и предполагает что {{jsxref("Object")}} и {{jsxref("TypeError")}} имеют свои первоначальные значения и что callback.call вычисляется в оригинальное значение {{jsxref("Function.prototype.call()")}}.

+ +
if (!Array.prototype.every) {
+  Array.prototype.every = function(callbackfn, thisArg) {
+    'use strict';
+    var T, k;
+
+    if (this == null) {
+      throw new TypeError('this is null or not defined');
+    }
+
+    // 1. Положим O равным результату вызова ToObject над значением
+    //    this, переданным в качестве аргумента.
+    var O = Object(this);
+
+    // 2. Положим lenValue равным результату вызова внутреннего метода Get
+    //    объекта O с аргументом "length".
+    // 3. Положим len равным ToUint32(lenValue).
+    var len = O.length >>> 0;
+
+    // 4. Если IsCallable(callbackfn) равен false, выкинем исключение TypeError.
+    if (typeof callbackfn !== 'function') {
+      throw new TypeError();
+    }
+
+    // 5. Если thisArg присутствует, положим T равным thisArg; иначе положим T равным undefined.
+    if (arguments.length > 1) {
+      T = thisArg;
+    }
+
+    // 6. Положим k равным 0.
+    k = 0;
+
+    // 7. Пока k < len, будем повторять
+    while (k < len) {
+
+      var kValue;
+
+      // a. Положим Pk равным ToString(k).
+      //   Это неявное преобразование для левостороннего операнда в операторе in
+      // b. Положим kPresent равным результату вызова внутреннего метода
+      //    HasProperty объекта O с аргументом Pk.
+      //   Этот шаг может быть объединён с шагом c
+      // c. Если kPresent равен true, то
+      if (k in O) {
+
+        // i. Положим kValue равным результату вызова внутреннего метода Get
+        //    объекта O с аргументом Pk.
+        kValue = O[k];
+
+        // ii. Положим testResult равным результату вызова внутреннего метода Call
+        //     функции callbackfn со значением T в качестве this и списком аргументов,
+        //     содержащим kValue, k и O.
+        var testResult = callbackfn.call(T, kValue, k, O);
+
+        // iii. Если ToBoolean(testResult) равен false, вернём false.
+        if (!testResult) {
+          return false;
+        }
+      }
+      k++;
+    }
+    return true;
+  };
+}
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES5.1', '#sec-15.4.4.16', 'Array.prototype.every')}}{{Spec2('ES5.1')}}Изначальное определение. Реализована в JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.every', 'Array.prototype.every')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-array.prototype.every', 'Array.prototype.every')}}{{Spec2('ESDraft')}}
+ +

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

+ +
+ +
{{Compat("javascript.builtins.Array.every")}}
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/fill/index.html b/files/ru/web/javascript/reference/global_objects/array/fill/index.html new file mode 100644 index 0000000000..1bef1fd1ea --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/fill/index.html @@ -0,0 +1,159 @@ +--- +title: Array.prototype.fill() +slug: Web/JavaScript/Reference/Global_Objects/Array/fill +tags: + - Array + - ECMAScript2015 + - ECMAScript6 + - JavaScript + - Method + - Prototype + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/fill +--- +
{{JSRef}}
+ +

Метод fill() заполняет все элементы массива от начального до конечного индексов одним значением.

+ +
{{EmbedInteractiveExample("pages/js/array-fill.html")}}
+ + + +

Синтаксис

+ +
arr.fill(value[, start = 0[, end = this.length]])
+ +

Параметры

+ +
+
value
+
Значение, заполняющее массив.
+
start
+
Необязательный параметр. Начальный индекс.
+
end
+
Необязательный параметр. Конечный индекс.
+
+

Возвращаемое значение

+ +

Изменённый массив.

+
+
+ +

Описание

+ +

Элементы заполняются в полузакрытом интервале [start, end).

+ +

Метод fill принимает до трёх аргументов — value, start и end. Аргументы start и end являются необязательными со значениями по умолчанию, равными 0 и length объекта this соответственно.

+ +

Если аргумент start является отрицательным, он трактуется как length+start, где length — это длина массива. Если аргумент end является отрицательным, он трактуется как length+end.

+ +

Метод fill намеренно является обобщённым, он не требует, чтобы значение this внутри него было объектом Array.

+ +

Метод fill является изменяющим методом, он изменит объект this и вернёт его, а не просто вернёт копию.

+ +

Если аргумент value​​​​​ является объектом, тo метод fill заполнит массив ссылками на этот объект.

+ +

Примеры

+ +
[1, 2, 3].fill(4);               // [4, 4, 4]
+[1, 2, 3].fill(4, 1);            // [1, 4, 4]
+[1, 2, 3].fill(4, 1, 2);         // [1, 4, 3]
+[1, 2, 3].fill(4, 1, 1);         // [1, 2, 3]
+[1, 2, 3].fill(4, 3, 3);         // [1, 2, 3]
+[1, 2, 3].fill(4, 3, 3);         // [1, 2, 3]
+[1, 2, 3].fill(4, -3, -2);       // [4, 2, 3]
+[1, 2, 3].fill(4, NaN, NaN);     // [1, 2, 3]
+[1, 2, 3].fill(4, 3, 5);         // [1, 2, 3]
+Array(3).fill(4);                // [4, 4, 4]
+[].fill.call({ length: 3 }, 4);  // {0: 4, 1: 4, 2: 4, length: 3}
+
+// Объекты заполняются по ссылке.
+var arr = Array(3).fill({}) // [{}, {}, {}];
+arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }]
+ +

Полифилл

+ +
if (!Array.prototype.fill) {
+  Object.defineProperty(Array.prototype, 'fill', {
+    value: function(value) {
+
+      // Шаги 1-2.
+      if (this == null) {
+        throw new TypeError('this is null or not defined');
+      }
+
+      var O = Object(this);
+
+      // Шаги 3-5.
+      var len = O.length >>> 0;
+
+      // Шаги 6-7.
+      var start = arguments[1];
+      var relativeStart = start >> 0;
+
+      // Шаг 8.
+      var k = relativeStart < 0 ?
+        Math.max(len + relativeStart, 0) :
+        Math.min(relativeStart, len);
+
+      // Шаги 9-10.
+      var end = arguments[2];
+      var relativeEnd = end === undefined ?
+        len : end >> 0;
+
+      // Шаг 11.
+      var final = relativeEnd < 0 ?
+        Math.max(len + relativeEnd, 0) :
+        Math.min(relativeEnd, len);
+
+      // Шаг 12.
+      while (k < final) {
+        O[k] = value;
+        k++;
+      }
+
+      // Шаг 13.
+      return O;
+    }
+  });
+}
+ +

Если вам нужно поддерживать действительно устаревшие движки JavaScript, которые не поддерживают Object.defineProperty, то лучше вообще не использовать полифилы для методов Array.prototype, так как вы не можете сделать их не перечисляемыми.

+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES6', '#sec-array.prototype.fill', 'Array.prototype.fill')}}{{Spec2('ES6')}}Изначальное определение.
{{SpecName('ESDraft', '#sec-array.prototype.fill', 'Array.prototype.fill')}}{{Spec2('ESDraft')}} 
+ +

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

+ +
+ + +

{{Compat("javascript.builtins.Array.fill")}}

+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/filter/index.html b/files/ru/web/javascript/reference/global_objects/array/filter/index.html new file mode 100644 index 0000000000..16333b09c6 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/filter/index.html @@ -0,0 +1,302 @@ +--- +title: Array.prototype.filter() +slug: Web/JavaScript/Reference/Global_Objects/Array/filter +tags: + - Array + - ECMAScript5 + - JavaScript + - Method + - Prototype + - Reference + - filter + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/filter +--- +
{{JSRef}}
+ +

Метод filter() создаёт новый массив со всеми элементами, прошедшими проверку, задаваемую в передаваемой функции.

+ +
{{EmbedInteractiveExample("pages/js/array-filter.html")}}
+ + + +

Синтаксис

+ +
let newArray = arr.filter(callback(element[, index, [array]])[, thisArg])
+
+ +

Параметры

+ +
+
callback
+
Функция, которая будет вызвана для каждого элемента массива. Если функция возвращает true, то элемент остаётся в массиве, если false, то удаляется.
+
В функцию будет передано три аргумента:
+
+
+
element
+
Текущий обрабатываемый элемент в массиве.
+
index{{optional_inline}}
+
Индекс текущего обрабатываемого элемента в массиве.
+
array{{optional_inline}}
+
Массив, по которому осуществляется проход.
+
+
+
thisArg {{optional_inline}}
+
Значение, используемое в качестве this при вызове функции callback.
+
+ +

Возвращаемое значение

+ +

Вернётся новый массив с элементами, которые проходят тест, то есть callback вернёт true. Если ни один элемент не пройдёт тест, то будет возвращён пустой массив.

+ +

Описание

+ +

Метод filter() вызывает переданную функцию callback один раз для каждого элемента, присутствующего в массиве, и конструирует новый массив со всеми значениями, для которых функция callback вернула true или {{Glossary('Truthy', 'значение, становящееся true при приведении в boolean')}}. Функция callback вызывается только для индексов массива, имеющих присвоенные значения; она не вызывается для индексов, которые были удалены или которым значения никогда не присваивались. Элементы массива, не прошедшие проверку функцией callback, просто пропускаются и не включаются в новый массив.

+ +

Функция callback вызывается с тремя аргументами:

+ +
    +
  1. значение элемента;
    2. +
  2. индекс элемента;
    3. +
  3. массив, по которому осуществляется проход.
    4. +
+ +

Если в метод filter() был передан параметр thisArg, при вызове callback он будет использоваться в качестве значения this. В противном случае, в качестве значения this будет использоваться значение {{jsxref("Global_Objects/undefined", "undefined")}}. В конечном итоге, значение this, наблюдаемое из функции callback, определяется согласно {{jsxref('Operators/this', 'обычным правилам определения this, видимого из функции')}}.

+ +

Метод filter() не изменяет массив, для которого он был вызван.

+ +

Диапазон элементов, обрабатываемых методом filter(), устанавливается до первого вызова функции callback. Элементы, добавленные в массив после начала выполнения метода filter(), не будут посещены функцией callback. Если существующие элементы массива изменятся, значения, переданные в функцию callback, будут значениями на тот момент времени, когда метод filter() посетит их; удалённые элементы посещены не будут.

+ +

Примеры

+ +

Отфильтровывание всех маленьких значений

+ +

Следующий пример использует filter() для создания отфильтрованного массива, все элементы которого больше или равны 10, а все меньшие 10 удалены.

+ +
function isBigEnough(value) {
+  return value >= 10;
+}
+
+let filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
+// массив filtered равен [12, 130, 44]
+
+ +

Найти все простые числа в массиве

+ +

Следующий пример возвращает все простые числа в массиве:

+ +
let array = [4, 6, 8, 9, 12, 53, -17, 2, 5, 7, 31, 97, -1, 17];
+
+function isPrime(num) {
+    if (num <= 1)
+        return false;
+    else if (num === 2)
+        return true;
+    else {
+        for (let i = 2; i < num; i++)
+            if (num % i === 0)
+                return false;
+        return true;
+    }
+}
+
+console.log(array.filter(isPrime));   // [53, 2, 5, 7, 31, 97, 17]
+ +

Фильтрация неверных записей в JSON

+ +

В следующем примере метод filter() используется для создания отфильтрованного объекта JSON, все элементы которого содержат ненулевое числовое поле id.

+ +
var arr = [
+    { id: 15 },
+    { id: -1 },
+    { id: 0 },
+    { id: 3 },
+    { id: 12.2 },
+    { },
+    { id: null },
+    { id: NaN },
+    { id: 'undefined' }
+];
+
+var invalidEntries = 0;
+
+function isNumber(obj) {
+    return obj!== undefined && typeof(obj) === 'number' && !isNaN(obj);
+}
+
+function filterByID(item) {
+    if (isNumber(item.id) && item.id !== 0) {
+        return true;
+    }
+    invalidEntries++;
+    return false;
+}
+
+var arrByID = arr.filter(filterByID);
+
+console.log('Отфильтрованный массив\n', arrByID);
+// Filtered Array
+// [{ id: 15 }, { id: -1 }, { id: 3 }, { id: 12.2 }]
+
+console.log('Количество ошибочных записей = ', invalidEntries);
+// Number of Invalid Entries = 5
+
+
+ +

Поиск в массиве

+ +

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

+ +
var fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];
+
+/**
+ * Элементы массива фильтруется на основе критериев поиска (query)
+*/
+function filterItems(query) {
+  return fruits.filter(function(el) {
+      return el.toLowerCase().indexOf(query.toLowerCase()) > -1;
+  })
+}
+
+console.log(filterItems('ap')); // ['apple', 'grapes']
+console.log(filterItems('an')); // ['banana', 'mango', 'orange']
+ +

ES2015 реализация

+ +
const fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];
+
+/**
+ * Элементы массива фильтруется на основе критериев поиска (query)
+ */
+const filterItems = (query) => {
+  return fruits.filter((el) =>
+    el.toLowerCase().indexOf(query.toLowerCase()) > -1
+  );
+}
+
+console.log(filterItems('ap')); // ['apple', 'grapes']
+console.log(filterItems('an')); // ['banana', 'mango', 'orange']
+
+
+ +

Влияние на начальный массив (изменение, добавление и удаление)

+ +

В следующих примерах проверяется поведение метода filter при изменении массива.

+ +
// Изменение всех элементов
+let words = ['spray', 'limit', 'exuberant', 'destruction','elite', 'present']
+
+const modifiedWords = words.filter( (word, index, arr) => {
+  arr[index+1] +=' extra'
+  return word.length < 6
+})
+
+console.log(modifiedWords)
+// Обратите внимание, что есть три слова длиной менее 6, но так как они были изменены,
+// возвращается одно слово ['spray']
+
+// Добавление новых элементов
+words = ['spray', 'limit', 'exuberant', 'destruction','elite', 'present']
+const appendedWords = words.filter( (word, index, arr) => {
+  arr.push('new')
+  return word.length < 6
+})
+
+console.log(appendedWords)
+// Только три слова удовлетворяют условию, хотя `words` теперь имеет куда больше слов,
+// длинной меньше 6 символов: ['spray', 'limit', 'elite']
+
+// Удаление элементов
+words = ['spray', 'limit', 'exuberant', 'destruction', 'elite', 'present']
+const deleteWords = words.filter( (word, index, arr) => {
+  arr.pop()
+  return word.length < 6
+})
+
+console.log(deleteWords)
+// Заметьте, что 'elite' не получено, так как удалено из `words` до того,
+// как filter смог получить его: ['spray', 'limit']
+ +

Полифилл

+ +

Метод filter() был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать filter() в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; он предполагает, что fn.call вычисляется в оригинальное значение {{jsxref("Function.prototype.call()")}} и что {{jsxref("Array.prototype.push()")}} содержит своё оригинальное значение.

+ +
if (!Array.prototype.filter) {
+  Array.prototype.filter = function(fun/*, thisArg*/) {
+    'use strict';
+
+    if (this === void 0 || this === null) {
+      throw new TypeError();
+    }
+
+    var t = Object(this);
+    var len = t.length >>> 0;
+    if (typeof fun !== 'function') {
+      throw new TypeError();
+    }
+
+    var res = [];
+    var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
+    for (var i = 0; i < len; i++) {
+      if (i in t) {
+        var val = t[i];
+
+        // ПРИМЕЧАНИЕ: Технически, здесь должен быть Object.defineProperty на
+        //             следующий индекс, поскольку push может зависеть от
+        //             свойств на Object.prototype и Array.prototype.
+        //             Но этот метод новый и коллизии должны быть редкими,
+        //             так что используем более совместимую альтернативу.
+        if (fun.call(thisArg, val, i, t)) {
+          res.push(val);
+        }
+      }
+    }
+
+    return res;
+  };
+}
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES5.1', '#sec-15.4.4.20', 'Array.prototype.filter')}}{{Spec2('ES5.1')}}Изначальное определение. Реализована в JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.filter', 'Array.prototype.filter')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-array.prototype.filter', 'Array.prototype.filter')}}{{Spec2('ESDraft')}}
+ +

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

+ +
+ + +

{{Compat("javascript.builtins.Array.filter")}}

+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/find/index.html b/files/ru/web/javascript/reference/global_objects/array/find/index.html new file mode 100644 index 0000000000..f4b8844a62 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/find/index.html @@ -0,0 +1,167 @@ +--- +title: Array.prototype.find() +slug: Web/JavaScript/Reference/Global_Objects/Array/find +tags: + - Array + - ECMAScript6 + - Experimental + - Expérimental(2) + - JavaScript + - Method + - Prototype + - Reference + - Référence(2) + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/find +--- +

{{JSRef}}

+ +

Сводка

+ +

Метод find() возвращает значение первого найденного в массиве элемента, которое удовлетворяет условию переданному в callback функции.  В противном случае возвращается {{jsxref("Global_Objects/undefined", "undefined")}}.

+ +

Также смотрите метод {{jsxref("Array.findIndex", "findIndex()")}}, который возвращает индекс найденного в массиве элемента вместо его значения.

+ +

Если вам нужно найти позицию элемента или наличие элемента в массиве, используйте {{jsxref("Array.prototype.indexOf()")}} или {{jsxref("Array.prototype.includes()")}} соответственно.

+ +

Синтаксис

+ +
arr.find(callback[, thisArg])
+ +

Параметры

+ +
+
callback
+
Функция, вызывающаяся для каждого значения в массиве, принимает три аргумента: +
+
element
+
Текущий обрабатываемый элемент в массиве.
+
index
+
Индекс текущего обрабатываемого элемента в массиве.
+
array
+
Массив, по которому осуществляется проход.
+
+
+
thisArg
+
Необязательный параметр. Значение, используемое в качестве this при выполнении функции callback.
+
+ +

Возвращаемое значение

+ +

Значение элемента из массива, если элемент прошёл проверку, иначе {{jsxref("undefined")}}.

+ +

Описание

+ +

Метод find вызывает переданную функцию callback один раз для каждого элемента, присутствующего в массиве, до тех пор, пока она не вернёт true. Если такой элемент найден, метод find немедленно вернёт значение этого элемента. В противном случае, метод find вернёт {{jsxref("Global_Objects/undefined", "undefined")}}. До Firefox 34 функция callback не вызывалась для «дырок» в массивах (bug 1058394).

+ +

Функция callback вызывается с тремя аргументами: значением элемента, индексом элемента и массивом, по которому осуществляется проход.

+ +

Если в метод find был передан параметр thisArg, при вызове callback он будет использоваться в качестве значения this. В противном случае в качестве значения this будет использоваться значение {{jsxref("Global_Objects/undefined", "undefined")}}.

+ +

Метод find не изменяет массив, для которого он был вызван.

+ +

Диапазон элементов, обрабатываемых методом find, устанавливается до первого вызова функции callback. Элементы, добавленные в массив после начала выполнения метода find, не будут посещены функцией callback. Если существующие, непосещённые элементы массива изменяются функцией callback, их значения, переданные в функцию, будут значениями на тот момент времени когда метод find посетит их; удалённые элементы все еще будут посещены. 

+ +

Примеры

+ +

Пример: поиск простого числа в массиве

+ +

Следующий пример находит в массиве положительных чисел элемент, являющийся простым числом (либо возвращает {{jsxref("Global_Objects/undefined", "undefined")}}, если в массиве нет простых чисел).

+ +
function isPrime(element, index, array) {
+  var start = 2;
+  while (start <= Math.sqrt(element)) {
+    if (element % start++ < 1) {
+      return false;
+    }
+  }
+  return element > 1;
+}
+
+console.log([4, 6, 8, 12].find(isPrime)); // undefined, не найдено
+console.log([4, 5, 8, 12].find(isPrime)); // 5
+
+ +

Полифилл

+ +

Этот метод был добавлен в спецификации ECMAScript 6 и пока может быть недоступен во всех реализациях JavaScript. Однако, вы можете использовать следующий сниппет в качестве полифилла:

+ +
// https://tc39.github.io/ecma262/#sec-array.prototype.find
+if (!Array.prototype.find) {
+  Object.defineProperty(Array.prototype, 'find', {
+    value: function(predicate) {
+     // 1. Let O be ? ToObject(this value).
+      if (this == null) {
+        throw new TypeError('"this" is null or not defined');
+      }
+
+      var o = Object(this);
+
+      // 2. Let len be ? ToLength(? Get(O, "length")).
+      var len = o.length >>> 0;
+
+      // 3. If IsCallable(predicate) is false, throw a TypeError exception.
+      if (typeof predicate !== 'function') {
+        throw new TypeError('predicate must be a function');
+      }
+
+      // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.
+      var thisArg = arguments[1];
+
+      // 5. Let k be 0.
+      var k = 0;
+
+      // 6. Repeat, while k < len
+      while (k < len) {
+        // a. Let Pk be ! ToString(k).
+        // b. Let kValue be ? Get(O, Pk).
+        // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
+        // d. If testResult is true, return kValue.
+        var kValue = o[k];
+        if (predicate.call(thisArg, kValue, k, o)) {
+          return kValue;
+        }
+        // e. Increase k by 1.
+        k++;
+      }
+
+      // 7. Return undefined.
+      return undefined;
+    },
+    configurable: true,
+    writable: true
+  });
+}
+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES6', '#sec-array.prototype.find', 'Array.prototype.find')}}{{Spec2('ES6')}}Изначальное определение.
{{SpecName('ESDraft', '#sec-array.prototype.find', 'Array.prototype.find')}}{{Spec2('ESDraft')}} 
+ +

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

+ +

{{Compat("javascript.builtins.Array.find")}}

+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/findindex/index.html b/files/ru/web/javascript/reference/global_objects/array/findindex/index.html new file mode 100644 index 0000000000..7cbc30e738 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/findindex/index.html @@ -0,0 +1,138 @@ +--- +title: Array.prototype.findIndex() +slug: Web/JavaScript/Reference/Global_Objects/Array/findIndex +tags: + - Array + - ECMAScript6 + - Experimental + - Expérimental(2) + - JavaScript + - Method + - Prototype + - Reference + - Référence(2) + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод findIndex() возвращает индекс в массиве, если элемент удовлетворяет условию проверяющей функции. В противном случае возвращается -1.

+ +

Также смотрите метод {{jsxref("Array.find", "find()")}}, который возвращает значение найденного в массиве элемента вместо его индекса.

+ +

Синтаксис

+ +
arr.findIndex(callback[, thisArg])
+ +

Параметры

+ +
+
callback
+
Функция, вызывающаяся для каждого значения в масиве, принимает три аргумента: +
+
element
+
Текущий обрабатываемый элемент в массиве.
+
index
+
Индекс текущего обрабатываемого элемента в массиве.
+
array
+
Массив, по которому осуществляется проход.
+
+
+
thisArg
+
Необязательный параметр. Значение, используемое в качестве this при выполнении функции callback.
+
+ +

Описание

+ +

Метод findIndex вызывает переданную функцию callback один раз для каждого элемента, присутствующего в массиве, до тех пор, пока она не вернёт true. Если такой элемент найден, метод findIndex немедленно вернёт индекс этого элемента. В противном случае, метод findIndex вернёт -1. Функция callback вызывается только для индексов массива, имеющих присвоенные значения; она не вызывается для индексов, которые были удалены или которым значения никогда не присваивались.

+ +

Функция callback вызывается с тремя аргументами: значением элемента, индексом элемента и массивом, по которому осуществляется проход.

+ +

Если в метод findIndex был передан параметр thisArg, при вызове callback он будет использоваться в качестве значения this. В противном случае в качестве значения this будет использоваться значение {{jsxref("Global_Objects/undefined", "undefined")}}.

+ +

Метод findIndex не изменяет массив, для которого он был вызван.

+ +

Диапазон элементов, обрабатываемых методом findIndex, устанавливается до первого вызова функции callback. Элементы, добавленные в массив после начала выполнения метода findIndex, не будут посещены функцией callback. Если существующие, непосещённые элементы массива изменяются функцией callback, их значения, переданные в функцию, будут значениями на тот момент времени, когда метод findIndex посетит их; удалённые элементы посещены не будут.

+ +

Примеры

+ +

Пример: поиск индекса простого числа в массиве

+ +

Следующий пример находит в массиве индекс элемента, являющийся простым числом (либо возвращает -1, если в массиве нет простых чисел).

+ +
function isPrime(element, index, array) {
+  var start = 2;
+  while (start <= Math.sqrt(element)) {
+    if (element % start++ < 1) {
+      return false;
+    }
+  }
+  return element > 1;
+}
+
+console.log([4, 6, 8, 12].findIndex(isPrime)); // -1, не найдено
+console.log([4, 6, 7, 12].findIndex(isPrime)); // 2
+
+ +

Полифилл

+ +

Этот метод был добавлен в спецификации ECMAScript 6 и пока может быть недоступен во всех реализациях JavaScript. Однако, вы можете использовать следующий кусочек кода в качестве полифилла:

+ +
if (!Array.prototype.findIndex) {
+  Array.prototype.findIndex = function(predicate) {
+    if (this == null) {
+      throw new TypeError('Array.prototype.findIndex called on null or undefined');
+    }
+    if (typeof predicate !== 'function') {
+      throw new TypeError('predicate must be a function');
+    }
+    var list = Object(this);
+    var length = list.length >>> 0;
+    var thisArg = arguments[1];
+    var value;
+
+    for (var i = 0; i < length; i++) {
+      value = list[i];
+      if (predicate.call(thisArg, value, i, list)) {
+        return i;
+      }
+    }
+    return -1;
+  };
+}
+
+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES6', '#sec-array.prototype.findIndex', 'Array.prototype.findIndex')}}{{Spec2('ES6')}}Изначальное определение.
{{SpecName('ESDraft', '#sec-array.prototype.findIndex', 'Array.prototype.findIndex')}}{{Spec2('ESDraft')}} 
+ +

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

+ +

{{Compat("javascript.builtins.Array.findIndex")}}

+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/flat/index.html b/files/ru/web/javascript/reference/global_objects/array/flat/index.html new file mode 100644 index 0000000000..7ce48303ea --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/flat/index.html @@ -0,0 +1,160 @@ +--- +title: Array.prototype.flat() +slug: Web/JavaScript/Reference/Global_Objects/Array/flat +tags: + - Массив + - Ссылка + - Экспериментальная + - метод + - прототип + - яваскрипт +translation_of: Web/JavaScript/Reference/Global_Objects/Array/flat +--- +
{{JSRef}}
+ +

Метод flat() возвращает новый массив, в котором все элементы вложенных подмассивов были рекурсивно "подняты" на указанный уровень depth.

+ + + + + +

Синтаксис

+ +
var newArray = arr.flat(depth);
+ +

Параметры

+ +
+
depth {{optional_inline}}
+
На сколько уровней вложенности уменьшается мерность исходного массива. По-умолчанию 1.
+
+ +

Возвращаемое значение

+ +

Новый массив с объединенными в него подмассивами.

+ +

Примеры

+ +

Упрощение вложенных массивов

+ +
var arr1 = [1, 2, [3, 4]];
+arr1.flat();
+// [1, 2, 3, 4]
+
+var arr2 = [1, 2, [3, 4, [5, 6]]];
+arr2.flat();
+// [1, 2, 3, 4, [5, 6]]
+
+var arr3 = [1, 2, [3, 4, [5, 6]]];
+arr3.flat(2);
+// [1, 2, 3, 4, 5, 6]
+
+var arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
+arr4.flat(Infinity);
+// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+ +

Упрощение и "дырки" в массивах

+ +

Метод flat удаляет пустые слоты из массива:

+ +
var arr4 = [1, 2, , 4, 5];
+arr4.flat();
+// [1, 2, 4, 5]
+
+ +

Альтернативы

+ +

reduce и concat

+ +
var arr1 = [1, 2, [3, 4]];
+arr1.flat();
+
+// В одномерный массив
+arr1.reduce((acc, val) => acc.concat(val), []);// [1, 2, 3, 4]
+
+//или
+const flatSingle = arr => [].concat(...arr);
+
+ +
// Для развёртвания многомерных массивов используем рекурсию, reduce и concat
+const arr = [1, 2, [3, 4, [5, 6]]];
+
+function flatDeep(arr, d = 1) {
+   return d > 0 ? arr.reduce((acc, val) => acc.concat(Array.isArray(val) ? flatDeep(val, d - 1) : val), [])
+                : arr.slice();
+};
+
+flatDeep(arr, Infinity);
+// [1, 2, 3, 4, 5, 6]
+ +
//не рекурсивное упрощение с использованием стэка
+var arr1 = [1,2,3,[1,2,3,4, [2,3,4]]];
+function flatten(input) {
+  const stack = [...input];
+  const res = [];
+  while (stack.length) {
+    // забираем последнее значение
+    const next = stack.pop();
+    if (Array.isArray(next)) {
+      // добавляем к массиву элементы не модифицируя исходное значение
+      stack.push(...next);
+    } else {
+      res.push(next);
+    }
+  }
+  //разворачиваем массив, чтобы восстановить порядок элементов
+  return res.reverse();
+}
+flatten(arr1);// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]
+
+ +
//рекурсивно упрощаем массив
+function flatten(array) {
+  var flattend = [];
+  (function flat(array) {
+    array.forEach(function(el) {
+      if (Array.isArray(el)) flat(el);
+      else flattend.push(el);
+    });
+  })(array);
+  return flattend;
+}
+
+ + + +

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

+ + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
Array.prototype.flat proposalКандидат (3)
+ +

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

+ +
+ + +

{{Compat("javascript.builtins.Array.flat")}}

+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/flatmap/index.html b/files/ru/web/javascript/reference/global_objects/array/flatmap/index.html new file mode 100644 index 0000000000..4465a92711 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/flatmap/index.html @@ -0,0 +1,126 @@ +--- +title: Array.prototype.flatMap() +slug: Web/JavaScript/Reference/Global_Objects/Array/flatMap +translation_of: Web/JavaScript/Reference/Global_Objects/Array/flatMap +--- +
{{JSRef}}
+ +

Метод flatMap() сначала применяет функцию к каждому элементу, а затем преобразует полученый результат в плоскую структуру и помещает в новый массив. Это идентично map функции, с последующим применением функции flat с параметром depth ( глубина ) равным 1, но flatMap часто бывает полезным, так как работает немного более эффективно.

+ + + + + +

Синтаксис

+ +
var new_array = arr.flatMap(function callback(currentValue[, index[, array]]) {
+    // возращает элемент для new_array
+}[, thisArg])
+ +

Параметры

+ +
+
callback
+
Функция которая производит элементы нового массива, принимает три аргумента: +
+
+
currentValue
+
Текущий обрабатываемый элемент массива.
+
index{{optional_inline}}
+
Индекс обрабатываемого элемента в массиве.
+
array{{optional_inline}}
+
Массив по которому осуществляется обход.
+
+
+
thisArg{{optional_inline}}
+
Значение используемое в качестве this при вызове функции callback.
+
+ +

Возвращаемое значение

+ +

Новый массив, каждый элемент которого является результатом выполнения функции callback и "поднят" на уровень 1.

+ +

Описание

+ +

Смотрите {{jsxref("Array.prototype.map()")}} для детального описания callback функции. Метод flatMap идентичен методу map с последующим вызовом flat с параметром depth 1.

+ +

Примеры

+ +

map и flatMap

+ +
let arr1 = [1, 2, 3, 4];
+
+arr1.map(x => [x * 2]);
+// [[2], [4], [6], [8]]
+
+arr1.flatMap(x => [x * 2]);
+// [2, 4, 6, 8]
+
+// выравнивается только один уровень
+arr1.flatMap(x => [[x * 2]]);
+// [[2], [4], [6], [8]]
+
+ +

Хотя результат полученый в примере выше можно было получить используя просто map, ниже мы рассмотрим пример где flatMap является более эффективным.

+ +

Давайте сгенерируем список слов из списка предложений.

+ +
let arr1 = ["it's Sunny in", "", "California"];
+
+arr1.map(x => x.split(" "));
+// [["it's","Sunny","in"],[""],["California"]]
+
+arr1.flatMap(x => x.split(" "));
+// ["it's","Sunny","in", "", "California"]
+ +

Обратите внимание, длина списка вывода может отличаться от длины списка ввода.

+ +
//=> [1, 2, 3, 4, 5, 6, 7, 8, 9]
+ +

Альтернативное решение

+ +

reduce and concat

+ +
var arr1 = [1, 2, 3, 4];
+
+arr1.flatMap(x => [x * 2]);
+// is equivalent to
+arr1.reduce((acc, x) => acc.concat([x * 2]), []);
+// [2, 4, 6, 8]
+
+ +
//=> [1, 2, 3, 4, 5, 6, 7, 8, 9]
+ +

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

+ + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ES6', '#sec-array.prototype.flatmap', 'Array.prototype.flatMap')}}{{Spec2('ES6')}}
+ +

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

+ +
+ + +

{{Compat("javascript.builtins.Array.flatMap")}}

+
+ +

См так же:

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/foreach/index.html b/files/ru/web/javascript/reference/global_objects/array/foreach/index.html new file mode 100644 index 0000000000..3787dc7e84 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/foreach/index.html @@ -0,0 +1,388 @@ +--- +title: Array.prototype.forEach() +slug: Web/JavaScript/Reference/Global_Objects/Array/forEach +tags: + - Array + - ECMAScript5 + - JavaScript + - Method + - Prototype + - Reference + - forEach + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/forEach +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Метод forEach() выполняет указанную функцию один раз для каждого элемента в массиве.

+ +
{{EmbedInteractiveExample("pages/js/array-foreach.html")}}
+ + + +

Синтаксис

+ +
arr.forEach(function callback(currentValue, index, array) {
+    //your iterator
+}[, thisArg]);
+ +

Параметры

+ +
+
callback
+
Функция, которая будет вызвана для каждого элемента массива. Она принимает от одного до трех аргументов:
+
+
+
currentValue
+
Текущий обрабатываемый элемент в массиве.
+
index{{optional_inline}}
+
Индекс текущего обрабатываемого элемента в массиве.
+
array{{optional_inline}}
+
Массив, по которому осуществляется проход.
+
+
+
thisArg
+
Необязательный параметр. Значение, используемое в качестве this при вызове функции callback.
+
+ +

Возвращаемое значение

+ +

{{jsxref("undefined")}}.

+ +

Описание

+ +

Метод forEach() выполняет функцию callback один раз для каждого элемента, находящегося в массиве в порядке возрастания. Она не будет вызвана для удалённых или пропущенных элементов массива. Однако, она будет вызвана для элементов, которые присутствуют в массиве и имеют значение {{jsxref("Global_Objects/undefined", "undefined")}}.

+ +

Функция callback будет вызвана с тремя аргументами:

+ + + +

Если в метод forEach() был передан параметр thisArg, при вызове callback он будет использоваться в качестве значения this. В противном случае, в качестве значения this будет использоваться значение {{jsxref("Global_Objects/undefined", "undefined")}}. В конечном итоге, значение this, наблюдаемое из функции callback, определяется согласно {{jsxref('Operators/this', 'обычным правилам определения this, видимого из функции')}}.

+ +

Диапазон элементов, обрабатываемых методом forEach(), устанавливается до первого вызова функции callback. Элементы, добавленные в массив после начала выполнения метода forEach(), не будут посещены функцией callback. Если существующие элементы массива изменятся, значения, переданные в функцию callback, будут значениями на тот момент времени, когда метод forEach() посетит их; удалённые элементы посещены не будут. Если уже посещённые элементы удаляются во время итерации (например, с помощью {{jsxref("Array.prototype.shift()", "shift()")}}), последующие элементы будут пропущены. ({{jsxref('Global_Objects/Array/forEach', 'Смотри пример ниже', 'Модификация_массива_во_время_итерации')}})

+ +
+

Примечание: Не существует способа остановить или прервать цикл forEach() кроме как выбрасыванием исключения. Если вам необходимо такое поведение, метод forEach() неправильный выбор.

+ +

Досрочное прекращение может быть достигнуто с:

+ + + +

Если нужно протестировать элементы массива на условие и нужно вернуть булево значение, вы можете воспользоваться методами {{jsxref("Array.prototype.every()", "every()")}}, {{jsxref("Array.prototype.some()", "some()")}}, {{jsxref("Array.prototype.find()", "find()")}} или {{jsxref("Array.prototype.findIndex()", "findIndex()")}}.

+ +

Метод forEach() выполняет функцию callback один раз для каждого элемента массива; в отличие от методов {{jsxref("Array.prototype.every()", "every()")}} и {{jsxref("Array.prototype.some()", "some()")}}, он всегда возвращает значение {{jsxref("Global_Objects/undefined", "undefined")}}.

+
+ +

Примеры

+ +

Нет операции для неинициализированных значений (разреженные массивы)

+ +
const arraySparse = [1,3,,7]
+let numCallbackRuns = 0
+
+arraySparse.forEach((element) => {
+  console.log(element)
+  numCallbackRuns++
+})
+
+console.log("numCallbackRuns: ", numCallbackRuns)
+
+// 1
+// 3
+// 7
+// numCallbackRuns: 3
+// комментарий: как вы видите пропущенное значение между 3 и 7 не вызывало функцию callback.
+ +

Конвертируем цикл for в forEach

+ +
const items = ['item1', 'item2', 'item3']
+const copy = []
+
+// до
+for (let i = 0; i < items.length; i++) {
+  copy.push(items[i])
+}
+
+// после
+items.forEach(function(item){
+  copy.push(item)
+})
+
+ +

Печать содержимого массива

+ +
+

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

+ +

Следующий пример иллюстрирует альтернативный подход, использующий forEach().

+
+ +

Следующий код выводит каждый элемент массива на новой строке журнала:

+ +
function logArrayElements(element, index, array) {
+  console.log('a[' + index + '] = ' + element);
+}
+
+// Обратите внимание на пропуск по индексу 2, там нет элемента, поэтому он не посещается
+[2, 5, , 9].forEach(logArrayElements);
+// логи:
+// a[0] = 2
+// a[1] = 5
+// a[3] = 9
+
+ +

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

+ +

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

+ +
function Counter() {
+  this.sum = 0
+  this.count = 0
+}
+Counter.prototype.add = function(array) {
+  array.forEach((entry) => {
+    this.sum += entry
+    ++this.count
+  }, this)
+  // ^---- Note
+}
+
+const obj = new Counter()
+obj.add([2, 5, 9])
+obj.count
+// 3
+obj.sum
+// 16
+
+ +

Поскольку в forEach()передан параметр thisArg (this), он затем передаётся в callback при каждом вызове. И callback использует его в качестве собственного значения this.

+ +
+

Примечание: Если при передаче callback функции используется {{jsxref('Functions/Arrow_functions', 'выражение стрелочной функции')}}, параметр thisArg может быть опущен, так как все стрелочные функции лексически привязываются к значению{{jsxref("Operators/this", "this")}}.

+
+ +

Прерывание цикла

+ +

Следующий код использует {{jsxref("Array.prototype.every()")}} для логирования содержимого массива и останавливается при превышении значением заданного порогового значения THRESHOLD.

+ +
var THRESHOLD = 12;
+var v = [5, 2, 16, 4, 3, 18, 20];
+var res;
+
+res = v.every(function(element, index, array) {
+  console.log('element:', element);
+  if (element >= THRESHOLD) {
+    return false;
+  }
+
+  return true;
+});
+console.log('res:', res);
+// логи:
+// element: 5
+// element: 2
+// element: 16
+// res: false
+
+res = v.some(function(element, index, array) {
+  console.log('element:', element);
+  if (element >= THRESHOLD) {
+    return true;
+  }
+
+  return false;
+});
+console.log('res:', res);
+// логи:
+// element: 5
+// element: 2
+// element: 16
+// res: true
+
+ +

Функция копирования объекта

+ +

Следующий код создаёт копию переданного объекта. Существует несколько способов создания копии объекта, и это один из них. Он позволяет понять, каким образом работает Array.prototype.forEach(), используя функции мета-свойств Object.* из ECMAScript 5.

+ +
function copy(o) {
+  var copy = Object.create(Object.getPrototypeOf(o));
+  var propNames = Object.getOwnPropertyNames(o);
+
+  propNames.forEach(function(name) {
+    var desc = Object.getOwnPropertyDescriptor(o, name);
+    Object.defineProperty(copy, name, desc);
+  });
+
+  return copy;
+}
+
+var o1 = { a: 1, b: 2 };
+var o2 = copy(o1); // теперь o2 выглядит также, как и o1
+
+ +

Модификация массива во время итерации

+ +

В следующем примере в лог выводится "one", "two", "four".

+ +

При достижении записи, содержащей значение 'two', первая запись всего массива удаляется, в результате чего все оставшиеся записи перемещаются на одну позицию вверх. Поскольку элемент 'four' теперь находится на более ранней позиции в массиве, 'three' будет пропущен.

+ +

forEach() не делает копию массива перед итерацией.

+ +
let words = ['one', 'two', 'three', 'four']
+words.forEach((word) => {
+  console.log(word)
+  if (word === 'two') {
+    words.shift()
+  }
+})
+// one
+// two
+// four
+
+ +

Выравнивание (уплощение) массива

+ +

Следующий пример приведен только для целей обучения. Если вы хотите выравнять массив с помощью встроенных методов, вы можете использовать {{jsxref("Array.prototype.flat()")}}

+ +
function flatten(arr) {
+  const result = []
+
+  arr.forEach((i) => {
+    if (Array.isArray(i)) {
+      result.push(...flatten(i))
+    } else {
+      result.push(i)
+    }
+  })
+
+  return result
+}
+
+// Usage
+const nested = [1, 2, 3, [4, 5, [6, 7], 8, 9]]
+
+flatten(nested) // [1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+ +

Полифилл

+ +

Метод forEach() был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать forEach() в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; он предполагает, что {{jsxref("Object")}} и {{jsxref("TypeError")}} имеют свои первоначальные значения и что callback.call вычисляется в оригинальное значение {{jsxref("Function.prototype.call()")}}.

+ +
// Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.18
+// Ссылка (en): http://es5.github.io/#x15.4.4.18
+// Ссылка (ru): http://es5.javascript.ru/x15.4.html#x15.4.4.18
+if (!Array.prototype.forEach) {
+
+  Array.prototype.forEach = function (callback, thisArg) {
+
+    var T, k;
+
+    if (this == null) {
+      throw new TypeError(' this is null or not defined');
+    }
+
+    // 1. Положим O равным результату вызова ToObject passing the |this| value as the argument.
+    var O = Object(this);
+
+    // 2. Положим lenValue равным результату вызова внутреннего метода Get объекта O с аргументом "length".
+    // 3. Положим len равным ToUint32(lenValue).
+    var len = O.length >>> 0;
+
+    // 4. Если IsCallable(callback) равен false, выкинем исключение TypeError.
+    // Смотрите: http://es5.github.com/#x9.11
+    if (typeof callback !== 'function') {
+        throw new TypeError(callback + ' is not a function');
+    }
+
+    // 5. Если thisArg присутствует, положим T равным thisArg; иначе положим T равным undefined.
+    if (arguments.length > 1) {
+      T = thisArg;
+    }
+
+    // 6. Положим k равным 0
+    k = 0;
+
+    // 7. Пока k < len, будем повторять
+    while (k < len) {
+
+      var kValue;
+
+      // a. Положим Pk равным ToString(k).
+      //   Это неявное преобразование для левостороннего операнда в операторе in
+      // b. Положим kPresent равным результату вызова внутреннего метода HasProperty объекта O с аргументом Pk.
+      //   Этот шаг может быть объединён с шагом c
+      // c. Если kPresent равен true, то
+      if (k in O) {
+
+        // i. Положим kValue равным результату вызова внутреннего метода Get объекта O с аргументом Pk.
+        kValue = O[k];
+
+        // ii. Вызовем внутренний метод Call функции callback с объектом T в качестве значения this и
+        // списком аргументов, содержащим kValue, k и O.
+        callback.call(T, kValue, k, O);
+      }
+      // d. Увеличим k на 1.
+      k++;
+    }
+    // 8. Вернём undefined.
+  };
+}
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES5.1', '#sec-15.4.4.18', 'Array.prototype.forEach')}}{{Spec2('ES5.1')}}Изначальное определение. Реализована в JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.foreach', 'Array.prototype.forEach')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-array.prototype.foreach', 'Array.prototype.forEach')}}{{Spec2('ESDraft')}}
+ +

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

+ +
+ + +

{{Compat("javascript.builtins.Array.forEach")}}

+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/from/index.html b/files/ru/web/javascript/reference/global_objects/array/from/index.html new file mode 100644 index 0000000000..f373749ec7 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/from/index.html @@ -0,0 +1,216 @@ +--- +title: Array.from() +slug: Web/JavaScript/Reference/Global_Objects/Array/from +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Method + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/from +--- +
{{JSRef}}
+ +

Метод Array.from() создаёт новый экземпляр Array из массивоподобного или итерируемого объекта.

+ +

{{EmbedInteractiveExample("pages/js/array-from.html")}}

+ +

Синтаксис

+ +
Array.from(arrayLike[, mapFn[, thisArg]])
+ +

Параметры

+ +
+
arrayLike
+
Массивоподобный или итерируемый объект, преобразуемый в массив.
+
mapFn {{Optional_inline}}
+
Отображающая функция, вызываемая для каждого элемента массива.
+
thisArg {{Optional_inline}}
+
Значение, используемое в качестве this при выполнении функции mapFn.
+
+ +

Возвращаемое значение

+ +

Новый экземпляр {{jsxref("Array")}}

+ +

Описание

+ +

Array.from() позволяет вам создавать массивы из:

+ + + +

Array.from() имеет необязательный параметр mapFn, который позволяет вам выполнять функцию {{jsxref("Array.prototype.map", "map")}} для каждого элемента создаваемого массива (или его подкласса). Проще говоря, вызов Array.from(obj, mapFn, thisArg) эквивалентен цепочке Array.from(obj).map(mapFn, thisArg), за исключением того, что он не создаёт промежуточного массива. Это особенно важно для некоторых подклассов массива, вроде типизированных массивов, поскольку промежуточный массив неизбежно приведёт к усечению значений, чтобы они подпали под подходящий тип.

+ +

Свойство length метода from() равно 1.

+ +

В ES2015 классовый синтаксис позволяет создавать подклассы как встроенных классов, так и классов, определённых пользователем; в результате статические методы класса, вроде Array.from «наследуются» подклассами {{jsxref("Global_Objects/Array", "Array")}} и создают новые экземпляры подкласса, а не класса {{jsxref("Global_Objects/Array", "Array")}}.

+ +

Примеры

+ +

Массив из строки String

+ +
Array.from('foo');
+// ['f', 'o', 'o']
+
+ +

Массив из Set

+ +
var s = new Set(['foo', window]);
+Array.from(s);
+// ['foo', window]
+
+ +

Массив из Map

+ +
var m = new Map([[1, 2], [2, 4], [4, 8]]);
+Array.from(m);
+// [[1, 2], [2, 4], [4, 8]]
+
+ +

Массив из массивоподобного объекта (arguments)

+ +
function f() {
+  return Array.from(arguments);
+}
+
+f(1, 2, 3);
+// [1, 2, 3]
+
+ +

Использование стрелочной функции и Array.from()

+ +
// Использование стрелочной функции в качестве функции отображения для
+
+// манипулирования элементами
+Array.from([1, 2, 3], x => x + x);
+// [2, 4, 6]
+
+// Генерирования последовательности чисел
+Array.from({ length: 5 }, (v, k) => k);
+// [0, 1, 2, 3, 4]
+ +

Полифилл

+ +

Метод Array.from был добавлен к стандарту ECMA-262 в 6-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать Array.from в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 6-го издания; он предполагает, что {{jsxref("Global_Objects/Object", "Object")}} и {{jsxref("Global_Objects/TypeError", "TypeError")}} имеют свои первоначальные значения и что callback.call вычисляется в оригинальное значение {{jsxref("Function.prototype.call")}}. Кроме того, поскольку истинные итерируемые объекты не могут быть заменены полифиллом, эта реализация не поддерживает общие итерируемые объекты, как они определены в 6-м издании ECMA-262.

+ +
// Шаги алгоритма ECMA-262, 6-е издание, 22.1.2.1
+// Ссылка: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-array.from
+if (!Array.from) {
+  Array.from = (function() {
+    var toStr = Object.prototype.toString;
+    var isCallable = function(fn) {
+      return typeof fn === 'function' || toStr.call(fn) === '[object Function]';
+    };
+    var toInteger = function (value) {
+      var number = Number(value);
+      if (isNaN(number)) { return 0; }
+      if (number === 0 || !isFinite(number)) { return number; }
+      return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));
+    };
+    var maxSafeInteger = Math.pow(2, 53) - 1;
+    var toLength = function (value) {
+      var len = toInteger(value);
+      return Math.min(Math.max(len, 0), maxSafeInteger);
+    };
+
+    // Свойство length метода from равно 1.
+    return function from(arrayLike/*, mapFn, thisArg */) {
+      // 1. Положим C равным значению this.
+      var C = this;
+
+      // 2. Положим items равным ToObject(arrayLike).
+      var items = Object(arrayLike);
+
+      // 3. ReturnIfAbrupt(items).
+      if (arrayLike == null) {
+        throw new TypeError('Array.from requires an array-like object - not null or undefined');
+      }
+
+      // 4. Если mapfn равен undefined, положим mapping равным false.
+      var mapFn = arguments.length > 1 ? arguments[1] : void undefined;
+      var T;
+      if (typeof mapFn !== 'undefined') {
+        // 5. иначе
+        // 5. a. Если вызов IsCallable(mapfn) равен false, выкидываем исключение TypeError.
+        if (!isCallable(mapFn)) {
+          throw new TypeError('Array.from: when provided, the second argument must be a function');
+        }
+
+        // 5. b. Если thisArg присутствует, положим T равным thisArg; иначе положим T равным undefined.
+        if (arguments.length > 2) {
+          T = arguments[2];
+        }
+      }
+
+      // 10. Положим lenValue равным Get(items, "length").
+      // 11. Положим len равным ToLength(lenValue).
+      var len = toLength(items.length);
+
+      // 13. Если IsConstructor(C) равен true, то
+      // 13. a. Положим A равным результату вызова внутреннего метода [[Construct]]
+      //     объекта C со списком аргументов, содержащим единственный элемент len.
+      // 14. a. Иначе, положим A равным ArrayCreate(len).
+      var A = isCallable(C) ? Object(new C(len)) : new Array(len);
+
+      // 16. Положим k равным 0.
+      var k = 0;
+      // 17. Пока k < len, будем повторять... (шаги с a по h)
+      var kValue;
+      while (k < len) {
+        kValue = items[k];
+        if (mapFn) {
+          A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k);
+        } else {
+          A[k] = kValue;
+        }
+        k += 1;
+      }
+      // 18. Положим putStatus равным Put(A, "length", len, true).
+      A.length = len;
+      // 20. Вернём A.
+      return A;
+    };
+  }());
+}
+
+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ESDraft', '#sec-array.from', 'Array.from')}}{{Spec2('ESDraft')}}
{{SpecName('ES2015', '#sec-array.from', 'Array.from')}}{{Spec2('ES2015')}}Изначальное определение.
+ +

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

+ +
{{Compat("javascript.builtins.Array.from")}}
+ +
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/includes/index.html b/files/ru/web/javascript/reference/global_objects/array/includes/index.html new file mode 100644 index 0000000000..61bbdf1620 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/includes/index.html @@ -0,0 +1,171 @@ +--- +title: Array.prototype.includes() +slug: Web/JavaScript/Reference/Global_Objects/Array/includes +tags: + - JavaScript + - Prototype + - Reference + - polyfill + - Массив + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Array/includes +--- +
{{JSRef}}
+ +

Метод includes() определяет, содержит ли массив определённый элемент, возвращая в зависимости от этого true или false.

+ +
{{EmbedInteractiveExample("pages/js/array-includes.html")}}
+ +

Синтаксис

+ +
arr.includes(searchElement[, fromIndex = 0])
+
+ +

Параметры

+ +
+
searchElement
+
Искомый элемент.
+
fromIndex {{optional_inline}}
+
Позиция в массиве, с которой начинать поиск элемента  searchElement. При отрицательных значениях поиск производится начиная с индекса array.length + fromIndex по возрастанию. Значение по умолчанию равно 0.
+
+ +

Возвращаемое значение

+ +

{{jsxref("Boolean")}}.

+ +

Примеры

+ +
[1, 2, 3].includes(2);     // true
+[1, 2, 3].includes(4);     // false
+[1, 2, 3].includes(3, 3);  // false
+[1, 2, 3].includes(3, -1); // true
+[1, 2, NaN].includes(NaN); // true
+
+ +

fromIndex больше или равен длине массива

+ +

Если fromIndex больше или равен длине массива, то возвращается false. При этом поиск не производится.

+ +
var arr = ['a', 'b', 'c'];
+
+arr.includes('c', 3);   // false
+arr.includes('c', 100); // false
+ +

Вычисленный индекс меньше нуля 0

+ +

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

+ +
// длина массива равна 3
+// fromIndex равен -100
+// вычисленный индекс равен 3 + (-100) = -97
+
+var arr = ['a', 'b', 'c'];
+
+arr.includes('a', -100); // true
+arr.includes('b', -100); // true
+arr.includes('c', -100); // true
+ +

Использование includes() в качестве общих метода

+ +

includes() специально сделан общим. Он не требует, чтобы this являлся массивом, так что он может быть применён к другим типам объектов (например, к массивоподобным объектам). Пример ниже показывает использование метода includes() на объекте arguments.

+ +
(function() {
+  console.log([].includes.call(arguments, 'a')); // true
+  console.log([].includes.call(arguments, 'd')); // false
+})('a','b','c');
+ +

Полифилл

+ +
// https://tc39.github.io/ecma262/#sec-array.prototype.includes
+if (!Array.prototype.includes) {
+  Object.defineProperty(Array.prototype, 'includes', {
+    value: function(searchElement, fromIndex) {
+
+      if (this == null) {
+        throw new TypeError('"this" is null or not defined');
+      }
+
+      // 1. Let O be ? ToObject(this value).
+      var o = Object(this);
+
+      // 2. Let len be ? ToLength(? Get(O, "length")).
+      var len = o.length >>> 0;
+
+      // 3. If len is 0, return false.
+      if (len === 0) {
+        return false;
+      }
+
+      // 4. Let n be ? ToInteger(fromIndex).
+      //    (If fromIndex is undefined, this step produces the value 0.)
+      var n = fromIndex | 0;
+
+      // 5. If n ≥ 0, then
+      //  a. Let k be n.
+      // 6. Else n < 0,
+      //  a. Let k be len + n.
+      //  b. If k < 0, let k be 0.
+      var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
+
+      function sameValueZero(x, y) {
+        return x === y || (typeof x === 'number' && typeof y === 'number' && isNaN(x) && isNaN(y));
+      }
+
+      // 7. Repeat, while k < len
+      while (k < len) {
+        // a. Let elementK be the result of ? Get(O, ! ToString(k)).
+        // b. If SameValueZero(searchElement, elementK) is true, return true.
+        if (sameValueZero(o[k], searchElement)) {
+          return true;
+        }
+        // c. Increase k by 1.
+        k++;
+      }
+
+      // 8. Return false
+      return false;
+    }
+  });
+}
+
+ +

Если требуется поддержка устаревших движков JavaScript, которые не поддерживают Object.defineProperty, наилучшим решением будет вообще не делать полифилл для методов Array.prototype, так как не получится сделать их неперечисляемыми.

+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
{{SpecName('ES7', '#sec-array.prototype.includes', 'Array.prototype.includes')}}{{Spec2('ES7')}}Изначальное определение.
{{SpecName('ESDraft', '#sec-array.prototype.includes', 'Array.prototype.includes')}}{{Spec2('ESDraft')}}
+ +

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

+ +
+

{{Compat("javascript.builtins.Array.includes")}}

+
+ +

См. также

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/index.html b/files/ru/web/javascript/reference/global_objects/array/index.html new file mode 100644 index 0000000000..263de030df --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/index.html @@ -0,0 +1,452 @@ +--- +title: Array +slug: Web/JavaScript/Reference/Global_Objects/Array +tags: + - Array + - JavaScript + - Reference + - Глобальные объекты +translation_of: Web/JavaScript/Reference/Global_Objects/Array +--- +
{{JSRef("Global_Objects", "Array")}}
+ +
 
+ +

Массив (Array) в JavaScript является глобальным объектом, который используется для создания массивов; которые представляют собой высокоуровневые спископодобные объекты.

+ +

Создание массива

+ +
var fruits = ['Яблоко', 'Банан'];
+
+console.log(fruits.length);
+// 2
+
+ +

Доступ к элементу массива по индексу

+ +
var first = fruits[0];
+// Яблоко
+
+var last = fruits[fruits.length - 1];
+// Банан
+
+ +

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

+ +
fruits.forEach(function(item, index, array) {
+  console.log(item, index);
+});
+// Яблоко 0
+// Банан 1
+
+ +

Добавление элемента в конец массива

+ +
var newLength = fruits.push('Апельсин');
+// ["Яблоко", "Банан", "Апельсин"]
+
+ +

Удаление последнего элемента массива

+ +
var last = fruits.pop(); // удалим Апельсин (из конца)
+// ["Яблоко", "Банан"];
+
+ +

Удаление первого элемента массива

+ +
var first = fruits.shift(); // удалим Яблоко (из начала)
+// ["Банан"];
+
+ +

Добавление элемента в начало массива

+ +
var newLength = fruits.unshift('Клубника') // добавляет в начало
+// ["Клубника", "Банан"];
+
+ +

Поиск номера элемента в массиве

+ +
fruits.push('Манго');
+// ["Клубника", "Банан", "Манго"]
+
+var pos = fruits.indexOf('Банан');
+// 1
+
+ +

Удаление элемента с определённым индексом

+ +
var removedItem = fruits.splice(pos, 1); // так можно удалить элемент
+
+// ["Клубника", "Манго"]
+ +

Удаление нескольких элементов, начиная с определённого индекса

+ +
var vegetables = ['Капуста', 'Репа', 'Редиска', 'Морковка'];
+console.log(vegetables);
+// ["Капуста", "Репа", "Редиска", "Морковка"]
+
+var pos = 1, n = 2;
+
+var removedItems = vegetables.splice(pos, n);
+// так можно удалить элементы, n определяет количество элементов для удаления,
+// начиная с позиции(pos) и далее в направлении конца массива.
+
+console.log(vegetables);
+// ["Капуста", "Морковка"] (исходный массив изменён)
+
+console.log(removedItems);
+// ["Репа", "Редиска"]
+ +

Создание копии массива

+ +
var shallowCopy = fruits.slice(); // так можно создать копию массива
+// ["Клубника", "Манго"]
+
+ +

Синтаксис

+ +
[element0, element1, ..., elementN]
+new Array(element0, element1[, ...[, elementN]])
+new Array(arrayLength)
+ +
+
elementN
+
Массив в JavaScript инициализируется с помощью переданных элементов, за исключением случая, когда в конструктор Array передаётся один аргумент и этот аргумент является числом (см. ниже). Стоит обратить внимание, что этот особый случай применяется только к JavaScript-массивам, создаваемым с помощью конструктора Array, а не к литеральным массивам, создаваемым с использованием скобочного синтаксиса.
+
arrayLength
+
Если конструктору Array передаётся единственный аргумент, являющийся целым числом в диапазоне от 0 до 232-1 (включительно), будет возвращён новый пустой JavaScript-массив, длина которого установится в это число (примечание: это означает массив, содержащий arrayLength пустых ячеек, а не ячеек со значениями undefined). Если аргументом будет любое другое число, возникнет исключение {{jsxref("Global_Objects/RangeError", "RangeError")}}.
+
+ +

Описание

+ +

Массивы являются спископодобными объектами, чьи прототипы содержат методы для операций обхода и изменения массива. Ни размер JavaScript-массива, ни типы его элементов не являются фиксированными. Поскольку размер массива может увеличиваться и уменьшаться в любое время, то нет гарантии, что массив окажется плотным. То есть, при работе с массивом может возникнуть ситуация, что элемент массива, к которому вы обратитесь, будет пустым и вернёт undefined. В целом, это удобная характеристика; но если эта особенность массива не желательна в вашем специфическом случае, вы можете рассмотреть возможность использования типизированных массивов.

+ +

Некоторые полагают, что вы не должны использовать массив в качестве ассоциативного массива. В любом случае, вместо него вы можете использовать простые {{jsxref("Global_Objects/Object", "объекты")}}, хотя у них есть и свои подводные камни. Смотрите пост Легковесные JavaScript-словари с произвольными ключами(англ.) в качестве примера.

+ +

Доступ к элементам массива

+ +

Массивы в JavaScript индексируются с нуля: первый элемент массива имеет индекс, равный 0, а индекс последнего элемента равен значению свойства массива {{jsxref("Array.length", "length")}} минус 1.

+ +
var arr = ['первый элемент', 'второй элемент', 'последний элемент'];
+console.log(arr[0]);              // напечатает 'первый элемент'
+console.log(arr[1]);              // напечатает 'второй элемент'
+console.log(arr[arr.length - 1]); // напечатает 'последний элемент'
+
+ +

Элементы массива являются свойствами, точно такими же, как, например, свойство toString, однако попытка получить элемент массива по имени его свойства приведёт к синтаксической ошибке, поскольку имя свойства не является допустимым именем JavaScript:

+ +
console.log(arr.0); // синтаксическая ошибка
+
+ +

Это не особенность массивов или их свойств. В JavaScript к свойствам, начинающимся с цифры, невозможно обратиться посредством точечной нотации; к ним можно обратиться только с помощью скобочной нотации. Например, если у вас есть объект со свойством, названным '3d', вы сможете обратиться к нему только посредством скобочной нотации. Примеры:

+ +
var years = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
+console.log(years.0);   // синтаксическая ошибка
+console.log(years[0]);  // работает как положено
+
+ +
renderer.3d.setTexture(model, 'character.png');     // синтаксическая ошибка
+renderer['3d'].setTexture(model, 'character.png');  // работает как положено
+
+ +

Обратите внимание, что во втором примере 3d заключено в кавычки: '3d'. Индексы можно заключать в кавычки (например years['2'] вместо years[2]), но в этом нет необходимости. Значение 2 в выражении years[2] будет неявно приведено к строке движком JavaScript через метод преобразования toString. Именно по этой причине ключи '2' и '02' будут ссылаться на два разных элемента в объекте years и следующий пример выведет true:

+ +
console.log(years['2'] != years['02']);
+
+ +

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

+ +
var promise = {
+  'var'  : 'text',
+  'array': [1, 2, 3, 4]
+};
+
+console.log(promise['array']);
+
+ +

Взаимосвязь свойства length с числовыми свойствами

+ +

Свойство массивов {{jsxref("Array.length", "length")}} взаимосвязано с числовыми свойствами. Некоторые встроенные методы массива (например, {{jsxref("Array.join", "join")}}, {{jsxref("Array.slice", "slice")}}, {{jsxref("Array.indexOf", "indexOf")}} и т.д.) учитывают значение свойства length при своём вызове. Другие методы (например, {{jsxref("Array.push", "push")}}, {{jsxref("Array.splice", "splice")}} и т.д.) в результате своей работы также обновляют свойство length массива.

+ +
var fruits = [];
+fruits.push('банан', 'яблоко', 'персик');
+
+console.log(fruits.length); // 3
+
+ +

При установке свойства в массиве, если свойство имеет действительный индекс и этот индекс выходит за пределы текущих границ массива, движок соответствующим образом обновит свойство {{jsxref("Array.length", "length")}}:

+ +
fruits[5] = 'манго';
+console.log(fruits[5]);             // 'манго'
+console.log(Object.keys(fruits));   // ['0', '1', '2', '5']
+console.log(fruits.length);         // 6
+
+ +

Увеличиваем свойство length

+ +
fruits.length = 10;
+console.log(Object.keys(fruits));   // ['0', '1', '2', '5']
+console.log(fruits.length);         // 10
+
+ +

Однако, уменьшение свойства {{jsxref("Array.length", "length")}} приведёт к удалению элементов.

+ +
fruits.length = 2;
+console.log(Object.keys(fruits)); // ['0', '1']
+console.log(fruits.length); // 2
+
+ +

Более подробно эта тема освещена на странице, посвящённой свойству {{jsxref("Array.length")}}.

+ +

Создание массива с использованием результата сопоставления

+ +

Результатом сопоставления регулярного выражения строке является JavaScript-массив. Этот массив имеет свойства и элементы, предоставляющие информацию о сопоставлении. Подобные массивы возвращаются методами {{jsxref("RegExp.exec")}}, {{jsxref("String.match")}} и {{jsxref("String.replace")}}. Чтобы было проще понять, откуда и какие появились свойства и элементы, посмотрите следующий пример и обратитесь к таблице ниже:

+ +
// Сопоставляется с одним символом d, за которым следует один
+// или более символов b, за которыми следует один символ d
+// Запоминаются сопоставившиеся символы b и следующий за ними символ d
+// Регистр игнорируется
+
+var myRe = /d(b+)(d)/i;
+var myArray = myRe.exec('cdbBdbsbz');
+
+ +

Свойства и элементы, возвращаемые из данного сопоставления, описаны ниже:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Свойство/ЭлементОписаниеПример
inputСвойство только для чтения, отражающее оригинальную строку, с которой сопоставлялось регулярное выражение.cdbBdbsbz
indexСвойство только для чтения, являющееся индексом (отсчёт начинается с нуля) в строке, с которого началось сопоставление.1
[0]Элемент только для чтения, определяющий последние сопоставившиеся символы.dbBd
[1], ...[n]Элементы только для чтения, определяющие сопоставившиеся подстроки, заключённые в круглые скобки, если те включены в регулярное выражение. Количество возможных подстрок не ограничено.[1]: bB
+ [2]: d
+ +

Свойства

+ +
+
{{jsxref("Array.length")}}
+
Значение свойства length конструктора массива равно 1.
+
{{jsxref("Array.prototype")}}
+
Позволяет добавлять свойства ко всем объектам массива.
+
+ +

Методы

+ +
+
{{jsxref("Array.from()")}} {{experimental_inline}}
+
Создаёт новый экземпляр Array из массивоподобного или итерируемого объекта.
+
{{jsxref("Array.isArray()")}}
+
Возвращает true, если значение является массивом, иначе возвращает false.
+
{{jsxref("Array.observe()")}} {{experimental_inline}}
+
Асинхронно наблюдает за изменениями в массиве, подобно методу {{jsxref("Object.observe()")}} для объектов. Метод предоставляет поток изменений в порядке их возникновения.
+
{{jsxref("Array.of()")}} {{experimental_inline}}
+
Создаёт новый экземпляр Array из любого количества аргументов, независимо от их количества или типа.
+
+ +

Экземпляры массива

+ +

Все экземпляры массива наследуются от {{jsxref("Array.prototype")}}. Изменения в объекте прототипа конструктора массива затронет все экземпляры Array.

+ +

Свойства

+ +
{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Properties')}}
+ +

Методы

+ +

Методы изменения

+ +
{{page('ru/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Mutator_methods')}}
+ +

Методы доступа

+ +
{{page('ru/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Accessor_methods')}}
+ +

Методы обхода

+ +
{{page('ru/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Iteration_methods')}}
+ +

Общие методы массива

+ +

Иногда хочется применить методы массива к строкам или другим массивоподобным объектам (например, к {{jsxref("Functions_and_function_scope/arguments", "аргументам", "", 1)}} функции). Делая это, вы трактуете строку как массив символов (другими словами, рассматриваете не-массив в качестве массива). Например, в порядке проверки каждого символа в переменной str на то, что он является буквой (латинского алфавита), вы пишете следущий код:

+ +
function isLetter(character) {
+  return character >= 'a' && character <= 'z';
+}
+
+if (Array.prototype.every.call(str, isLetter)) {
+  console.log("Строка '" + str + "' содержит только (латинские) буквы!");
+}
+
+ +

Эта запись довольно расточительна и в JavaScript 1.6 введён общий сокращённый вид:

+ +
if (Array.every(str, isLetter)) {
+  console.log("Строка '" + str + "' содержит только (латинские) буквы!");
+}
+
+ +

{{jsxref("Global_Objects/String", "Общие методы", "#String_generic_methods", 1)}} также доступны для объекта {{jsxref("Global_Objects/String", "String")}}.

+ +

В настоящее время они не являются частью стандартов ECMAScript (хотя в ES2015 для достижения поставленной цели можно использовать Array.from()). Следующая прослойка позволяет использовать их во всех браузерах:

+ +
// Предполагаем, что дополнения массива уже присутствуют (для них так же можно использовать polyfill'ы)
+(function() {
+  'use strict';
+
+  var i,
+    // Мы могли построить массив методов следующим образом, однако метод
+    //  getOwnPropertyNames() нельзя реализовать на JavaScript:
+    // Object.getOwnPropertyNames(Array).filter(function(methodName) {
+    //   return typeof Array[methodName] === 'function'
+    // });
+    methods = [
+      'join', 'reverse', 'sort', 'push', 'pop', 'shift', 'unshift',
+      'splice', 'concat', 'slice', 'indexOf', 'lastIndexOf',
+      'forEach', 'map', 'reduce', 'reduceRight', 'filter',
+      'some', 'every'
+    ],
+    methodCount = methods.length,
+    assignArrayGeneric = function(methodName) {
+      if (!Array[methodName]) {
+        var method = Array.prototype[methodName];
+        if (typeof method === 'function') {
+          Array[methodName] = function() {
+            return method.call.apply(method, arguments);
+          };
+        }
+      }
+    };
+
+  for (i = 0; i < methodCount; i++) {
+    assignArrayGeneric(methods[i]);
+  }
+}());
+
+ +

Примеры

+ +

Пример: создание массива

+ +

Следующий пример создаёт массив msgArray с длиной 0, присваивает значения элементам msgArray[0] и msgArray[99], что изменяет длину массива на 100.

+ +
var msgArray = [];
+msgArray[0] = 'Привет';
+msgArray[99] = 'мир';
+
+if (msgArray.length === 100) {
+  console.log('Длина равна 100.');
+}
+
+ +

Пример: создание двумерного массива

+ +

Следующий код создаёт шахматную доску в виде двумерного массива строк. Затем он перемещает пешку путём копирования символа 'p' в позиции (6,4) на позицию (4,4). Старая позиция (6,4) затирается пустым местом.

+ +
var board = [
+  ['R','N','B','Q','K','B','N','R'],
+  ['P','P','P','P','P','P','P','P'],
+  [' ',' ',' ',' ',' ',' ',' ',' '],
+  [' ',' ',' ',' ',' ',' ',' ',' '],
+  [' ',' ',' ',' ',' ',' ',' ',' '],
+  [' ',' ',' ',' ',' ',' ',' ',' '],
+  ['p','p','p','p','p','p','p','p'],
+  ['r','n','b','q','k','b','n','r'] ];
+
+console.log(board.join('\n') + '\n\n');
+
+// Двигаем королевскую пешку вперёд на две клетки
+board[4][4] = board[6][4];
+board[6][4] = ' ';
+console.log(board.join('\n'));
+
+ +

Ниже показан вывод:

+ +
R,N,B,Q,K,B,N,R
+P,P,P,P,P,P,P,P
+ , , , , , , ,
+ , , , , , , ,
+ , , , , , , ,
+ , , , , , , ,
+p,p,p,p,p,p,p,p
+r,n,b,q,k,b,n,r
+
+R,N,B,Q,K,B,N,R
+P,P,P,P,P,P,P,P
+ , , , , , , ,
+ , , , , , , ,
+ , , , ,p, , ,
+ , , , , , , ,
+p,p,p,p, ,p,p,p
+r,n,b,q,k,b,n,r
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
ECMAScript 1-е издание.СтандартИзначальное определение.
{{SpecName('ES5.1', '#sec-15.4', 'Array')}}{{Spec2('ES5.1')}}Добавлены новые методы: {{jsxref("Array.isArray")}}, {{jsxref("Array.prototype.indexOf", "indexOf")}}, {{jsxref("Array.prototype.lastIndexOf", "lastIndexOf")}}, {{jsxref("Array.prototype.every", "every")}}, {{jsxref("Array.prototype.some", "some")}}, {{jsxref("Array.prototype.forEach", "forEach")}}, {{jsxref("Array.prototype.map", "map")}}, {{jsxref("Array.prototype.filter", "filter")}}, {{jsxref("Array.prototype.reduce", "reduce")}}, {{jsxref("Array.prototype.reduceRight", "reduceRight")}}.
{{SpecName('ES2015', '#sec-array-objects', 'Array')}}{{Spec2('ES2015')}}Добавлены новые методы: {{jsxref("Array.from")}}, {{jsxref("Array.of")}}, {{jsxref("Array.prototype.find", "find")}}, {{jsxref("Array.prototype.findIndex", "findIndex")}}, {{jsxref("Array.prototype.fill", "fill")}}, {{jsxref("Array.prototype.copyWithin", "copyWithin")}}.
{{SpecName('ES7', '#sec-array-objects', 'Array')}}{{Spec2('ES7')}}Добавлен новый метод: {{jsxref("Array.prototype.includes()")}}
+ +

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

+ +

{{Compat("javascript.builtins.Array")}}

+ +
 
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/indexof/index.html b/files/ru/web/javascript/reference/global_objects/array/indexof/index.html new file mode 100644 index 0000000000..ef6820df41 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/indexof/index.html @@ -0,0 +1,175 @@ +--- +title: Array.prototype.indexOf() +slug: Web/JavaScript/Reference/Global_Objects/Array/indexOf +tags: + - Array + - JavaScript + - Method + - Prototype + - Reference + - Référence(2) + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/indexOf +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод indexOf() возвращает первый индекс, по которому данный элемент может быть найден в массиве или -1, если такого индекса нет.

+ +

Синтаксис

+ +
arr.indexOf(searchElement[, fromIndex = 0])
+ +

Параметры

+ +
+
searchElement
+
Искомый элемент в массиве.
+
fromIndex
+
Индекс, с которого начинать поиск. Если индекс больше или равен длине массива, возвращается -1, что означает, что массив даже не просматривается. Если индекс является отрицательным числом, он трактуется как смещение с конца массива. Обратите внимание: если индекс отрицателен, массив всё равно просматривается от начала к концу. Если рассчитанный индекс оказывается меньше 0, поиск ведётся по всему массиву. Значение по умолчанию равно 0, что означает, что просматривается весь массив.
+
+ +

Описание

+ +

Метод indexOf() сравнивает искомый элемент searchElement с элементами в массиве, используя строгое сравнение (тот же метод используется оператором ===, тройное равно).

+ +

Примеры

+ +

Пример: использование indexOf()

+ +

В следующем примере indexOf() используется для поиска значений в массиве.

+ +
var array = [2, 5, 9];
+array.indexOf(2);     // 0
+array.indexOf(7);     // -1
+array.indexOf(9, 2);  // 2
+array.indexOf(2, -1); // -1
+array.indexOf(2, -3); // 0
+
+ +

Пример: нахождение всех вхождений элемента

+ +

В следующем примере indexOf() используется для поиска всех индексов элемента в указанном массиве, которые с помощью {{jsxref("Array.prototype.push()", "push()")}} добавляются в другой массив.

+ +
var indices = [];
+var array = ['a', 'b', 'a', 'c', 'a', 'd'];
+var element = 'a';
+var idx = array.indexOf(element);
+while (idx != -1) {
+  indices.push(idx);
+  idx = array.indexOf(element, idx + 1);
+}
+
+console.log(indices);
+// [0, 2, 4]
+
+ +

Полифилл

+ +

Метод indexOf() был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать indexOf() в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; он предполагает, что {{jsxref("Global_Objects/TypeError", "TypeError")}} и {{jsxref("Math.abs()")}} имеют свои первоначальные значения.

+ +
// Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.14
+// Ссылка (en): http://es5.github.io/#x15.4.4.14
+// Ссылка (ru): http://es5.javascript.ru/x15.4.html#x15.4.4.14
+if (!Array.prototype.indexOf) {
+  Array.prototype.indexOf = function(searchElement, fromIndex) {
+    var k;
+
+    // 1. Положим O равным результату вызова ToObject с передачей ему
+    //    значения this в качестве аргумента.
+    if (this == null) {
+      throw new TypeError('"this" is null or not defined');
+    }
+
+    var O = Object(this);
+
+    // 2. Положим lenValue равным результату вызова внутреннего метода Get
+    //    объекта O с аргументом "length".
+    // 3. Положим len равным ToUint32(lenValue).
+    var len = O.length >>> 0;
+
+    // 4. Если len равен 0, вернём -1.
+    if (len === 0) {
+      return -1;
+    }
+
+    // 5. Если был передан аргумент fromIndex, положим n равным
+    //    ToInteger(fromIndex); иначе положим n равным 0.
+    var n = +fromIndex || 0;
+
+    if (Math.abs(n) === Infinity) {
+      n = 0;
+    }
+
+    // 6. Если n >= len, вернём -1.
+    if (n >= len) {
+      return -1;
+    }
+
+    // 7. Если n >= 0, положим k равным n.
+    // 8. Иначе, n<0, положим k равным len - abs(n).
+    //    Если k меньше нуля 0, положим k равным 0.
+    k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
+
+    // 9. Пока k < len, будем повторять
+    while (k < len) {
+      // a. Положим Pk равным ToString(k).
+      //   Это неявное преобразование для левостороннего операнда в операторе in
+      // b. Положим kPresent равным результату вызова внутреннего метода
+      //    HasProperty объекта O с аргументом Pk.
+      //   Этот шаг может быть объединён с шагом c
+      // c. Если kPresent равен true, выполним
+      //    i.  Положим elementK равным результату вызова внутреннего метода Get
+      //        объекта O с аргументом ToString(k).
+      //   ii.  Положим same равным результату применения
+      //        Алгоритма строгого сравнения на равенство между
+      //        searchElement и elementK.
+      //  iii.  Если same равен true, вернём k.
+      if (k in O && O[k] === searchElement) {
+        return k;
+      }
+      k++;
+    }
+    return -1;
+  };
+}
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES5.1', '#sec-15.4.4.14', 'Array.prototype.indexOf')}}{{Spec2('ES5.1')}}Изначальное определение. Реализована в JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.indexof', 'Array.prototype.indexOf')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-array.prototype.indexof', 'Array.prototype.indexOf')}}{{Spec2('ESDraft')}} 
+ +

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

+ +

{{Compat("javascript.builtins.Array.indexOf")}}

+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/isarray/index.html b/files/ru/web/javascript/reference/global_objects/array/isarray/index.html new file mode 100644 index 0000000000..a9599389e8 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/isarray/index.html @@ -0,0 +1,120 @@ +--- +title: Array.isArray() +slug: Web/JavaScript/Reference/Global_Objects/Array/isArray +tags: + - Array + - ECMAScript5 + - JavaScript + - Method + - Reference + - Référence(2) + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/isArray +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод Array.isArray() возвращает true, если объект является массивом и false, если он массивом не является.

+ +

Синтаксис

+ +
Array.isArray(obj)
+ +

Параметры

+ +
+
obj
+
Объект для проверки.
+
+ +

Возвращаемое значение

+ +

true если объект является {{jsxref("Array")}}; иначе, false.

+ +

Описание

+ +

За подробностям обращайтесь к статье «Абсолютно точное определение того, является ли JavaScript-объект массивом или нет».

+ +

Примеры

+ +
// Все следующие вызовы вернут true
+Array.isArray([]);
+Array.isArray([1]);
+Array.isArray(new Array());
+// Малоизвестный факт: Array.prototype сам является массивом:
+Array.isArray(Array.prototype);
+
+// Все следующие вызовы вернут false
+Array.isArray();
+Array.isArray({});
+Array.isArray(null);
+Array.isArray(undefined);
+Array.isArray(17);
+Array.isArray("Array");
+Array.isArray(true);
+Array.isArray(false);
+Array.isArray({ __proto__: Array.prototype });
+
+ +

instanceof vs isArray

+ +

Когда проверяем экземпляр Array, Array.isArray предпочтительней, чем instanceof, потому что он работает и с iframes.

+ +
var iframe = document.createElement('iframe');
+document.body.appendChild(iframe);
+xArray = window.frames[window.frames.length-1].Array;
+var arr = new xArray(1,2,3); // [1,2,3]
+
+// Correctly checking for Array
+Array.isArray(arr);  // true
+// Considered harmful, because doesn't work through iframes
+arr instanceof Array; // false
+
+ +

Полифилл

+ +

Выполнение следующего кода перед любым другим кодом создаст метод Array.isArray(), если он ещё не реализован в браузере.

+ +
if (!Array.isArray) {
+  Array.isArray = function(arg) {
+    return Object.prototype.toString.call(arg) === '[object Array]';
+  };
+}
+
+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES5.1', '#sec-15.4.3.2', 'Array.isArray')}}{{Spec2('ES5.1')}}Изначальное определение. Реализована в JavaScript 1.8.5.
{{SpecName('ES6', '#sec-array.isarray', 'Array.isArray')}}{{Spec2('ES6')}} 
+ +

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

+ +
+ + +

{{Compat("javascript.builtins.Array.isArray")}}

+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/join/index.html b/files/ru/web/javascript/reference/global_objects/array/join/index.html new file mode 100644 index 0000000000..28ae457276 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/join/index.html @@ -0,0 +1,110 @@ +--- +title: Array.prototype.join() +slug: Web/JavaScript/Reference/Global_Objects/Array/join +tags: + - Array + - JavaScript + - Method + - Prototype + - Reference + - Массив + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Array/join +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод join() объединяет все элементы массива (или массивоподобного объекта) в строку.

+ +

{{EmbedInteractiveExample("pages/js/array-join.html")}}

+ +

Синтаксис

+ +
arr.join([separator])
+ +

Параметры

+ +
+
separator {{optional_inline}}
+
Определяет строку, разделяющую элементы массива. В случае необходимости тип разделителя приводится к типу Строка. Если он не задан, элементы массива разделяются запятой ','. Если разделитель - пустая строка, элементы массива ничем не разделяются в возвращаемой строке.
+
+ +

Возвращаемое значение

+ +

Строка, содержащая все элементы массива. Если arr.length == 0,  то будет возвращена пустая строка.

+ +

Описание

+ +

Преобразует все элементы массива в строки и объединяет их в одну большую строку. Элемент массива с типом undefined или null преобразуется в пустую строку.

+ +

Примеры

+ +

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

+ +

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

+ +
var a = ['Ветер', 'Дождь', 'Огонь'];
+var myVar1 = a.join();      // присвоит 'Ветер,Дождь,Огонь' переменной myVar1
+var myVar2 = a.join(', ');  // присвоит 'Ветер, Дождь, Огонь' переменной myVar2
+var myVar3 = a.join(' + '); // присвоит 'Ветер + Дождь + Огонь' переменной myVar3
+var myVar4 = a.join('');    // присвоит 'ВетерДождьОгонь' переменной myVar4
+
+ +

Соединение элементов массивоподобного объекта

+ +

В следующем примере соединяется массивоподобный объект (в данном случае список аргументов функции) с использованием вызова {{jsxref("Function.prototype.call")}} для Array.prototype.join.

+ +
function f(a, b, c) {
+  var s = Array.prototype.join.call(arguments);
+  console.log(s); // '1,a,true'
+}
+f(1, 'a', true);
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES1')}}{{Spec2('ES1')}}Изначальное определение. Реализована в JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.4.4.5', 'Array.prototype.join')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-array.prototype.join', 'Array.prototype.join')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-array.prototype.join', 'Array.prototype.join')}}{{Spec2('ESDraft')}} 
+ +

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

+ +
+ + +

{{Compat("javascript.builtins.Array.join")}}

+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/keys/index.html b/files/ru/web/javascript/reference/global_objects/array/keys/index.html new file mode 100644 index 0000000000..94cc84dd43 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/keys/index.html @@ -0,0 +1,90 @@ +--- +title: Array.prototype.keys() +slug: Web/JavaScript/Reference/Global_Objects/Array/keys +tags: + - Array + - ECMAScript6 + - Experimental + - Expérimental(2) + - Iterator + - JavaScript + - Method + - Prototype + - Reference + - Référence(2) +translation_of: Web/JavaScript/Reference/Global_Objects/Array/keys +--- +
{{JSRef}}
+ + + +

Метод keys() возвращает новый итератор массива Array Iterator, содержащий ключи каждого индекса в массиве.

+ +
{{EmbedInteractiveExample("pages/js/array-keys.html")}}
+ + + +

Синтаксис

+ +
arr.keys()
+ +

Примеры

+ +

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

+ +
var arr = ['a', 'b', 'c'];
+var iterator = arr.keys();
+
+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 }
+
+ +

Пример: итератор, возвращаемый методом keys(), не пропускает дырки в массиве

+ +
var arr = ['a', , 'c'];
+var sparseKeys = Object.keys(arr);
+var denseKeys = [...arr.keys()];
+console.log(sparseKeys); // [0, 2]
+console.log(denseKeys);  // [0, 1, 2]
+
+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES2015', '#sec-array.prototype.keys', 'Array.prototype.keys')}}{{Spec2('ES2015')}}Изначальное определение.
{{SpecName('ESDraft', '#sec-array.prototype.keys', 'Array.prototype.keys')}}{{Spec2('ESDraft')}} 
+ + +

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

+ +
+ + +

{{Compat("javascript.builtins.Array.keys")}}

+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/lastindexof/index.html b/files/ru/web/javascript/reference/global_objects/array/lastindexof/index.html new file mode 100644 index 0000000000..d5125cd9e9 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/lastindexof/index.html @@ -0,0 +1,167 @@ +--- +title: Array.prototype.lastIndexOf() +slug: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf +tags: + - Array + - ECMAScript5 + - JavaScript + - Method + - Prototype + - Reference + - Référence(2) + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf +--- +
{{JSRef}}
+ +

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

+ +
{{EmbedInteractiveExample("pages/js/array-lastindexof.html")}}
+ + +

Синтаксис

+ +
arr.lastIndexOf(searchElement[, fromIndex = arr.length])
+ +

Параметры

+ +
+
searchElement
+
Искомый элемент в массиве.
+
fromIndex
+
Необязательный параметр. Индекс, с которого начинать поиск в обратном направлении. Если индекс больше или равен длине массива, просматривается весь массив. Если индекс является отрицательным числом, он трактуется как смещение с конца массива. Обратите внимание: если индекс отрицателен, массив всё равно просматривается от конца к началу. Если рассчитанный индекс оказывается меньше 0, массив даже не просматривается. Значение по умолчанию равно длине массива, что означает, что просматривается весь массив.
+
+ +

Описание

+ +

Метод lastIndexOf() сравнивает искомый элемент searchElement с элементами в массиве, используя строгое сравнение (тот же метод используется оператором ===, тройное равно).

+ +

Примеры

+ +

Пример: использование lastIndexOf()

+ +

В следующем примере метод lastIndexOf() используется для поиска значений в массиве.

+ +
var array = [2, 5, 9, 2];
+array.lastIndexOf(2);     // 3
+array.lastIndexOf(7);     // -1
+array.lastIndexOf(2, 3);  // 3
+array.lastIndexOf(2, 2);  // 0
+array.lastIndexOf(2, -2); // 0
+array.lastIndexOf(2, -1); // 3
+
+ +

Пример: нахождение всех вхождений элемента

+ +

В следующем примере метод lastIndexOf() используется для поиска всех индексов элемента в указанном массиве, которые с помощью метода {{jsxref("Array.prototype.push()", "push()")}} добавляются в другой массив.

+ +
var indices = [];
+var array = ['a', 'b', 'a', 'c', 'a', 'd'];
+var element = 'a';
+var idx = array.lastIndexOf(element);
+while (idx != -1) {
+  indices.push(idx);
+  idx = (idx > 0 ? array.lastIndexOf(element, idx - 1) : -1);
+}
+
+console.log(indices);
+// [4, 2, 0]
+
+ +

Обратите внимание, что мы обрабатываем случай idx == 0 отдельно, поскольку элемент всегда будет найден, независимо от параметра fromIndex, если он является первым элементом в массиве. Этим он отличается от метода {{jsxref("Array.prototype.indexOf()", "indexOf()")}}.

+ +

Полифилл

+ +

Метод lastIndexOf() был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать lastIndexOf() в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; он предполагает, что {{jsxref("Global_Objects/Object", "Object")}}, {{jsxref("Global_Objects/TypeError", "TypeError")}}, {{jsxref("Global_Objects/Number", "Number")}}, {{jsxref("Math.floor()")}}, {{jsxref("Math.abs()")}} и {{jsxref("Math.min()")}} имеют свои первоначальные значения.

+ +
// Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.15
+// Ссылка (en): http://es5.github.io/#x15.4.4.15
+// Ссылка (ru): http://es5.javascript.ru/x15.4.html#x15.4.4.15
+if (!Array.prototype.lastIndexOf) {
+  Array.prototype.lastIndexOf = function(searchElement/*, fromIndex*/) {
+    'use strict';
+
+    if (this === void 0 || this === null) {
+      throw new TypeError();
+    }
+
+    var n, k,
+        t = Object(this),
+        len = t.length >>> 0;
+    if (len === 0) {
+      return -1;
+    }
+
+    n = len - 1;
+    if (arguments.length > 1) {
+      n = Number(arguments[1]);
+      if (n != n) {
+        n = 0;
+      }
+      else if (n != 0 && n != (1 / 0) && n != -(1 / 0)) {
+        n = (n > 0 || -1) * Math.floor(Math.abs(n));
+      }
+    }
+
+    for (k = n >= 0 ? Math.min(n, len - 1) : len - Math.abs(n); k >= 0; k--) {
+      if (k in t && t[k] === searchElement) {
+        return k;
+      }
+    }
+    return -1;
+  };
+}
+
+ +

И снова обратите внимание, что данная реализация нацелена на абсолютную совместимость с методом lastIndexOf(), реализованным в Firefox и движке JavaScript SpiderMonkey, включая несколько случаев, которые являются спорными крайними случаями. Если вы используете этот код в реальных приложениях, вы можете вычислять параметр from менее сложным образом, игнорируя эти случаи.

+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES5.1', '#sec-15.4.4.15', 'Array.prototype.lastIndexOf')}}{{Spec2('ES5.1')}}Изначальное определение. Реализована в JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.lastindexof', 'Array.prototype.lastIndexOf')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-array.prototype.lastindexof', 'Array.prototype.lastIndexOf')}}{{Spec2('ESDraft')}} 
+ +

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

+ +
+ + +

{{Compat("javascript.builtins.Array.lastIndexOf")}}

+
+ +

Замечания по совместимости

+ + + +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/length/index.html b/files/ru/web/javascript/reference/global_objects/array/length/index.html new file mode 100644 index 0000000000..402e1005a4 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/length/index.html @@ -0,0 +1,146 @@ +--- +title: Array.length +slug: Web/JavaScript/Reference/Global_Objects/Array/length +tags: + - Array + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Array/length +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Cвойство length объекта, который является экземпляром типа Array , устанавливает или возвращает число элементов этого массива. Значение данного свойства 32-битное безнаковое целое число, которое всегда численно больше чем самый наибольший индекс в массиве.

+ +
var items = ['shoes', 'shirts', 'socks', 'sweaters'];
+items.length;
+
+// возвращает 4
+ +

Синтаксис

+ +
arr.length
+ +

Описание

+ +

Свойство length является целым числом с положительным знаком и значением, меньшим чем 2 в степени 32 (232).

+ +
var namelistA = new Array(4294967296); //2 в 32 степени = 4294967296
+var namelistC = new Array(-100) //отрицательная величина
+
+console.log(namelistA.length); //RangeError: Invalid array length
+console.log(namelistC.length); //RangeError: Invalid array length
+
+
+
+var namelistB = [];
+namelistB.length = Math.pow(2,32)-1; //устанавливает длину массива меньше 2 в 32 степени
+console.log(namelistB.length);
+
+//4294967295
+
+ +

В любой момент вы можете установить свойство length для обрезки массива. Когда вы расширяете массив, изменяя его свойство length, реальное количество элементов в массиве увеличивается; например, если вы установите свойство length в 3, когда оно равно 2, массив будет из 3 элементов, где значение третьего элемента будет равно undefined .

+ +
var arr = [1, 2, 3];
+printEntries(arr);
+
+arr.length = 5; // устанавливает длину массива 5.
+printEntries(arr);
+
+function printEntries(arr) {
+  var goNext = true;
+  var entries = arr.entries();
+  while (goNext) {
+    var result = entries.next();
+    if (result.done !== true) {
+      console.log(result.value[1]);
+      goNext = true;
+    } else
+      goNext = false;
+  }
+  console.log('=== printed ===');
+}
+
+// 1
+// 2
+// 3
+// === printed ===
+// 1
+// 2
+// 3
+// undefined
+// undefined
+// === printed ===
+ +

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

+ +

{{js_property_attributes(1, 0, 0)}}

+ +

Примеры

+ +

Пример: итерирование по массиву

+ +

В следующем примере массив numbers итерируется до значения свойства length, показывающего, сколько элементов содержит массив. Значение каждого элемента удваивается.

+ +
var numbers = [1, 2, 3, 4, 5];
+
+for (var i = 0; i < numbers.length; i++) {
+  numbers[i] *= 2;
+}
+// Массив numbers теперь равен [2, 4, 6, 8, 10];
+
+ +

Пример: сокращение массива

+ +

Следующий пример сокращает массив statesUS до длины в 50 элементов, если текущая длина массива больше 50.

+ +
if (statesUS.length > 50) {
+  statesUS.length = 50;
+}
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
ECMAScript 1-е издание.СтандартИзначальное определение.
{{SpecName('ES5.1', '#sec-15.4.5.2', 'Array.length')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-properties-of-array-instances-length', 'Array.length')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-properties-of-array-instances-length', 'Array.length')}}{{Spec2('ESDraft')}}    
+ +

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

+ +
+

{{Compat("javascript.builtins.Array.length")}}

+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/map/index.html b/files/ru/web/javascript/reference/global_objects/array/map/index.html new file mode 100644 index 0000000000..95e63de892 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/map/index.html @@ -0,0 +1,284 @@ +--- +title: Array.prototype.map() +slug: Web/JavaScript/Reference/Global_Objects/Array/map +tags: + - Array + - ECMAScript5 + - JavaScript + - JavaScript 1.6 + - Method + - Prototype + - Reference + - Référence(2) + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/map +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод map() создаёт новый массив с результатом вызова указанной функции для каждого элемента массива.

+ +

Синтаксис

+ +
let new_array = arr.map(function callback( currentValue[, index[, array]]) {
+    // Возвращает элемент для new_array
+}[, thisArg])
+ +

Параметры

+ +
+
callback
+
+

Функция, вызываемая для каждого элемента массива arr. Каждый раз, когда callback выполняется, возвращаемое значение добавляется в new_array.

+ +

Функция callback, создающая элемент в новом массиве, принимает три аргумента:

+ +
+
currentValue
+
Текущий обрабатываемый элемент массива.
+
index{{optional_inline}}
+
Индекс текущего обрабатываемого элемента в массиве.
+
array{{optional_inline}}
+
Массив, по которому осуществляется проход.
+
+
+
thisArg{{optional_inline}}
+
Необязательный параметр. Значение, используемое в качестве this при вызове функции callback
+
+ +

Возвращаемое значение

+ +

Новый массив, где каждый элемент является результатом callback функции.

+ +

Описание

+ +

Метод map вызывает переданную функцию callback один раз для каждого элемента, в порядке их появления и конструирует новый массив из результатов её вызова. Функция callback вызывается только для индексов массива, имеющих присвоенные значения, включая {{jsxref("Global_Objects/undefined", "undefined")}}. Она не вызывается для пропущенных элементов массива (то есть для индексов, которые никогда не были заданы, которые были удалены или которым никогда не было присвоено значение.

+ +

Функция callback вызывается с тремя аргументами: значением элемента, индексом элемента и массивом, по которому осуществляется проход.

+ +

Если в метод map был передан параметр thisArg, при вызове callback он будет использоваться в качестве значения this. В противном случае в качестве значения this будет использоваться значение {{jsxref("Global_Objects/undefined", "undefined")}}. В конечном итоге, значение this, наблюдаемое из функции callback, определяется согласно обычным правилам определения this, видимого из функции.

+ +

Метод map не изменяет массив, для которого он был вызван (хотя функция callback может это делать).

+ +

Диапазон элементов, обрабатываемых методом map, устанавливается до первого вызова функции callback. Элементы, добавленные в массив после начала выполнения метода map, не будут посещены функцией callback. Если существующие элементы массива изменяются функцией callback, их значения, переданные в функцию, будут значениями на тот момент времени, когда метод map посетит их; удалённые элементы посещены не будут.

+ +

Примеры

+ +

Пример: отображение массива чисел на массив квадратных корней

+ +

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

+ +
var numbers = [1, 4, 9];
+var roots = numbers.map(Math.sqrt);
+// теперь roots равен [1, 2, 3], а numbers всё ещё равен [1, 4, 9]
+
+ +

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

+ +

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

+ +
var numbers = [1, 4, 9];
+var doubles = numbers.map(function(num) {
+  return num * 2;
+});
+// теперь doubles равен [2, 8, 18], а numbers всё ещё равен [1, 4, 9]
+
+ +

Пример: обобщённое использование map

+ +

Этот пример показывает, как использовать map на объекте строки {{jsxref("Global_Objects/String", "String")}} для получения массива байт в кодировке ASCII, представляющего значения символов:

+ +
var map = Array.prototype.map;
+var a = map.call('Hello World', function(x) { return x.charCodeAt(0); });
+// теперь a равен [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
+
+ +

Пример: обобщённое использование map вместе с querySelectorAll

+ +

Этот пример показывает, как пройтись по коллекции объектов, собранных с помощью querySelectorAll. В данном случае мы получаем все выбранные опции на экране и печатаем их в консоль:

+ +
var elems = document.querySelectorAll('select option:checked');
+var values = [].map.call(elems, function(obj) {
+  return obj.value;
+});
+
+ +

Более простым способом будет использование метода {{jsxref("Array.from()")}}.

+ +

Пример: использование map для переворачивания строки

+ +
var str = '12345';
+[].map.call(str, function(x) {
+  return x;
+}).reverse().join('');
+
+// Вывод: '54321'
+// Бонус: используйте '===' для проверки того, является ли строка палиндромом
+
+ +

Более простым способом будет использование метода {{jsxref("String.split()")}} (см. пример обращение строки при помощи метода split()).

+ +

Пример: хитрый вариант использования

+ +

(навеяно этой записью в блоге)

+ +

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

+ +
// Рассмотрим пример:
+['1', '2', '3'].map(parseInt);
+// Хотя ожидаемый результат вызова равен [1, 2, 3],
+// в действительности получаем [1, NaN, NaN]
+
+// Функция parseInt часто используется с одним аргументом, но она принимает два.
+// Первый аргумент является выражением, а второй - основанием системы счисления.
+// В функцию callback Array.prototype.map передаёт 3 аргумента:
+// элемент, его индекс и сам массив.
+// Третий аргумент игнорируется parseInt, но не второй, следовательно,
+// возможна путаница. Смотрите запись в блоге для дополнительной информации.
+
+function returnInt(element) {
+  return parseInt(element, 10);
+}
+
+['1', '2', '3'].map(returnInt);
+// Результатом является массив чисел (как и ожидалось)
+
+// Простейший способ добиться вышеозначенного поведения и избежать чувства "чё за!?":
+['1', '2', '3'].map(Number); // [1, 2, 3]
+
+ +

Полифилл

+ +

Метод map был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать map в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; он предполагает, что {{jsxref("Global_Objects/Object", "Object")}}, {{jsxref("Global_Objects/TypeError", "TypeError")}} и {{jsxref("Global_Objects/Array", "Array")}} имеют свои первоначальные значения и что callback.call вычисляется в оригинальное значение {{jsxref("Function.prototype.call")}}.

+ +
// Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.19
+// Ссылка (en): http://es5.github.com/#x15.4.4.19
+// Ссылка (ru): http://es5.javascript.ru/x15.4.html#x15.4.4.19
+if (!Array.prototype.map) {
+
+  Array.prototype.map = function(callback, thisArg) {
+
+    var T, A, k;
+
+    if (this == null) {
+      throw new TypeError(' this is null or not defined');
+    }
+
+    // 1. Положим O равным результату вызова ToObject с передачей ему
+    //    значения |this| в качестве аргумента.
+    var O = Object(this);
+
+    // 2. Положим lenValue равным результату вызова внутреннего метода Get
+    //    объекта O с аргументом "length".
+    // 3. Положим len равным ToUint32(lenValue).
+    var len = O.length >>> 0;
+
+    // 4. Если вызов IsCallable(callback) равен false, выкидываем исключение TypeError.
+    // Смотрите (en): http://es5.github.com/#x9.11
+    // Смотрите (ru): http://es5.javascript.ru/x9.html#x9.11
+    if (typeof callback !== 'function') {
+      throw new TypeError(callback + ' is not a function');
+    }
+
+    // 5. Если thisArg присутствует, положим T равным thisArg; иначе положим T равным undefined.
+    if (arguments.length > 1) {
+      T = thisArg;
+    }
+
+    // 6. Положим A равным новому масиву, как если бы он был создан выражением new Array(len),
+    //    где Array является стандартным встроенным конструктором с этим именем,
+    //    а len является значением len.
+    A = new Array(len);
+
+    // 7. Положим k равным 0
+    k = 0;
+
+    // 8. Пока k < len, будем повторять
+    while (k < len) {
+
+      var kValue, mappedValue;
+
+      // a. Положим Pk равным ToString(k).
+      //   Это неявное преобразование для левостороннего операнда в операторе in
+      // b. Положим kPresent равным результату вызова внутреннего метода HasProperty
+      //    объекта O с аргументом Pk.
+      //   Этот шаг может быть объединён с шагом c
+      // c. Если kPresent равен true, то
+      if (k in O) {
+
+        // i. Положим kValue равным результату вызова внутреннего метода Get
+        //    объекта O с аргументом Pk.
+        kValue = O[k];
+
+        // ii. Положим mappedValue равным результату вызова внутреннего метода Call
+        //     функции callback со значением T в качестве значения this и списком
+        //     аргументов, содержащим kValue, k и O.
+        mappedValue = callback.call(T, kValue, k, O);
+
+        // iii. Вызовем внутренний метод DefineOwnProperty объекта A с аргументами
+        // Pk, Описатель Свойства
+        // { Value: mappedValue,
+        //   Writable: true,
+        //   Enumerable: true,
+        //   Configurable: true }
+        // и false.
+
+        // В браузерах, поддерживающих Object.defineProperty, используем следующий код:
+        // Object.defineProperty(A, k, {
+        //   value: mappedValue,
+        //   writable: true,
+        //   enumerable: true,
+        //   configurable: true
+        // });
+
+        // Для лучшей поддержки браузерами, используем следующий код:
+        A[k] = mappedValue;
+      }
+      // d. Увеличим k на 1.
+      k++;
+    }
+
+    // 9. Вернём A.
+    return A;
+  };
+}
+
+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES5.1', '#sec-15.4.4.19', 'Array.prototype.map')}}{{Spec2('ES5.1')}}Изначальное определение. Реализована в JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.map', 'Array.prototype.map')}}{{Spec2('ES6')}}
+ +

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

+ +
+ + +

{{Compat("javascript.builtins.Array.map")}}

+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/observe/index.html b/files/ru/web/javascript/reference/global_objects/array/observe/index.html new file mode 100644 index 0000000000..f8d7d9cd07 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/observe/index.html @@ -0,0 +1,138 @@ +--- +title: Array.observe() +slug: Web/JavaScript/Reference/Global_Objects/Array/observe +tags: + - Array + - ECMAScript7 + - Experimental + - Expérimental(2) + - JavaScript + - Method + - Reference + - Référence(2) +translation_of: Archive/Web/JavaScript/Array.observe +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод Array.observe() используется для асинхронного обзора изменений в массивах, подобно тому, как метод {{jsxref("Object.observe()")}} используется для тех же целей для объектов. Он предоставляет поток изменений в порядке их возникновения.

+ +

Синтаксис

+ +
Array.observe(arr, callback)
+ +

Параметры

+ +
+
arr
+
Обозреваемый массив.
+
callback
+
Функция, вызываемая на каждое сделанное изменение со следующими аргументами: +
+
changes
+
Массив объектов, каждый из которых представляет одно изменение. Эти объекты обладают следующими свойствами: +
    +
  • name: название изменённого свойства.
    • +
  • object: изменённый массив, после применения этого изменения.
    • +
  • type: строка, указывающая тип произошедшего изменения. Может быть одной из "add", "update", "delete" или "splice".
    • +
  • oldValue: только для типов "update" и "delete". Значение до изменения.
    • +
  • index: только для типа "splice". Индекс, по которому произошло изменение.
    • +
  • removed: только для типа "splice". Массив с удалёнными элементами.
    • +
  • addedCount: только для типа "splice". Количество добавленных элементов.
    • +
+
+
+
+
+ +

Описание

+ +

Функция callback вызывается каждый раз, когда с массивом arr происходят какие-либо изменения. Параметром в неё передаётся массив со всеми произошедшими изменениями в порядке их возникновения.

+ +
+

Изменения через методы объекта {{jsxref("Array")}}, например, посредством метода {{jsxref("Array.prototype.pop()")}}, будут зарегистрированы как изменения типа "splice". Присваивание по индексу, в результате которого размер массива не изменится, может быть зарегистрировано, как изменение типа "update".

+
+ +

Примеры

+ +

Пример: журналирование всех трёх типов событий

+ +
var arr = ['a', 'b', 'c'];
+
+Array.observe(arr, function(changes) {
+  console.log(changes);
+});
+
+arr[1] = 'B';
+// [{type: 'update', object: <arr>, name: '1', oldValue: 'b'}]
+
+arr[3] = 'd';
+// [{type: 'splice', object: <arr>, index: 3, removed: [], addedCount: 1}]
+
+arr.splice(1, 2, 'beta', 'gamma', 'delta');
+// [{type: 'splice', object: <arr>, index: 1, removed: ['B', 'c', 'd'], addedCount: 3}]
+
+ +

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

+ +

Черновое предложение к обсуждению для ECMAScript 7.

+ +

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

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

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/of/index.html b/files/ru/web/javascript/reference/global_objects/array/of/index.html new file mode 100644 index 0000000000..3f798e0516 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/of/index.html @@ -0,0 +1,99 @@ +--- +title: Array.of() +slug: Web/JavaScript/Reference/Global_Objects/Array/of +tags: + - Array + - ECMAScript6 + - Experimental + - JavaScript + - Method + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/of +--- +
{{JSRef}}
+ +

Метод Array.of() создаёт новый экземпляр массива Array из произвольного числа аргументов, вне зависимости от числа или типа аргумента.

+ +

Разница между Array.of() и конструктором Array заключается в обработке целочисленных аргументов: Array.of(7) создаёт массив с одним элементом 7, а Array(7) создаёт пустой массив со значением свойства length равным 7 (Замечание: подразумевается 7 пустых слотов, а не слоты со значением undefined).

+ +
Array.of(7);       // [7]
+Array.of(1, 2, 3); // [1, 2, 3]
+
+Array(7);          // массив с 7 пустыми слотами
+Array(1, 2, 3);    // [1, 2, 3]
+ +

Синтаксис

+ +
Array.of(element0[, element1[, ...[, elementN]]])
+ +

Параметры

+ +
+
elementN
+
Элементы, из которых создаётся массив.
+
+ +

Возвращаемое значение

+ +

Новый массив {{jsxref("Array")}}.

+ +

Описание

+ +

Эта функция является частью стандарта ECMAScript 6. Для дополнительной информации смотрите предложение по Array.of и Array.from и полифилл для Array.of.

+ +

Примеры

+ +
Array.of(1);         // [1]
+Array.of(1, 2, 3);   // [1, 2, 3]
+Array.of(undefined); // [undefined]
+
+ +

Полифилл

+ +

Выполнение следующего кода перед любым другим кодом создаст метод Array.of(), если он ещё не реализован в браузере.

+ +
if (!Array.of) {
+  Array.of = function() {
+    return Array.prototype.slice.call(arguments);
+    // Or
+    let vals = []
+    for(let prop in arguments){
+        vals.push(arguments[prop])
+    }
+    return vals.slice()
+}
+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES6', '#sec-array.of', 'Array.of')}}{{Spec2('ES6')}}Изначальное определение.
{{SpecName('ESDraft', '#sec-array.of', 'Array.of')}}{{Spec2('ESDraft')}}
+ +

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

+ +
{{Compat("javascript.builtins.Array.of")}}
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/pop/index.html b/files/ru/web/javascript/reference/global_objects/array/pop/index.html new file mode 100644 index 0000000000..0f6ba275f0 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/pop/index.html @@ -0,0 +1,99 @@ +--- +title: Array.prototype.pop() +slug: Web/JavaScript/Reference/Global_Objects/Array/pop +tags: + - Array + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/pop +--- +
{{JSRef}}
+ +

Сводка

+ +

Метод pop() удаляет последний элемент из массива и возвращает его значение.

+ +

Синтаксис

+ +
arr.pop()
+ +

Возвращаемое значение

+ +

Последний элемент массива или {{jsxref("undefined")}}, если массив пуст.

+ +

Описание

+ +

Метод pop удаляет последний элемент из массива и возвращает удалённое значение.

+ +

Метод pop не является привязанным к типу; этот метод может быть {{jsxref("Function.call", "вызван", "", 1)}} или {{jsxref("Function.apply", "применён", "", 1)}} к массивоподобным объектам. Объекты, не содержащие свойство length, отражающее последний элемент в серии последовательных числовых, начинающихся с нуля, свойств, могут повести себя неправильным образом.

+ +

Если вы вызовете pop() на пустом массиве, он вернёт значение {{jsxref("undefined")}}.

+ +

Примеры

+ +

Удаление последнего элемента массива

+ +

Следующий код создаёт массив myFish, содержащий четыре элемента, а затем удаляет последний элемент.

+ +
var myFish = ['ангел', 'клоун', 'мандарин', 'хирург'];
+
+console.log(myFish); // ['ангел', 'клоун', 'мандарин', 'хирург']
+
+var popped = myFish.pop();
+
+console.log(myFish); // ['ангел', 'клоун', 'мандарин']
+
+console.log(popped); // 'хирург'
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES3')}}{{Spec2('ES3')}}Изначальное определение. Реализована в JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.4.4.6', 'Array.prototype.pop')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-array.prototype.pop', 'Array.prototype.pop')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-array.prototype.pop', 'Array.prototype.pop')}}{{Spec2('ESDraft')}}
+ +

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

+ +
+
+ + +

{{Compat("javascript.builtins.Array.pop")}}

+
+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/prototype/index.html b/files/ru/web/javascript/reference/global_objects/array/prototype/index.html new file mode 100644 index 0000000000..4d04fc0736 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/prototype/index.html @@ -0,0 +1,171 @@ +--- +title: Array.prototype +slug: Web/JavaScript/Reference/Global_Objects/Array/prototype +tags: + - Array + - JavaScript + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array/prototype +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Свойство Array.prototype представляет прототип для конструктора {{jsxref("Global_Objects/Array", "Array", "массива")}}.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Описание

+ +

Экземпляры Array наследуются от Array.prototype. Как и с остальными конструкторами, вы можете изменять прототип конструктора объекта для применения изменений ко всем экземплярам класса Array.

+ +

Небольшой факт: Array.prototype сам является экземпляром Array:

+ +
Array.isArray(Array.prototype); // true
+ +

Свойства

+ +
+
Array.prototype.constructor
+
Определяет функцию, создающую прототип объекта.
+
{{jsxref("Array.prototype.length")}}
+
Отражает количество элементов в массиве.
+
+ +

Методы

+ +

Методы изменения

+ +

Эти методы изменяют массив:

+ +
+
{{jsxref("Array.prototype.copyWithin()")}} {{experimental_inline}}
+
Копирует последовательность элементов массива внутри массива.
+
{{jsxref("Array.prototype.fill()")}} {{experimental_inline}}
+
Заполняет все элементы массива от начального индекса до конечного индекса указанным значением.
+
{{jsxref("Array.prototype.pop()")}}
+
Удаляет последний элемент из массива и возвращает его.
+
{{jsxref("Array.prototype.push()")}}
+
Добавляет один или более элементов в конец массива и возвращает новую длину массива.
+
{{jsxref("Array.prototype.reverse()")}}
+
Переворачивает порядок элементов в массиве — первый элемент становится последним, а последний — первым.
+
{{jsxref("Array.prototype.shift()")}}
+
Удаляет первый элемент из массива и возвращает его.
+
{{jsxref("Array.prototype.sort()")}}
+
Сортирует элементы массива на месте и возвращает отсортированный массив.
+
{{jsxref("Array.prototype.splice()")}}
+
Добавляет и/или удаляет элементы из массива.
+
{{jsxref("Array.prototype.unshift()")}}
+
Добавляет один или более элементов в начало массива и возвращает новую длину массива.
+
+ +

Методы доступа

+ +

Эти методы не изменяют массив, а просто возвращают его в ином представлении.

+ +
+
{{jsxref("Array.prototype.concat()")}}
+
Возвращает новый массив, состоящий из данного массива, соединённого с другим массивом и/или значением (списком массивов/значений).
+
{{jsxref("Array.prototype.includes()")}} {{experimental_inline}}
+
Определяет, содержится ли в массиве указанный элемент, возвращая, соответственно, true или false.
+
{{jsxref("Array.prototype.join()")}}
+
Объединяет все элементы массива в строку.
+
{{jsxref("Array.prototype.slice()")}}
+
Извлекает диапазон значений и возвращает его в виде нового массива.
+
{{jsxref("Array.prototype.toSource()")}} {{non-standard_inline}}
+
Возвращает литеральное представление указанного массива; вы можете использовать это значение для создания нового массива. Переопределяет метод {{jsxref("Object.prototype.toSource()")}}.
+
{{jsxref("Array.prototype.toString()")}}
+
Возвращает строковое представление массива и его элементов. Переопределяет метод {{jsxref("Object.prototype.toString()")}}.
+
{{jsxref("Array.prototype.toLocaleString()")}}
+
Возвращает локализованное строковое представление массива и его элементов. Переопределяет метод {{jsxref("Object.prototype.toLocaleString()")}}.
+
{{jsxref("Array.prototype.indexOf()")}}
+
Возвращает первый (наименьший) индекс элемента внутри массива, равный указанному значению; или -1, если значение не найдено.
+
{{jsxref("Array.prototype.lastIndexOf()")}}
+
Возвращает последний (наибольший) индекс элемента внутри массива, равный указанному значению; или -1, если значение не найдено.
+
+ +

Методы обхода

+ +

Некоторые методы принимают в качестве аргументов функции, вызываемые при обработке массива. Когда вызываются эти методы, достаётся длина массива, и любой элемент, добавленный свыше этой длины изнутри функции обратного вызова не посещается. Другие изменения в массиве (установка значения или удаление элемента) могут повлиять на результаты операции, если изменённый элемент метод посещает после изменения. Хотя специфическое поведение этих методов в таких случаях хорошо определено, вы не должны на него полагаться, чтобы не запутывать других людей, читающих ваш код. Если вам нужно изменить массив, лучше вместо этого скопируйте его в новый массив.

+ +
+
{{jsxref("Array.prototype.forEach()")}}
+
Вызывает функцию для каждого элемента в массиве.
+
{{jsxref("Array.prototype.entries()")}} {{experimental_inline}}
+
Возвращает новый объект итератора массива Array Iterator, содержащий пары ключ / значение для каждого индекса в массиве.
+
{{jsxref("Array.prototype.every()")}}
+
Возвращает true, если каждый элемент в массиве удовлетворяет условию проверяющей функции.
+
{{jsxref("Array.prototype.some()")}}
+
Возвращает true, если хотя бы один элемент в массиве удовлетворяет условию проверяющей функции.
+
{{jsxref("Array.prototype.filter()")}}
+
Создаёт новый массив со всеми элементами этого массива, для которых функция фильтрации возвращает true.
+
{{jsxref("Array.prototype.find()")}} {{experimental_inline}}
+
Возвращает искомое значение в массиве, если элемент в массиве удовлетворяет условию проверяющей функции или {{jsxref("Global_Objects/undefined", "undefined")}}, если такое значение не найдено.
+
{{jsxref("Array.prototype.findIndex()")}} {{experimental_inline}}
+
Возвращает искомый индекс в массиве, если элемент в массиве удовлетворяет условию проверяющей функции или -1, если такое значение не найдено.
+
{{jsxref("Array.prototype.keys()")}} {{experimental_inline}}
+
Возвращает новый итератор массива, содержащий ключи каждого индекса в массиве.
+
{{jsxref("Array.prototype.map()")}}
+
Создаёт новый массив с результатами вызова указанной функции на каждом элементе данного массива.
+
{{jsxref("Array.prototype.reduce()")}}
+
Применяет функцию к аккумулятору и каждому значению массива (слева-направо), сводя его к одному значению.
+
{{jsxref("Array.prototype.reduceRight()")}}
+
Применяет функцию к аккумулятору и каждому значению массива (справа-налево), сводя его к одному значению.
+
{{jsxref("Array.prototype.values()")}} {{experimental_inline}}
+
Возвращает новый объект итератора массива Array Iterator, содержащий значения для каждого индекса в массиве.
+
{{jsxref("Array.prototype.@@iterator()", "Array.prototype[@@iterator]()")}} {{experimental_inline}}
+
Возвращает новый объект итератора массива Array Iterator, содержащий значения для каждого индекса в массиве.
+
+ +

Общие методы

+ +

Многие методы JavaScript-массива спроектированы таким образом, чтобы иметь возможность применяться ко всем объектам, «выглядящим похоже» на массивы. То есть, они могут использоваться на любом объекте, имеющим свойство length и к элементам которого можно получить доступ через числовые имена свойств (как при индексации: array[5]). TODO: предоставить примеры с Array.prototype.forEach.call и добавлением методов к объекту, как сделано для {{jsxref("Global_Objects/JavaArray", "JavaArray")}} или {{jsxref("Global_Objects/String", "String")}}. Некоторые методы, например {{jsxref("Array.join", "join")}}, только читают свойство length и числовые свойства объекта, на котором они вызываются. Другие, вроде {{jsxref("Array.reverse", "reverse")}} требуют, чтобы числовые свойства и свойство length объекта были изменяемыми; эти методы не могут вызываться на объектах вроде {{jsxref("Global_Objects/String", "String")}}, которые не позволяют установку своего свойства length или синтезирование числовых свойств.

+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарий
ECMAScript 1-е издание.СтандартИзначальное определение.
{{SpecName('ES5.1', '#sec-15.4.3.1', 'Array.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-array.prototype', 'Array.prototype')}}{{Spec2('ES6')}} 
+ +

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

+ +

 

+ + + +

{{Compat("javascript.builtins.Array.prototype")}}

+ +

 

+ +
 
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/push/index.html b/files/ru/web/javascript/reference/global_objects/array/push/index.html new file mode 100644 index 0000000000..d746b2cd88 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/push/index.html @@ -0,0 +1,111 @@ +--- +title: Array.prototype.push() +slug: Web/JavaScript/Reference/Global_Objects/Array/push +tags: + - Array + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/push +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод push() добавляет один или более элементов в конец массива и возвращает новую длину массива.

+ +

Синтаксис

+ +
arr.push(element1, ..., elementN)
+ +

Параметры

+ +
+
elementN
+
Элементы, добавляемые в конец массива.
+
+ +

Возвращаемое значение

+ +

Новое значение свойства {{jsxref("Array.length", "length")}} объекта, для которого был вызван данный метод.

+ +

Описание

+ +

Метод push присоединяет значения к массиву.

+ +

Метод push не является привязанным к типу; этот метод может быть {{jsxref("Function.call", "вызван", "", 1)}} или {{jsxref("Function.apply", "применён", "", 1)}} к объектам, напоминающим массив. Метод опирается на свойство length для определения места вставки значений. Если свойство length не может быть преобразовано в число, будет использовать индекс 0. Сюда входит случай несуществования свойства length, в этом случае оно также будет создано.

+ +

Единственными родными массивоподобными объектами являются {{jsxref("Global_Objects/String", "строки", "", 1)}}, хотя к ним он не может быть применён, поскольку строки являются неизменяемыми.

+ +

Примеры

+ +

Пример: добавление элементов в массив

+ +

Следующий код создаёт массив sports, содержащий два элемента, а затем добавляет к нему ещё два элемента. Переменная total будет содержать новую длину массива.

+ +
var sports = ['футбол', 'бейсбол'];
+var total = sports.push('американский футбол', 'плавание');
+
+console.log(sports); // ['футбол', 'бейсбол', 'американский футбол', 'плавание']
+console.log(total);  // 4
+
+ +

Пример: слияние двух массивов

+ +

В этом примере используется функция {{jsxref("Function.apply", "apply()")}} для помещения всех элементов из второго массива в первый.

+ +
var vegetables = ['пастернак', 'картошка'];
+var moreVegs = ['сельдерей', 'свёкла'];
+
+// Сливает второй массив с первым
+// Эквивалентно вызову vegetables.push('сельдерей', 'свёкла');
+Array.prototype.push.apply(vegetables, moreVegs);
+
+console.log(vegetables); // ['пастернак', 'картошка', 'сельдерей', 'свёкла']
+
+ +

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

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

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

+ +
+
+ + +

{{Compat("javascript.builtins.Array.push")}}

+
+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/reduce/index.html b/files/ru/web/javascript/reference/global_objects/array/reduce/index.html new file mode 100644 index 0000000000..b65fb98ed4 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/reduce/index.html @@ -0,0 +1,314 @@ +--- +title: Array.prototype.reduce() +slug: Web/JavaScript/Reference/Global_Objects/Array/Reduce +tags: + - Array + - ECMAScript5 + - JavaScript + - JavaScript 1.8 + - Method + - Prototype + - Reference + - Référence(2) + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce +--- +
{{JSRef}}
+ +

Метод reduce() применяет функцию reducer к каждому элементу массива (слева-направо), возвращая одно результирующее значение.

+ +
{{EmbedInteractiveExample("pages/js/array-reduce.html")}}
+ + + +

Синтаксис

+ +
array.reduce(callback[, initialValue])
+ +

Параметры

+ +
+
callback
+
Функция, выполняющаяся для каждого элемента массива, принимает четыре аргумента: +
+
accumulator
+
Аккумулятор, аккумулирующий значение, которое возвращает функция callback после посещения очередного элемента, либо значение initialValue, если оно предоставлено (смотрите пояснения ниже).
+
currentValue
+
Текущий обрабатываемый элемент массива.
+
index{{optional_inline}}
+
Индекс текущего обрабатываемого элемента массива.
+
array{{optional_inline}}
+
Массив, для которого была вызвана функция reduce.
+
+
+
initialValue{{optional_inline}}
+
Необязательный параметр. Объект, используемый в качестве первого аргумента при первом вызове функции callback.
+
+ +

Описание

+ +

Метод reduce() выполняет функцию callback один раз для каждого элемента, присутствующего в массиве, за исключением пустот, принимая четыре аргумента: начальное значение (или значение от предыдущего вызова callback), значение текущего элемента, текущий индекс и массив, по которому происходит итерация.

+ +

При первом вызове функции, параметры accumulator и currentValue могут принимать одно из двух значений. Если при вызове reduce() передан аргумент initialValue, то значение accumulator будет равным значению initialValue, а значение currentValue будет равным первому значению в массиве. Если аргумент initialValue не задан, то значение accumulator будет равным первому значению в массиве, а значение currentValue будет равным второму значению в массиве.

+ +

Если массив пустой и аргумент initialValue не указан, будет брошено исключение {{jsxref("Global_Objects/TypeError", "TypeError")}}. Если массив состоит только из одного элемента (независимо от его положения в массиве) и аргумент initialValue не указан, или если аргумент initialValue указан, но массив пустой, то будет возвращено одно это значение, без вызова функции callback.

+ +

Предположим, что reduce() используется следующим образом:

+ +
[0, 1, 2, 3, 4].reduce(function(previousValue, currentValue, index, array) {
+  return previousValue + currentValue;
+});
+
+ +

Функция обратного вызова будет вызвана четыре раза, аргументы и возвращаемое значение при каждом вызове будут следующими:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
previousValuecurrentValueindexarrayвозвращаемое значение
первый вызов011[0, 1, 2, 3, 4]1
второй вызов122[0, 1, 2, 3, 4]3
третий вызов333[0, 1, 2, 3, 4]6
четвёртый вызов644[0, 1, 2, 3, 4]10
+ +

Значение, возвращённое методом reduce() будет равным последнему результату выполнения функции обратного вызова (10).

+ +

Если же вы зададите начальное значение initialValue, результат будет выглядеть так:

+ +
[0, 1, 2, 3, 4].reduce(function(accumulator, currentValue, index, array) {
+  return accumulator + currentValue;
+}, 10);
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
accumulatorcurrentValueindexarrayвозвращаемое значение
первый вызов1000[0, 1, 2, 3, 4]10
второй вызов1011[0, 1, 2, 3, 4]11
третий вызов1122[0, 1, 2, 3, 4]13
четвёртый вызов1333[0, 1, 2, 3, 4]16
пятый вызов1644[0, 1, 2, 3, 4]20
+ +

Значение, возвращённое методом reduce() на этот раз, конечно же, будет равным 20.

+ +

Примеры

+ +

Суммирование всех значений в массиве

+ +
var total = [0, 1, 2, 3].reduce(function(a, b) {
+  return a + b;
+});
+// total == 6
+
+ +

Суммирование значений в массиве объектов

+ +

Чтобы суммировать значения, содержащиеся в массиве объектов, вы должны указать initialValue, чтобы каждый элемент смог пройти через callback.

+ +
var initialValue = 0;
+var sum = [{x: 1}, {x:2}, {x:3}].reduce(function (accumulator, currentValue) {
+    return accumulator + currentValue.x;
+}, initialValue)
+// sum == 6
+
+ +

Тоже самое, но со стрелочной функцией: 

+ +
var initialValue = 0;
+var sum = [{x: 1}, {x:2}, {x:3}].reduce(
+    (accumulator, currentValue) => accumulator + currentValue.x,
+    initialValue
+);
+// sum == 6
+
+ +

Разворачивание массива массивов

+ +
var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
+  return a.concat(b);
+});
+// flattened равен [0, 1, 2, 3, 4, 5]
+
+ +

Пример: склеивание массивов, содержащихся в объектах массива, с использованием оператора расширения и initialValue

+ +
// friends - список из объектов(друзей)
+// где поле "books" - список любимых книг друга
+var friends = [
+{ name: "Anna", books: ["Bible", "Harry Potter"], age: 21 },
+{ name: "Bob", books: ["War and peace", "Romeo and Juliet"], age: 26 },
+{ name: "Alice", books: ["The Lord of the Rings", "The Shining"], age: 18 }
+]
+
+// allbooks - список, который будет содержать все книги друзей +
+// дополнительный список указанный в initialValue
+var allbooks = friends.reduce(function(prev, curr) {
+  return [...prev, ...curr.books];
+}, ["Alphabet"]);
+
+// allbooks = ["Alphabet", "Bible", "Harry Potter", "War and peace",
+// "Romeo and Juliet", "The Lord of the Rings", "The Shining"]
+
+ +

Полифилл

+ +

Метод Array.prototype.reduce() был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать reduce() в реализациях, которые не поддерживают этот метод.

+ +
// Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.21
+// Ссылка (en): http://es5.github.io/#x15.4.4.21
+// Ссылка (ru): http://es5.javascript.ru/x15.4.html#x15.4.4.21
+if (!Array.prototype.reduce) {
+  Array.prototype.reduce = function(callback/*, initialValue*/) {
+    'use strict';
+    if (this == null) {
+      throw new TypeError('Array.prototype.reduce called on null or undefined');
+    }
+    if (typeof callback !== 'function') {
+      throw new TypeError(callback + ' is not a function');
+    }
+    var t = Object(this), len = t.length >>> 0, k = 0, value;
+    if (arguments.length >= 2) {
+      value = arguments[1];
+    } else {
+      while (k < len && ! (k in t)) {
+        k++;
+      }
+      if (k >= len) {
+        throw new TypeError('Reduce of empty array with no initial value');
+      }
+      value = t[k++];
+    }
+    for (; k < len; k++) {
+      if (k in t) {
+        value = callback(value, t[k], k, t);
+      }
+    }
+    return value;
+  };
+}
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES5.1', '#sec-15.4.4.21', 'Array.prototype.reduce()')}}{{Spec2('ES5.1')}}Изначальное определение. Реализована в JavaScript 1.8.
{{SpecName('ES6', '#sec-array.prototype.reduce', 'Array.prototype.reduce()')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-array.prototype.reduce', 'Array.prototype.reduce()')}}{{Spec2('ESDraft')}}
+ +

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

+ +
+ + +

{{Compat("javascript.builtins.Array.reduce")}}

+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/reduceright/index.html b/files/ru/web/javascript/reference/global_objects/array/reduceright/index.html new file mode 100644 index 0000000000..08bb7e978d --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/reduceright/index.html @@ -0,0 +1,290 @@ +--- +title: Array.prototype.reduceRight() +slug: Web/JavaScript/Reference/Global_Objects/Array/reduceRight +tags: + - Array + - ECMAScript5 + - JavaScript + - JavaScript 1.8 + - Method + - Prototype + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+

Метод reduceRight() применяет функцию к аккумулятору и каждому значению массива (справа-налево), сводя его к одному значению.

+ +

Синтаксис

+
arr.reduceRight(callback[, initialValue])
+ +

Параметры

+
+
callback
+
Функция, выполняющаяся для каждого элемента массива, принимает четыре аргумента: +
+
previousValue
+
Значение, возвращённое предыдущим выполнением функции callback, либо значение initialValue, если оно предоставлено (смотрите пояснения ниже).
+
currentValue
+
Текущий обрабатываемый элемент массива.
+
index
+
Индекс текущего обрабатываемого элемента массива.
+
array
+
Массив, для которого была вызвана функция reduceRight.
+
+
+
initialValue
+
Необязательный параметр. Объект, используемый в качестве первого аргумента при первом вызове функции callback.
+
+ +

Описание

+

Метод reduceRight() выполняет функцию callback один раз для каждого элемента, присутствующего в массиве, за исключением пустот, принимая четыре аргумента: начальное значение (или значение от предыдущего вызова callback), значение текущего элемента, текущий индекс и массив, по которому происходит итерация.

+

Вызов функции обратного вызова callback будет выглядеть так:

+
array.reduceRight(function(previousValue, currentValue, index, array) {
+  // ...
+});
+
+

При первом вызове функции, параметры previousValue и currentValue могут принимать одно из двух значений. Если при вызове reduceRight() передан аргумент initialValue, то значение previousValue будет равным значению initialValue, а значение currentValue будет равным последнему значению в массиве. Если аргумент initialValue не задан, то значение previousValue будет равным последнему значению в массиве, а значение currentValue будет равным второму с конца значению в массиве.

+

Если массив пустой и аргумент initialValue не указан, будет брошено исключение {{jsxref("Global_Objects/TypeError", "TypeError")}}. Если массив состоит только из одного элемента (независимо от его положения в массиве) и аргумент initialValue не указан, или если аргумент initialValue указан, но массив пустой, то будет возвращено одно это значение, без вызова функции callback.

+

Вот так будут выглядеть некоторый примеры прогона функции:

+
[0, 1, 2, 3, 4].reduceRight(function(previousValue, currentValue, index, array) {
+  return previousValue + currentValue;
+});
+
+

Функция обратного вызова будет вызвана четыре раза, аргументы и возвращаемое значение при каждом вызове будут следующими:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 previousValuecurrentValueindexarrayвозвращаемое значение
первый вызов433[0, 1, 2, 3, 4]7
второй вызов722[0, 1, 2, 3, 4]9
третий вызов911[0, 1, 2, 3, 4]10
четвёртый вызов1000[0, 1, 2, 3, 4]10
+

Значение, возвращённое методом reduceRight() будет равным последнему результату выполнения функции обратного вызова (10).

+

Если же вы зададите начальное значение initialValue, результат будет выглядеть так:

+
[0, 1, 2, 3, 4].reduceRight(function(previousValue, currentValue, index, array) {
+  return previousValue + currentValue;
+}, 10);
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 previousValuecurrentValueindexarrayвозвращаемое значение
первый вызов1044[0, 1, 2, 3, 4]14
второй вызов1433[0, 1, 2, 3, 4]17
третий вызов1722[0, 1, 2, 3, 4]19
четвёртый вызов1911[0, 1, 2, 3, 4]20
пятый вызов2000[0, 1, 2, 3, 4]20
+

Значение, возвращённое методом reduceRight() на этот раз, конечно же, будет равным 20.

+ +

Примеры

+ +

Пример: суммирование всех значений в массиве

+
var total = [0, 1, 2, 3].reduceRight(function(a, b) {
+  return a + b;
+});
+// total == 6
+
+ +

Пример: разворачивание массива массивов

+
var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {
+  return a.concat(b);
+}, []);
+// flattened равен [4, 5, 2, 3, 0, 1]
+
+ +

Полифилл

+

Метод Array.prototype.reduceRight() был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать reduceRight() в реализациях, которые не поддерживают этот метод.

+
// Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.22
+// Ссылка (en): http://es5.github.io/#x15.4.4.22
+// Ссылка (ru): http://es5.javascript.ru/x15.4.html#x15.4.4.22
+if ('function' !== typeof Array.prototype.reduceRight) {
+  Array.prototype.reduceRight = function(callback/*, initialValue*/) {
+    'use strict';
+    if (null === this || 'undefined' === typeof this) {
+      throw new TypeError('Array.prototype.reduce called on null or undefined');
+    }
+    if ('function' !== typeof callback) {
+      throw new TypeError(callback + ' is not a function');
+    }
+    var t = Object(this), len = t.length >>> 0, k = len - 1, value;
+    if (arguments.length >= 2) {
+      value = arguments[1];
+    } else {
+      while (k >= 0 && !k in t) {
+        k--;
+      }
+      if (k < 0) {
+        throw new TypeError('Reduce of empty array with no initial value');
+      }
+      value = t[k--];
+    }
+    for (; k >= 0; k--) {
+      if (k in t) {
+        value = callback(value, t[k], k, t);
+      }
+    }
+    return value;
+  };
+}
+
+ +

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

+ + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES5.1', '#sec-15.4.4.22', 'Array.prototype.reduceRight')}}{{Spec2('ES5.1')}}Изначальное определение. Реализована в JavaScript 1.8.
{{SpecName('ES6', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}{{Spec2('ES6')}} 
+ +

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

+
{{CompatibilityTable}}
+
+ + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari
Базовая поддержка{{CompatVersionUnknown}}{{CompatGeckoDesktop("1.9")}}{{CompatIE("9")}}{{CompatOpera("10.5")}}{{CompatSafari("4.0")}}
+
+
+ + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome для AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

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

+ diff --git a/files/ru/web/javascript/reference/global_objects/array/reverse/index.html b/files/ru/web/javascript/reference/global_objects/array/reverse/index.html new file mode 100644 index 0000000000..15bb946242 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/reverse/index.html @@ -0,0 +1,96 @@ +--- +title: Array.prototype.reverse() +slug: Web/JavaScript/Reference/Global_Objects/Array/reverse +tags: + - Array + - JavaScript + - Method + - Prototype + - Reference + - Référence(2) +translation_of: Web/JavaScript/Reference/Global_Objects/Array/reverse +--- +
{{JSRef}}
+ +

Метод reverse() на месте обращает порядок следования элементов массива. Первый элемент массива становится последним, а последний — первым.

+ +
{{EmbedInteractiveExample("pages/js/array-reverse.html")}}
+ + + +

Синтаксис

+ +
array.reverse()
+ +

Параметры

+ +

Нет.

+ +

Возвращаемое значение

+ +

Перевернутный массив

+ +

Описание

+ +

Метод reverse() на месте переставляет элементы массива, на котором он был вызван, изменяет массив и возвращает ссылку на него.

+ +

Примеры

+ +

Пример: обращение порядка элементов в массиве

+ +

В следующем примере создаётся массив myArray, содержащий три элемента, а затем массив переворачивается.

+ +
var myArray = ['один', 'два', 'три'];
+myArray.reverse();
+
+console.log(myArray) // ['три', 'два', 'один']
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES1')}}{{Spec2('ES1')}}Изначальное определение. Реализована в JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.4.4.8', 'Array.prototype.reverse')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-array.prototype.reverse', 'Array.prototype.reverse')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-array.prototype.reverse', 'Array.prototype.reverse')}}{{Spec2('ESDraft')}} 
+ + +

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

+ +
+ + +

{{Compat("javascript.builtins.Array.reverse")}}

+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/shift/index.html b/files/ru/web/javascript/reference/global_objects/array/shift/index.html new file mode 100644 index 0000000000..081339bd93 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/shift/index.html @@ -0,0 +1,139 @@ +--- +title: Array.prototype.shift() +slug: Web/JavaScript/Reference/Global_Objects/Array/shift +tags: + - Array + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/shift +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод shift() удаляет первый элемент из массива и возвращает его значение. Этот метод изменяет длину массива.

+ +

Синтаксис

+ +
arr.shift()
+ +

Описание

+ +

Метод shift удаляет элемент по нулевому индексу, сдвигает значения по последовательным индексам вниз, а затем возвращает удалённое значение. Если свойство {{jsxref("Array.length", "length")}} массива равно 0, вернётся значение {{jsxref("Global_Objects/undefined", "undefined")}}.

+ +

Метод shift не является привязанным к типу; этот метод может быть {{jsxref("Function.call", "вызван", "", 1)}} или {{jsxref("Function.apply", "применён", "", 1)}} к объектам, напоминающим массив. Объекты, не содержащие свойство length, отражающее последний элемент в серии последовательных числовых, начинающихся с нуля, свойств, могут повести себя неправильным образом.

+ +

Примеры

+ +

Пример: удаление элемента из массива

+ +

Следующий код показывает массив myFish до и после удаления его первого элемента. Также он показывает удалённый элемент:

+ +
var myFish = ['ангел', 'клоун', 'мандарин', 'хирург'];
+
+console.log('myFish до: ' + myFish);
+//myFish до: ангел,клоун,мандарин,хирург
+
+var shifted = myFish.shift();
+
+console.log('myFish после: ' + myFish);
+//myFish после: клоун,мандарин,хирург
+
+console.log('Удалён этот элемент: ' + shifted);
+//Удалён этот элемент: ангел
+
+ +

Вывод этого примера будет следующим:

+ +
myFish до: ангел,клоун,мандарин,хирург
+myFish после: клоун,мандарин,хирург
+Удалён этот элемент: ангел
+
+ +

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

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

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

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari
Базовая поддержка{{CompatChrome("1.0")}}{{CompatGeckoDesktop("1.7")}}{{CompatIE("5.5")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
ВозможностьAndroidChrome для AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Базовая поддержка{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/slice/index.html b/files/ru/web/javascript/reference/global_objects/array/slice/index.html new file mode 100644 index 0000000000..1b35c36e24 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/slice/index.html @@ -0,0 +1,242 @@ +--- +title: Array.prototype.slice() +slug: Web/JavaScript/Reference/Global_Objects/Array/slice +tags: + - Array + - JavaScript + - Method + - Prototype + - Reference + - Référence(2) +translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice +--- +
{{JSRef}}
+ +

Метод slice() возвращает новый массив, содержащий копию части исходного массива.

+ +
{{EmbedInteractiveExample("pages/js/array-slice.html")}}
+ + + +

Синтаксис

+ +
arr.slice([begin[, end]])
+ +

Параметры

+ +
+
begin {{optional_inline}}
+
Индекс (счёт начинается с нуля), по которому начинать извлечение.
+
Если индекс отрицательный, begin указывает смещение от конца последовательности. Вызов slice(-2) извлечёт два последних элемента последовательности.
+
Если begin неопределен, slice() начинает работать с индекса 0.
+
Если begin больше длины последовательности вернется пустой массив.
+
end {{optional_inline}}
+
Индекс (счёт начинается с нуля), по которому заканчивать извлечение. Метод slice() извлекает элементы с индексом меньше end.
+
Вызов slice(1, 4) извлечёт элементы со второго по четвёртый (элементы по индексам 1, 2 и 3).
+
Если индекс отрицательный, end указывает смещение от конца последовательности. Вызов slice(2, -1) извлечёт из последовательности элементы начиная с третьего элемента с начала и заканчивая вторым с конца.
+
Если end опущен, slice() извлекает все элементы до конца последовательности (arr.length).
+
+ +

Возвращаемое значение

+ +

Новый массив, содержащий извлеченные элементы.

+ +

Описание

+ +

Метод slice() не изменяет исходный массив, а возвращает новую «одноуровневую» копию, содержащую копии элементов, вырезанных из исходного массива. Элементы исходного массива копируются в новый массив по следующим правилам:

+ + + +

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

+ +

Примеры

+ +

Пример: возврат части существующего массива

+ +
// Пример: наши хорошие друзья цитрусовые среди фруктов
+var fruits = ['Банан', 'Апельсин', 'Лимон', 'Яблоко', 'Манго'];
+var citrus = fruits.slice(1, 3);
+
+// citrus содержит ['Апельсин', 'Лимон']
+
+ +

Пример: использование метода slice()

+ +

В следующем примере метод slice() создаёт новый массив, newCar, из массива myCar. Оба содержат ссылку на объект myHonda. Когда цвет в объекте myHonda изменяется на багровый, оба массива замечают это изменение.

+ +
// Используя slice, создаём newCar из myCar.
+var myHonda = { color: 'красный', wheels: 4, engine: { cylinders: 4, size: 2.2 } };
+var myCar = [myHonda, 2, 'в хорошем состоянии', 'приобретена в 1997'];
+var newCar = myCar.slice(0, 2);
+
+// Отображаем значения myCar, newCar и цвет myHonda
+//  по ссылкам из обоих массивов.
+console.log('myCar = ' + myCar.toSource());
+console.log('newCar = ' + newCar.toSource());
+console.log('myCar[0].color = ' + myCar[0].color);
+console.log('newCar[0].color = ' + newCar[0].color);
+
+// Изменяем цвет myHonda.
+myHonda.color = 'багровый';
+console.log('Новый цвет моей Honda - ' + myHonda.color);
+
+// Отображаем цвет myHonda по ссылкам из обоих массивов.
+console.log('myCar[0].color = ' + myCar[0].color);
+console.log('newCar[0].color = ' + newCar[0].color);
+
+ +

Этот скрипт выведет:

+ +
myCar = [{color:'красный', wheels:4, engine:{cylinders:4, size:2.2}}, 2,
+         'в хорошем состоянии', 'приобретена в 1997']
+newCar = [{color:'красный', wheels:4, engine:{cylinders:4, size:2.2}}, 2]
+myCar[0].color = красный
+newCar[0].color = красный
+Новый цвет моей Honda - багровый
+myCar[0].color = багровый
+newCar[0].color = багровый
+
+ +

Массивоподобные объекты

+ +

Метод slice() также может использоваться для преобразования массивоподобных объектов / коллекций в новый массив Array. Вам просто нужно привязать метод к объекту. Псевдомассив {{jsxref("Functions_and_function_scope/arguments", "arguments")}} внутри функции как раз является примером «массивоподобного объекта».

+ +
function list() {
+  return Array.prototype.slice.call(arguments, 0);
+}
+
+var list1 = list(1, 2, 3); // [1, 2, 3]
+
+ +

Привязка может быть осуществлена посредством функции .call() из прототипа функции {{jsxref("Function.prototype")}}, также запись может быть сокращена до [].slice.call(arguments) вместо использования Array.prototype.slice.call(). В любом случае, она может быть упрощена посредством использования функции {{jsxref("Function.prototype.bind()", "bind()")}}.

+ +
var unboundSlice = Array.prototype.slice;
+var slice = Function.prototype.call.bind(unboundSlice);
+
+function list() {
+  return slice(arguments, 0);
+}
+
+var list1 = list(1, 2, 3); // [1, 2, 3]
+
+ +

Совершенствование кросс-браузерного поведения

+ +

Хотя спецификация не требует от хост-объектов (например, объектов DOM) следовать поведению Mozilla при преобразовании с помощью Array.prototype.slice() и IE < 9 так не делает, версии IE, начиная с 9-й это умеют. «Прокладывание» позволяет добиться надёжного кросс-браузерного поведения. Пока другие современные браузеры будут поддерживать эту способность, что и делают в настоящее время IE, Mozilla, Chrome, Safari и Opera, разработчики, читая (поддерживающий DOM) код функции slice(), опирающийся на эту прокладку, не будут вводиться в заблуждение его семантикой; они могут смело полагаться на текущую семантику, являющуюся, видимо, де-факто стандартным поведением. (Прокладка также исправляет поведение IE, позволяя работать со вторым аргументом slice(), явно определённым как {{jsxref("Global_Objects/null", "null")}}/{{jsxref("Global_Objects/undefined", "undefined")}}, поскольку более ранние версии IE такое не позволяют, но все современные браузеры, в том числе IE >= 9, поддерживают данное поведение.)

+ +
/**
+ * Прокладка для "исправления" отсутствия поддержки в IE < 9 применения slice
+ * к хост-объектам вроде NamedNodeMap, NodeList и HTMLCollection
+ * (технически, поскольку хост-объекты зависят от реализации,
+ * по крайней мере, до ES2015, IE не обязан так работать).
+ * Также работает для строк, исправляет поведение IE < 9, позволяя явно указывать undefined
+ * вторым аргументом (как в Firefox), и предотвращает ошибки, возникающие при
+ * вызове на других объектах DOM.
+ */
+(function () {
+  'use strict';
+  var _slice = Array.prototype.slice;
+
+  try {
+    // Не может использоваться с элементами DOM в IE < 9
+    _slice.call(document.documentElement);
+  } catch (e) { // В IE < 9 кидается исключение
+    // Функция будет работать для истинных массивов, массивоподобных объектов,
+    // NamedNodeMap (атрибуты, сущности, примечания),
+    // NodeList (например, getElementsByTagName), HTMLCollection (например, childNodes)
+    // и не будет падать на других объектах DOM (как это происходит на элементах DOM в IE < 9)
+    Array.prototype.slice = function(begin, end) {
+      // IE < 9 будет недоволен аргументом end, равным undefined
+      end = (typeof end !== 'undefined') ? end : this.length;
+
+      // Для родных объектов Array мы используем родную функцию slice
+      if (Object.prototype.toString.call(this) === '[object Array]') {
+        return _slice.call(this, begin, end);
+      }
+
+      // Массивоподобные объекты мы обрабатываем самостоятельно
+      var i, cloned = [],
+          size, len = this.length;
+
+      // Обрабатываем отрицательное значение begin
+      var start = begin || 0;
+      start = (start >= 0) ? start: len + start;
+
+      // Обрабатываем отрицательное значение end
+      var upTo = (end) ? end : len;
+      if (end < 0) {
+        upTo = len + end;
+      }
+
+      // Фактически ожидаемый размер среза
+      size = upTo - start;
+
+      if (size > 0) {
+        cloned = new Array(size);
+        if (this.charAt) {
+          for (i = 0; i < size; i++) {
+            cloned[i] = this.charAt(start + i);
+          }
+        } else {
+          for (i = 0; i < size; i++) {
+            cloned[i] = this[start + i];
+          }
+        }
+      }
+
+      return cloned;
+    };
+  }
+}());
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES3')}}{{Spec2('ES3')}}Изначальное определение. Реализована в JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.4.4.10', 'Array.prototype.slice')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-array.prototype.slice', 'Array.prototype.slice')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-array.prototype.slice', 'Array.prototype.slice')}}{{Spec2('ESDraft')}}
+ +

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

+ +
+ + +

{{Compat("javascript.builtins.Array.slice")}}

+
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/some/index.html b/files/ru/web/javascript/reference/global_objects/array/some/index.html new file mode 100644 index 0000000000..ee4c18f9f0 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/some/index.html @@ -0,0 +1,215 @@ +--- +title: Array.prototype.some() +slug: Web/JavaScript/Reference/Global_Objects/Array/some +tags: + - Array + - ECMAScript5 + - JavaScript + - JavaScript 1.6 + - Method + - Prototype + - Reference + - Référence(2) + - Массив + - метод +translation_of: Web/JavaScript/Reference/Global_Objects/Array/some +--- +
{{JSRef}}
+ +

Метод some() проверяет, удовлетворяет ли какой-либо элемент массива условию, заданному в передаваемой функции.

+ +
+

Обратите внимание: метод возвращает false при любом условии для пустого массива.

+
+ +

{{EmbedInteractiveExample("pages/js/array-some.html")}}

+ +

Синтаксис

+ +
arr.some(callback(element[, index[, array]])[, thisArg])
+ +

Параметры

+ +
+
callback
+
Функция проверки каждого элемента, принимает три аргумента: +
+
element
+
Текущий обрабатываемый элемент массива.
+
index{{Optional_inline}}
+
Индекс текущего обрабатываемого элемента массива.
+
array{{Optional_inline}}
+
Массив, по которому осуществляется проход.
+
+
+
thisArg{{Optional_inline}}
+
Значение, используемое в качестве this при выполнении функции callback.
+
+ +

Возвращаемое значение

+ +

true, если функция проверки возвращает {{Glossary("truthy")}} значение хотя бы для одного элемента массива. Иначе, false.

+ +

Описание

+ +

Метод some() вызывает переданную функцию callback один раз для каждого элемента, присутствующего в массиве до тех пор, пока не найдет такой, для которого callback вернет истинное значение (значение, становящееся равным true при приведении его к типу {{jsxref("Boolean")}}). Если такой элемент найден, метод some() немедленно вернёт true. В противном случае, если callback вернёт false для всех элементов массива, метод some() вернёт false. Функция callback вызывается только для индексов массива, имеющих присвоенные значения; она не вызывается для индексов, которые были удалены или которым значения никогда не присваивались.

+ +

Функция callback вызывается с тремя аргументами: значением элемента, индексом элемента и массивом, по которому осуществляется проход.

+ +

Если в метод some() был передан параметр thisArg, при вызове callback он будет использоваться в качестве значения this. В противном случае в качестве значения this будет использоваться значение {{jsxref("Global_Objects/undefined", "undefined")}}. В конечном итоге, значение this, наблюдаемое из функции callback, определяется согласно обычным правилам определения this, видимого из функции.

+ +

Метод some() не изменяет массив, для которого он был вызван.

+ +

Диапазон элементов, обрабатываемых методом some(), устанавливается до первого вызова функции callback. Элементы, добавленные в массив после начала выполнения метода some(), не будут посещены функцией callback. Если существующие элементы массива изменятся, значения, переданные в функцию callback, будут значениями на тот момент времени, когда метод some() посетит их; удалённые элементы посещены не будут.

+ +

Примеры

+ +

Проверка значений элементов массива

+ +

Следующий пример проверяет наличие в массиве элемента, который больше 10.

+ +
function isBiggerThan10(element, index, array) {
+  return element > 10;
+}
+[2, 5, 8, 1, 4].some(isBiggerThan10);  // false
+[12, 5, 8, 1, 4].some(isBiggerThan10); // true
+
+ +

{{ EmbedLiveSample('Проверка_значений_элементов_массива', '', '', '', 'Web/JavaScript/Reference/Global_Objects/Array/some') }}

+ +

Проверка элементов массива с использованием стрелочных функций

+ +

Стрелочные функции предоставляют более краткий синтаксис для подобных проверок.

+ +
[2, 5, 8, 1, 4].some(elem => elem > 10);  // false
+[12, 5, 8, 1, 4].some(elem => elem > 10); // true
+
+ +

{{ EmbedLiveSample('Проверка_элементов_массива_с_использованием_стрелочных_функций', '', '', '', 'Web/JavaScript/Reference/Global_Objects/Array/some') }}

+ +

Проверка наличия элемента в массиве

+ +

Чтобы имитировать функцию метода includes(), эта пользовательская функция возвращает true, если элемент существует в массиве:

+ +
const fruits = ['apple', 'banana', 'mango', 'guava'];
+
+function checkAvailability(arr, val) {
+  return arr.some(function(arrVal) {
+    return val === arrVal;
+  });
+}
+
+checkAvailability(fruits, 'kela');   // false
+checkAvailability(fruits, 'banana'); // true
+ +

{{ EmbedLiveSample('Проверка_наличия_элемента_в_массиве', '', '', '', 'Web/JavaScript/Reference/Global_Objects/Array/some') }}

+ +

Проверка наличия элемента в массиве с использованием стрелочной функции

+ +
const fruits = ['apple', 'banana', 'mango', 'guava'];
+
+function checkAvailability(arr, val) {
+  return arr.some(arrVal => val === arrVal);
+}
+
+checkAvailability(fruits, 'kela');   // false
+checkAvailability(fruits, 'banana'); // true
+ +

{{ EmbedLiveSample('Проверка_наличия_элемента_в_массиве_с_использованием_стрелочной_функции', '', '', '', 'Experiment:StaticExamplesOnTop/JavaScript/Array/some') }}

+ +

Приведение значения к логическому типу

+ +
const TRUTHY_VALUES = [true, 'true', 1];
+
+function getBoolean(value) {
+  'use strict';
+
+  if (typeof value === 'string') {
+    value = value.toLowerCase().trim();
+  }
+
+  return TRUTHY_VALUES.some(function(t) {
+    return t === value;
+  });
+}
+
+getBoolean(false);   // false
+getBoolean('false'); // false
+getBoolean(1);       // true
+getBoolean('true');  // true
+ +

{{ EmbedLiveSample('Приведение_значения_к_логическому_типу', '', '', '', 'Web/JavaScript/Reference/Global_Objects/Array/some') }}

+ +

Полифилл

+ +

Метод some() был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может не присутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать some() в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; и предполагает, что {{jsxref("Global_Objects/Object", "Object")}} и {{jsxref("Global_Objects/TypeError", "TypeError")}} имеют свои первоначальные значения и что callback.call вычисляется в оригинальное значение {{jsxref("Function.prototype.call()")}}.

+ +
// Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.17
+// Ссылка (en): http://es5.github.io/#x15.4.4.17
+// Ссылка (ru): http://es5.javascript.ru/x15.4.html#x15.4.4.17
+if (!Array.prototype.some) {
+  Array.prototype.some = function(fun/*, thisArg*/) {
+    'use strict';
+
+    if (this == null) {
+      throw new TypeError('Array.prototype.some called on null or undefined');
+    }
+
+    if (typeof fun !== 'function') {
+      throw new TypeError();
+    }
+
+    var t = Object(this);
+    var len = t.length >>> 0;
+
+    var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
+    for (var i = 0; i < len; i++) {
+      if (i in t && fun.call(thisArg, t[i], i, t)) {
+        return true;
+      }
+    }
+
+    return false;
+  };
+}
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES5.1', '#sec-15.4.4.17', 'Array.prototype.some')}}{{Spec2('ES5.1')}}Изначальное определение. Реализована в JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.some', 'Array.prototype.some')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-array.prototype.some', 'Array.prototype.some')}}{{Spec2('ESDraft')}}
+ +

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

+ +
{{Compat("javascript.builtins.Array.some")}}
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/sort/index.html b/files/ru/web/javascript/reference/global_objects/array/sort/index.html new file mode 100644 index 0000000000..06769275e6 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/sort/index.html @@ -0,0 +1,234 @@ +--- +title: Array.prototype.sort() +slug: Web/JavaScript/Reference/Global_Objects/Array/sort +tags: + - Array + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод sort() на месте сортирует элементы массива и возвращает отсортированный массив. Сортировка не обязательно устойчива (англ.). Порядок cортировки по умолчанию соответствует порядку кодовых точек Unicode.

+ +

Синтаксис

+ +
arr.sort([compareFunction])
+ +

Параметры

+ +
+
compareFunction
+
Необязательный параметр. Указывает функцию, определяющую порядок сортировки. Если опущен, массив сортируется в соответствии со значениями кодовых точек каждого символа Unicode, полученных путём преобразования каждого элемента в строку.
+
+ +

Возвращаемое значение

+ +

Отсортированный массив. Важно, что копия массива не создается - массив сортируется на месте.

+ +

Описание

+ +

Если функция сравнения compareFunction не предоставляется, элементы сортируются путём преобразования их в строки и сравнения строк в порядке следования кодовых точек Unicode. Например, слово "Вишня" идёт перед словом "бананы". При числовой сортировке, 9 идёт перед 80, но поскольку числа преобразуются в строки, то "80" идёт перед "9" в соответствии с порядком в Unicode.

+ +
var fruit = ['арбузы', 'бананы', 'Вишня'];
+fruit.sort(); // ['Вишня', 'арбузы', 'бананы']
+
+var scores = [1, 2, 10, 21];
+scores.sort(); // [1, 10, 2, 21]
+
+var things = ['слово', 'Слово', '1 Слово', '2 Слова'];
+things.sort(); // ['1 Слово', '2 Слова', 'Слово', 'слово']
+// В Unicode, числа находятся перед буквами в верхнем регистре,
+// а те, в свою очередь, перед буквами в нижнем регистре.
+
+ +

Если функция сравнения compareFunction предоставлена, элементы массива сортируются в соответствии с её возвращаемым значением. Если сравниваются два элемента a и b, то:

+ + + +

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

+ +
function compare(a, b) {
+  if (a меньше b по некоторому критерию сортировки) {
+    return -1;
+  }
+  if (a больше b по некоторому критерию сортировки) {
+    return 1;
+  }
+  // a должно быть равным b
+  return 0;
+}
+
+ +

Для числового сравнения, вместо строкового, функция сравнения может просто вычитать b из a. Следующая функция будет сортировать массив по возрастанию:

+ +
function compareNumbers(a, b) {
+  return a - b;
+}
+
+ +

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

+ +
var numbers = [4, 2, 5, 1, 3];
+numbers.sort(function(a, b) {
+  return a - b;
+});
+console.log(numbers); // [1, 2, 3, 4, 5]
+
+ +

Объекты могут быть отсортированы по значению одного из своих свойств.

+ +
var items = [
+  { name: 'Edward', value: 21 },
+  { name: 'Sharpe', value: 37 },
+  { name: 'And', value: 45 },
+  { name: 'The', value: -12 },
+  { name: 'Magnetic' },
+  { name: 'Zeros', value: 37 }
+];
+items.sort(function (a, b) {
+  if (a.name > b.name) {
+    return 1;
+  }
+  if (a.name < b.name) {
+    return -1;
+  }
+  // a должно быть равным b
+  return 0;
+});
+
+ +

Примеры

+ +

Пример: создание, отображение и сортировка массива

+ +

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

+ +
var stringArray = ['Голубая', 'Горбатая', 'Белуга'];
+var numericStringArray = ['80', '9', '700'];
+var numberArray = [40, 1, 5, 200];
+var mixedNumericArray = ['80', '9', '700', 40, 1, 5, 200];
+
+function compareNumbers(a, b) {
+  return a - b;
+}
+
+// снова предполагаем, что функция печати определена
+console.log('stringArray:', stringArray.join());
+console.log('Сортировка:', stringArray.sort());
+
+console.log('numberArray:', numberArray.join());
+console.log('Сортировка без функции сравнения:', numberArray.sort());
+console.log('Сортировка с функцией compareNumbers:', numberArray.sort(compareNumbers));
+
+console.log('numericStringArray:', numericStringArray.join());
+console.log('Сортировка без функции сравнения:', numericStringArray.sort());
+console.log('Сортировка с функцией compareNumbers:', numericStringArray.sort(compareNumbers));
+
+console.log('mixedNumericArray:', mixedNumericArray.join());
+console.log('Сортировка без функции сравнения:', mixedNumericArray.sort());
+console.log('Сортировка с функцией compareNumbers:', mixedNumericArray.sort(compareNumbers));
+
+ +

Этот пример произведёт следующий вывод. Как показывает вывод, когда используется функция сравнения, числа сортируются корректно вне зависимости от того, являются ли они собственно числами или строками с числами.

+ +
stringArray: Голубая,Горбатая,Белуга
+Сортировка: Белуга,Голубая,Горбатая
+
+numberArray: 40,1,5,200
+Сортировка без функции сравнения: 1,200,40,5
+Сортировка с функцией compareNumbers: 1,5,40,200
+
+numericStringArray: 80,9,700
+Сортировка без функции сравнения: 700,80,9
+Сортировка с функцией compareNumbers: 9,80,700
+
+mixedNumericArray: 80,9,700,40,1,5,200
+Сортировка без функции сравнения: 1,200,40,5,700,80,9
+Сортировка с функцией compareNumbers: 1,5,9,40,80,200,700
+
+ +

Пример: сортировка не-ASCII символов

+ +

Для сортировки строк с не-ASCII символами, то есть строк с символами акцента (e, é, è, a, ä и т.д.), строк, с языками, отличными от английского: используйте {{jsxref("String.localeCompare")}}. Эта функция может сравнивать эти символы, чтобы они становились в правильном порядке.

+ +
var items = ['réservé', 'premier', 'cliché', 'communiqué', 'café', 'adieu'];
+items.sort(function (a, b) {
+  return a.localeCompare(b);
+});
+
+// items равен ['adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé']
+
+ +

Пример: сортировка c помощью map

+ +

Функция сравнения (compareFunction) может вызываться несколько раз для каждого элемента в массиве. В зависимости от природы функции сравнения, это может привести к высоким расходам ресурсов. Чем более сложна функция сравнения и чем больше элементов требуется отсортировать, тем разумнее использовать map для сортировки. Идея состоит в том, чтобы обойти массив один раз, чтобы извлечь фактические значения, используемые для сортировки, во временный массив, отсортировать временный массив, а затем обойти временный массив для получения правильного порядка.

+ +
// массив для сортировки
+var list = ['Дельта', 'альфа', 'ЧАРЛИ', 'браво'];
+
+// временный массив содержит объекты с позицией и значением сортировки
+var mapped = list.map(function(el, i) {
+return { index: i, value: el.toLowerCase() };
+});
+
+// сортируем массив, содержащий уменьшенные значения
+mapped.sort(function(a, b) {
+  if (a.value > b.value) {
+    return 1; }
+  if (a.value < b.value) {
+    return -1; }
+  return 0;
+});
+
+// контейнер для результа
+var result = mapped.map(function(el) {
+  return list[el.index];
+});
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
ECMAScript 1-е издание.СтандартИзначальное определение.
{{SpecName('ES5.1', '#sec-15.4.4.11', 'Array.prototype.sort')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-array.prototype.sort', 'Array.prototype.sort')}}{{Spec2('ES6')}}
+ +

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

+ +
{{Compat("javascript.builtins.Array.sort")}}
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/splice/index.html b/files/ru/web/javascript/reference/global_objects/array/splice/index.html new file mode 100644 index 0000000000..a714590fab --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/splice/index.html @@ -0,0 +1,142 @@ +--- +title: Array.prototype.splice() +slug: Web/JavaScript/Reference/Global_Objects/Array/splice +tags: + - Array + - JavaScript + - Method + - Prototype + - Reference + - Référence(2) +translation_of: Web/JavaScript/Reference/Global_Objects/Array/splice +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод splice() изменяет содержимое массива, удаляя существующие элементы и/или добавляя новые.

+ +

Синтаксис

+ +
array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
+
+ +

Параметры

+ +
+
start
+
Индекс, по которому начинает изменять массив. Если больше длины массива, реальный индекс будет установлен на длину массива. Если отрицателен, указывает индекс элемента с конца.
+
deleteCount {{optional_inline}}
+
Целое число, показывающее количество старых удаляемых из массива элементов. Если deleteCount равен 0, элементы не удаляются. В этом случае вы должны указать как минимум один новый элемент. Если deleteCount больше количества элементов, оставшихся в массиве, начиная с индекса start, то будут удалены все элементы до конца массива.
+
itemN {{optional_inline}}
+
Необязательные параметры. Добавляемые к массиву элементы. Если вы не укажете никакого элемента, splice() просто удалит элементы из массива.
+
+ +

Возвращаемое значение

+ +

Массив, содержащий удалённые элементы. Если будет удалён только один элемент, вернётся массив из одного элемента. Если никакие элементы не будут удалены, вернётся пустой массив.

+ +

Описание

+ +

Если количество указанных вставляемых элементов будет отличным от количества удаляемых элементов, массив изменит длину после вызова.

+ +

Примеры

+ +

Удаляет 0 элементов по индексу 2 и вставляет "drum"

+ +
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
+var removed = myFish.splice(2, 0, 'drum');
+
+// myFish равен ["angel", "clown", "drum", "mandarin", "sturgeon"]
+// removed равен [], ничего не удалено
+ +

Удаляет 1 элемент по индексу 3

+ +
var myFish = ['angel', 'clown', 'drum', 'mandarin', 'sturgeon'];
+var removed = myFish.splice(3, 1);
+
+// removed равен ["mandarin"]
+// myFish равен ["angel", "clown", "drum", "sturgeon"]
+ +

Удаляет 1 элемент по индексу 2 и вставляет "trumpet"

+ +
var myFish = ['angel', 'clown', 'drum', 'sturgeon'];
+var removed = myFish.splice(2, 1, 'trumpet');
+
+// myFish равен ["angel", "clown", "trumpet", "sturgeon"]
+// removed равен ["drum"]
+ +

Удаляет 2 элемента начиная с индекса 0 и вставляет "parrot", "anemone" и "blue"

+ +
var myFish = ['angel', 'clown', 'trumpet', 'sturgeon'];
+var removed = myFish.splice(0, 2, 'parrot', 'anemone', 'blue');
+
+// myFish равен ["parrot", "anemone", "blue", "trumpet", "sturgeon"]
+// removed равен ["angel", "clown"]
+ +

Удаляет 2 элемента начиная с индекса 2

+ +
var myFish = ['parrot', 'anemone', 'blue', 'trumpet', 'sturgeon'];
+var removed = myFish.splice(myFish.length - 3, 2);
+
+// myFish равен ["parrot", "anemone", "sturgeon"]
+// removed равен ["blue", "trumpet"]
+ +

Удаляет 1 элемент по индексу -2

+ +
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
+var removed = myFish.splice(-2, 1);
+
+// myFish равен ["angel", "clown", "sturgeon"]
+// removed равен s ["mandarin"]
+ +

Удаляет все элементы после индекса 2 (включительно)

+ +
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
+var removed = myFish.splice(2);
+
+// myFish равен ["angel", "clown"]
+// removed равен ["mandarin", "sturgeon"]
+ +

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

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

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

+ +

{{Compat("javascript.builtins.Array.splice")}}

+ +

Обратная совместимость

+ +

В JavaScript 1.2 метод splice() возвращал удалённый элемент только если был удалён один элемент (параметр deleteCount равен 1); в противном случае метод возвращал массив с удалёнными элементами. Обратите внимание, что последним браузером, использующим JavaScript 1.2, был Netscape Navigator 4, так что вы можете считать, что splice() всегда возвращает массив.

+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/tolocalestring/index.html b/files/ru/web/javascript/reference/global_objects/array/tolocalestring/index.html new file mode 100644 index 0000000000..ed3f4f6088 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/tolocalestring/index.html @@ -0,0 +1,134 @@ +--- +title: Array.prototype.toLocaleString() +slug: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString +tags: + - Array + - Internationalization + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод toLocaleString() возвращает строковое представление элементов массива. Элементы преобразуются в строки с использованием своих собственных методов toLocaleString и эти строки разделяются локале-зависимой строкой (например, запятой «,»).

+ +

Синтаксис

+ +
arr.toLocaleString();
+ +

Параметры

+ +

Нет.

+ +

Описание

+ +

Элементы массива преобразуются в строки с использованием своих собственных методов toLocaleString:

+ + + +

Примеры

+ +

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

+ +
var number = 1337;
+var date = new Date();
+var myArr = [number, date, 'foo'];
+
+var str = myArr.toLocaleString();
+
+console.log(str);
+// напечатает '1337,6.12.2013 19:37:35,foo',
+// если работает под германской локалью (de-DE) с временной зоной Европа/Берлин
+
+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
ECMAScript 3-е издание.СтандартИзначальное определение.
{{SpecName('ES5.1', '#sec-15.2.4.3', 'Array.prototype.toLocaleString')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-array.prototype.tolocalestring', 'Array.prototype.toLocaleString')}}{{Spec2('ES6')}} 
+ +

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

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

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/tosource/index.html b/files/ru/web/javascript/reference/global_objects/array/tosource/index.html new file mode 100644 index 0000000000..c4d30c1287 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/tosource/index.html @@ -0,0 +1,94 @@ +--- +title: Array.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Array/toSource +tags: + - Array + - JavaScript + - Method + - Non-standard + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toSource +--- +
+ {{JSRef("Global_Objects", "Array")}} {{non-standard_header}}
+

Сводка

+

Метод toSource() возвращает строковое представление исходного кода массива.

+

Синтаксис

+
arr.toSource()
+

Параметры

+

Нет.

+

Описание

+

Метод toSource возвращает следующие значения:

+ +

Этот метод обычно вызывается внутри движка JavaScript, а не явно в коде. Вы можете вызвать toSource во время отладки для просмотра содержимого массива.

+

Примеры

+

Пример: рассмотрение исходного кода массива

+

Для просмотра исходного кода массива:

+
var alpha = new Array('a', 'b', 'c');
+
+alpha.toSource();   // вернёт ['a', 'b', 'c']
+
+

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

+

Не является частью какого-либо стандарта. Реализована в JavaScript 1.3.

+

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

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

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

+ diff --git a/files/ru/web/javascript/reference/global_objects/array/tostring/index.html b/files/ru/web/javascript/reference/global_objects/array/tostring/index.html new file mode 100644 index 0000000000..f2877df269 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/tostring/index.html @@ -0,0 +1,122 @@ +--- +title: Array.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Array/toString +tags: + - Array + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toString +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод toString() возвращает строковое представление указанного массива и его элементов.

+ +

Синтаксис

+ +
arr.toString()
+ +

Параметры

+ +

Нет.

+ +

Описание

+ +

Объект {{jsxref("Global_Objects/Array", "Array")}} переопределяет метод toString объекта {{jsxref("Global_Objects/Object", "Object")}}. Для объектов класса Array, метод toString соединяет массив и возвращает одну строку, содержащую каждый элемент массива, разделённый запятыми. Например, следующий код создаёт массив и использует метод toString для преобразования массива в строку.

+ +
var monthNames = ['Янв', 'Фев', 'Мар', 'Апр'];
+var myVar = monthNames.toString(); // присваивает 'Янв,Фев,Мар,Апр' переменной myVar.
+
+ +

JavaScript вызывает метод toString автоматически, когда массив представляется текстовым значением или когда массив находится в контексте конкатенации строк.

+ +

Семантика ECMAScript 5

+ +

Начиная с JavaScript 1.8.5 (Firefox 4), и в соответствии с сементикой ECMAScript 5-го издания, метод toString() является обобщённым и может использоваться с любым объектом. В случае с массивами, если он имеет метод join(), он будет вызван и результат его работы будет возвращён. В противном случае будет вызван метод {{jsxref("Object.prototype.toString()")}}, и будет возвращён результат его работы.

+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
ECMAScript 1-е издание.СтандартИзначальное определение. Реализована в JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.4.4.2', 'Array.prototype.toString')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-array.prototype.tostring', 'Array.prototype.toString')}}{{Spec2('ES6')}}
+ +

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

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

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/unshift/index.html b/files/ru/web/javascript/reference/global_objects/array/unshift/index.html new file mode 100644 index 0000000000..1d3e095ead --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/unshift/index.html @@ -0,0 +1,89 @@ +--- +title: Array.prototype.unshift() +slug: Web/JavaScript/Reference/Global_Objects/Array/unshift +tags: + - Array + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/unshift +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод unshift() добавляет один или более элементов в начало массива и возвращает новую длину массива.

+ +

Синтаксис

+ +
arr.unshift(element1[, ...[, elementN]])
+ +

Параметры

+ +
+
element1, ..., elementN
+
Элементы, добавляемые в начало массива.
+
+ +

Возвращаемое значение

+ +

Новое свойство {{jsxref("Array.length", "length")}} объекта, над которым был вызван метод unshift.

+ +

Описание

+ +

Метод unshift вставляет переданные значения в начало массивоподобного объекта.

+ +

Метод unshift не является привязанным к типу; этот метод может быть {{jsxref("Function.call", "вызван", "", 1)}} или {{jsxref("Function.apply", "применён", "", 1)}} к объектам, напоминающим массив. Объекты, не содержащие свойство length, отражающее последний элемент в серии последовательных числовых, начинающихся с нуля, свойств, могут повести себя неправильным образом.

+ +

Примеры

+ +
var arr = [1, 2];
+
+arr.unshift(0); // результат вызова равен 3, новой длине массива
+// arr равен [0, 1, 2]
+
+arr.unshift(-2, -1); // = 5
+// arr равен [-2, -1, 0, 1, 2]
+
+arr.unshift([-3]);
+// arr равен[[-3], -2, -1, 0, 1, 2]
+
+ +

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

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

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

+ +
{{Compat("javascript.builtins.Array.unshift")}}
+ +

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

+ + diff --git a/files/ru/web/javascript/reference/global_objects/array/values/index.html b/files/ru/web/javascript/reference/global_objects/array/values/index.html new file mode 100644 index 0000000000..bdd8c8c2f6 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/array/values/index.html @@ -0,0 +1,136 @@ +--- +title: Array.prototype.values() +slug: Web/JavaScript/Reference/Global_Objects/Array/values +tags: + - Array + - ECMAScript6 + - Experimental + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array/values +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Сводка

+ +

Метод values() возвращает новый объект итератора массива Array Iterator, содержащий значения для каждого индекса в массиве.

+ +

Синтаксис

+ +
arr.values()
+ +

Примеры

+ +

Пример: итерация через цикл for...of

+ +
var arr = ['w', 'y', 'k', 'o', 'p'];
+var eArr = arr.values();
+// ваш браузер должен поддерживать цикл for...of и переменные,
+// объявленные через let в циклах for
+for (let letter of eArr) {
+  console.log(letter);
+}
+
+ +

Пример: альтернативный способ итерации

+ +
var arr = ['w', 'y', 'k', 'o', 'p'];
+var eArr = arr.values();
+console.log(eArr.next().value); // w
+console.log(eArr.next().value); // y
+console.log(eArr.next().value); // k
+console.log(eArr.next().value); // o
+console.log(eArr.next().value); // p
+
+ +

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

+ + + + + + + + + + + + + + + + + + + +
СпецификацияСтатусКомментарии
{{SpecName('ES6', '#sec-array.prototype.values', 'Array.prototype.values')}}{{Spec2('ES6')}}Изначальное определение.
{{SpecName('ESDraft', '#sec-array.prototype.values', 'Array.prototype.values')}}{{Spec2('ESDraft')}} 
+ +

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

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

Примечание по Firefox

+ + + +

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

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