diff options
Diffstat (limited to 'files/pt-br/web/javascript/reference/global_objects/array/from')
| -rw-r--r-- | files/pt-br/web/javascript/reference/global_objects/array/from/index.html | 205 |
1 files changed, 205 insertions, 0 deletions
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/from/index.html b/files/pt-br/web/javascript/reference/global_objects/array/from/index.html new file mode 100644 index 0000000000..798f1c727d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/from/index.html @@ -0,0 +1,205 @@ +--- +title: Array.from() +slug: Web/JavaScript/Reference/Global_Objects/Array/from +tags: + - Array + - ECMAScript 2015 + - ES6 + - Method + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/from +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <code><strong>Array.from()</strong></code> cria uma nova instância <code>de um Array</code> quando for passado um array-like ou um iterable object como argumento.</p> + +<p>No ES6, <span id="result_box" lang="pt"><span class="hps">a sintaxe</span> <span class="hps">de classe</span> permite a<span class="hps"> subclassificação de </span>classes nativas e classes <span class="hps">definidas pelo usuário; como </span><span class="hps">resultado</span><span>, os métodos estáticos</span> <span class="hps">pertencentes a classe,</span> <span class="hps">como</span> </span> <code><strong>Array.from,</strong></code><span lang="pt"> <span class="hps">são</span> <span class="atn hps">"</span><span>herdadas</span><span>"</span> por <span class="hps">subclasses</span> <span class="hps">do </span></span><code><strong>Array</strong></code><span lang="pt"> <span class="hps">e criam </span><span class="hps">novas instâncias da</span> <span class="hps">subclasse,</span> <span class="hps">não</span> <span class="hps">do </span></span><code><strong>Array</strong></code><span lang="pt"><span class="hps">.</span></span></p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code>Array.from(arrayLike[, mapFn[, thisArg]]) +</code></pre> + +<h3 id="Parameters" name="Parameters"><span>Parâmetros</span></h3> + +<dl> + <dt><code>arrayLike</code></dt> + <dd>Um array-like ou um objeto iterável para converter em array.</dd> + <dt><code>mapFn</code></dt> + <dd><em>Opcional</em>. Função Map que será chamada para cada elemento do array.</dd> + <dt><code>thisArg</code></dt> + <dd><em>Opcional</em>. Valor a ser utilizado como this quando a mapFn for chamada.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p><code>Array.from()</code> deixa você criar um Array de:</p> + +<ul> + <li>objetos array-like (objetos com a propriedade <code>length</code> e elementos indexados); ou</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/iterable">Objetos iteráveis</a> (objetos onde você pode coletar seus elementos, assim como {{jsxref("Map")}} e {{jsxref("Set")}}).</li> +</ul> + +<p><code>Array.from()</code> tem um parametro opcional <code>mapFn</code>, que permite executar a função {{jsxref("Array.prototype.map", "map")}} para cada elemento do array (ou subclasse de objeto) que está sendo criado. Simplificando,<code> Array.from(obj, mapFn, thisArg)</code> é o mesmo que <code>Array.from(obj).map(mapFn, thisArg)</code>, com a excessão de não cria um array intermediário . Isso é importante, principalmente para certas subclasses de array, como <a href="/en-US/docs/Web/JavaScript/Typed_arrays">typed array</a>, no qual o array intermediário iria necessáriamente ter o valor truncado para encaixar-se no tipo apropriado.</p> + +<p>A propriedade <code>length</code> do método <code>from()</code> é <code>1</code>.</p> + +<p>No ES2015, a sintaxe de class permite a definição de subclasses tanto internas quando definidas pelo usuário. Como resultado, métodos estáticos como <code>Array.from()</code> são "herdados" pelas subclasses de <code>Array</code>, e cria novas instâncias da subclasse, não de <code>Array</code>.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>Array.from</code> foi adicionado ao padrão ECMA-262 em sua 6ª edição; desta forma, <span id="result_box" lang="pt"><span class="hps">não</span> <span class="hps">está presente</span> <span class="hps">na</span> <span class="hps">aplicações anteriores da especificação</span></span>. Na ausência do código nativo, você pode inserir o código seguinte no início do script, permitindo <code>o uso parcial da funcionalidade do Array.from</code>. Esse algorítmo é equivalente ao especificado no ECMA-262, 6ª edição, exceto que <code>Object</code> e <code>TypeError</code> tem seus valores originais e que <code>callback.call</code> retorna o valor original de {{jsxref("Function.prototype.call")}}. Além disso, <span id="result_box" lang="pt"><span class="hps">os verdadeiros</span> <span class="hps">iterables</span> <span class="hps">não</span> podem ser representados</span> genéricamente no polyfill, criando a principal distinção do que foi definido na especificação.</p> + +<pre class="brush: js notranslate">// Production steps of ECMA-262, Edition 6, 22.1.2.1 +// Reference: 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); + }; + + // The length property of the from method is 1. + return function from(arrayLike/*, mapFn, thisArg */) { + // 1. Let C be the this value. + var C = this; + + // 2. Let items be 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. If mapfn is undefined, then let mapping be false. + var mapFn = arguments.length > 1 ? arguments[1] : void undefined; + var T; + if (typeof mapFn !== 'undefined') { + // 5. else + // 5. a If IsCallable(mapfn) is false, throw a TypeError exception. + if (!isCallable(mapFn)) { + throw new TypeError('Array.from: when provided, the second argument must be a function'); + } + + // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined. + if (arguments.length > 2) { + T = arguments[2]; + } + } + + // 10. Let lenValue be Get(items, "length"). + // 11. Let len be ToLength(lenValue). + var len = toLength(items.length); + + // 13. If IsConstructor(C) is true, then + // 13. a. Let A be the result of calling the [[Construct]] internal method of C with an argument list containing the single item len. + // 14. a. Else, Let A be ArrayCreate(len). + var A = isCallable(C) ? Object(new C(len)) : new Array(len); + + // 16. Let k be 0. + var k = 0; + // 17. Repeat, while k < len… (also steps 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. Let putStatus be Put(A, "length", len, true). + A.length = len; + // 20. Return A. + return A; + }; + }()); +} +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js notranslate">// Array-like object (arguments) para um Array +function f() { + return Array.from(arguments); +} + +f(1, 2, 3); +// [1, 2, 3] + + +// Qualquer iterable object ... +// com 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]] + + +// String +Array.from("foo"); +// ["f", "o", "o"] + + +// Usando um arrow function como função map para +// manipular os elementos +Array.from([1, 2, 3], x => x + x); +// [2, 4, 6] + + +// Gerando uma sequência de números +Array.from({length: 5}, (v, k) => k); +// [0, 1, 2, 3, 4] +</pre> + +<h2 id="Especificação">Especificação</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.from', 'Array.from')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + </tbody> +</table> + +<h2 id="compatibilidade_com_navegadores">compatibilidade com navegadores</h2> + +<div> +<p>{{Compat("javascript.builtins.Array.from")}}</p> +</div> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Array.prototype.map()")}}</li> + <li>{{jsxref("TypedArray.from()")}}</li> +</ul> |