path: root/files/ru/web/javascript/reference/global_objects/array/from/index.html

---
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
---
<div>{{JSRef}}</div>

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

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

<h2 id="Syntax" name="Syntax">Синтаксис</h2>

<pre class="syntaxbox"><code>Array.from(<var>arrayLike</var>[, <var>mapFn</var>[, <var>thisArg</var>]])</code></pre>

<h3 id="Parameters" name="Parameters">Параметры</h3>

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

<h3 id="Возвращаемое_значение">Возвращаемое значение</h3>

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

<h2 id="Description" name="Description">Описание</h2>

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

<ul>
 <li>массивоподобных объектов (объектов со свойством <code>length</code> и элементами по индексным ключам) или</li>
 <li><a href="/ru/docs/Web/JavaScript/Reference/Iteration_protocols">итерируемых объектов</a> (объектов, из которых вы можете достать их элементы, например {{jsxref("Map")}} или {{jsxref("Set")}}).</li>
</ul>

<p><code>Array.from()</code> имеет необязательный параметр <code>mapFn</code>, который позволяет вам выполнять функцию {{jsxref("Array.prototype.map", "map")}} для каждого элемента создаваемого массива (или его подкласса). Проще говоря, вызов <code>Array.from(obj, mapFn, thisArg)</code> эквивалентен цепочке <code>Array.from(obj).map(mapFn, thisArg)</code>, за исключением того, что он не создаёт промежуточного массива. Это особенно важно для некоторых подклассов массива, вроде <a href="/ru/docs/Web/JavaScript/Typed_arrays">типизированных массивов</a>, поскольку промежуточный массив неизбежно приведёт к усечению значений, чтобы они подпали под подходящий тип.</p>

<p>Свойство <code>length</code> метода <code>from()</code> равно 1.</p>

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

<h2 id="Examples" name="Examples">Примеры</h2>

<h3 id="Массив_из_строки_String">Массив из строки <code>String</code></h3>

<pre class="brush: js">Array.from('foo');
// ['f', 'o', 'o']
</pre>

<h3 id="Массив_из_Set">Массив из <code>Set</code></h3>

<pre class="brush: js">var s = new Set(['foo', window]);
Array.from(s);
// ['foo', window]
</pre>

<h3 id="Массив_из_Map">Массив из <code>Map</code></h3>

<pre class="brush: js">var m = new Map([[1, 2], [2, 4], [4, 8]]);
Array.from(m);
// [[1, 2], [2, 4], [4, 8]]
</pre>

<h3 id="Массив_из_массивоподобного_объекта_(arguments)">Массив из массивоподобного объекта (arguments)</h3>

<pre class="brush: js">function f() {
  return Array.from(arguments);
}

f(1, 2, 3);
// [1, 2, 3]
</pre>

<h3 id="Использование_стрелочной_функции_и_Array.from()">Использование стрелочной функции и <code>Array.from()</code></h3>

<pre class="brush: js">// Использование стрелочной функции в качестве функции отображения для

// манипулирования элементами
Array.from([1, 2, 3], x =&gt; x + x);
// [2, 4, 6]

// Генерирования последовательности чисел
Array.from({ length: 5 }, (v, k) =&gt; k);
// [0, 1, 2, 3, 4]</pre>

<h2 id="Polyfill" name="Polyfill">Полифил</h2>

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

<pre class="brush: js">// Шаги алгоритма 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 &gt; 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 &gt; 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 &gt; 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 &lt; len, будем повторять... (шаги с a по h)
      var kValue;
      while (k &lt; 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;
    };
  }());
}
</pre>

<h2 id="Specifications" name="Specifications">Спецификации</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Спецификация</th>
   <th scope="col">Статус</th>
   <th scope="col">Комментарии</th>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-array.from', 'Array.from')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td></td>
  </tr>
  <tr>
   <td>{{SpecName('ES2015', '#sec-array.from', 'Array.from')}}</td>
   <td>{{Spec2('ES2015')}}</td>
   <td>Изначальное определение.</td>
  </tr>
 </tbody>
</table>

<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>

<div>{{Compat("javascript.builtins.Array.from")}}</div>

<div id="compat-mobile"></div>

<h2 id="See_also" name="See_also">Смотрите также</h2>

<ul>
 <li>{{jsxref("Array")}}</li>
 <li>{{jsxref("Array.prototype.map()")}}</li>
 <li>{{jsxref("TypedArray.from()")}}</li>
</ul>