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 | 122 +++++ .../global_objects/array/@@unscopables/index.html | 75 +++ .../global_objects/array/concat/index.html | 159 +++++++ .../global_objects/array/contains/index.html | 106 +++++ .../global_objects/array/copywithin/index.html | 203 ++++++++ .../global_objects/array/entries/index.html | 117 +++++ .../global_objects/array/every/index.html | 176 +++++++ .../reference/global_objects/array/fill/index.html | 125 +++++ .../global_objects/array/filtro/index.html | 227 +++++++++ .../reference/global_objects/array/find/index.html | 157 +++++++ .../global_objects/array/findindex/index.html | 127 +++++ .../reference/global_objects/array/flat/index.html | 121 +++++ .../global_objects/array/flatmap/index.html | 126 +++++ .../global_objects/array/foreach/index.html | 212 +++++++++ .../reference/global_objects/array/from/index.html | 205 ++++++++ .../reference/global_objects/array/index.html | 511 ++++++++++++++++++++ .../global_objects/array/indexof/index.html | 186 ++++++++ .../global_objects/array/isarray/index.html | 141 ++++++ .../reference/global_objects/array/join/index.html | 108 +++++ .../reference/global_objects/array/keys/index.html | 115 +++++ .../global_objects/array/lastindexof/index.html | 184 ++++++++ .../global_objects/array/length/index.html | 128 +++++ .../reference/global_objects/array/map/index.html | 255 ++++++++++ .../global_objects/array/observe/index.html | 128 +++++ .../reference/global_objects/array/of/index.html | 108 +++++ .../reference/global_objects/array/pop/index.html | 81 ++++ .../global_objects/array/prototype/index.html | 206 +++++++++ .../reference/global_objects/array/push/index.html | 184 ++++++++ .../global_objects/array/reduce/index.html | 513 +++++++++++++++++++++ .../global_objects/array/reduceright/index.html | 258 +++++++++++ .../global_objects/array/reverse/index.html | 121 +++++ .../global_objects/array/shift/index.html | 104 +++++ .../global_objects/array/slice/index.html | 224 +++++++++ .../reference/global_objects/array/some/index.html | 134 ++++++ .../reference/global_objects/array/sort/index.html | 232 ++++++++++ .../global_objects/array/splice/index.html | 173 +++++++ .../global_objects/array/tolocalestring/index.html | 140 ++++++ .../global_objects/array/tosource/index.html | 113 +++++ .../global_objects/array/tostring/index.html | 115 +++++ .../global_objects/array/unobserve/index.html | 129 ++++++ .../global_objects/array/unshift/index.html | 90 ++++ .../global_objects/array/values/index.html | 121 +++++ 42 files changed, 7060 insertions(+) create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/@@iterator/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/@@unscopables/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/concat/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/contains/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/copywithin/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/entries/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/every/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/fill/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/filtro/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/find/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/findindex/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/flat/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/flatmap/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/foreach/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/from/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/indexof/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/isarray/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/join/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/keys/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/lastindexof/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/length/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/map/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/observe/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/of/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/pop/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/prototype/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/push/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/reduce/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/reduceright/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/reverse/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/shift/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/slice/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/some/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/sort/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/splice/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/tolocalestring/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/tosource/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/tostring/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/unobserve/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/unshift/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/array/values/index.html (limited to 'files/pt-br/web/javascript/reference/global_objects/array') diff --git a/files/pt-br/web/javascript/reference/global_objects/array/@@iterator/index.html b/files/pt-br/web/javascript/reference/global_objects/array/@@iterator/index.html new file mode 100644 index 0000000000..4256678efd --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/@@iterator/index.html @@ -0,0 +1,122 @@ +--- +title: 'Array.prototype[@@iterator]()' +slug: Web/JavaScript/Reference/Global_Objects/Array/@@iterator +translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@iterator +--- +
{{JSRef}}
+ +

O valor inicial da propriedade @@iterator é o mesmo objeto função que o valor inicial da propriedade {{jsxref("Array.prototype.values()", "values()")}}.

+ +

Sintaxe

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

Exemplos

+ +

Iteração usando laço for...of

+ +
var arr = ['w', 'y', 'k', 'o', 'p'];
+// seu navegador deve suportar laço for..of
+// e variáveis de escopo let em laços for
+for (let letter of arr) {
+  console.log(letter);
+}
+
+ +

Iteração alternativa

+ +
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
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES6', '#sec-array.prototype-@@iterator', 'Array.prototype[@@iterator]()')}}{{Spec2('ES6')}}Definição inicial.
{{SpecName('ESDraft', '#sec-array.prototype-@@iterator', 'Array.prototype[@@iterator]()')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidade de navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatChrome("38")}}{{CompatGeckoDesktop("36")}} [1]{{CompatNo}}{{CompatOpera("25")}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("36")}} [1]{{CompatNo}}{{CompatOpera("25")}}{{CompatNo}}
+
+ +

[1] A partir do Gecko 17 (Firefox 17 / Thunderbird 17 / SeaMonkey 2.14) até o Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2) a propriedade iterator era usada (bug 907077), e a partir do Gecko 27 até o Gecko 35 o placeholder "@@iterator" era usado. No Gecko 36 (Firefox 36 / Thunderbird 36 / SeaMonkey 2.33), o símbolo @@iterator foi implementado (bug 918828).

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/@@unscopables/index.html b/files/pt-br/web/javascript/reference/global_objects/array/@@unscopables/index.html new file mode 100644 index 0000000000..53805d6ada --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/@@unscopables/index.html @@ -0,0 +1,75 @@ +--- +title: 'Array.prototype[@@unscopables]' +slug: Web/JavaScript/Reference/Global_Objects/Array/@@unscopables +tags: + - ES2015 + - JS + - Propriedade + - Prototipo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@unscopables +--- +
{{JSRef}}
+ +
A propriedade de símbolo @@unscopable contém nomes de propriedades que não foram incluídos no padrão ECMAScript antes da versão ES2015. Essas propriedades são excluídas do statement bindings with. 
+ +

Sintaxe

+ +
arr[Symbol.unscopables]
+ +

Descrição

+ +

As propriedades padrão de array que são excluídas dos bindings with são: copyWithin, entries, fill, find, findIndex, includes, keys, e values.

+ +

Veja {{jsxref("Symbol.unscopables")}} para saber como definir unscopables para seus objetos.

+ +

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

+ +

Exemplos

+ +

O código a seguir funciona bem no ES5 e abaixo. No entanto, no ECMAScript 2015 e posterior, o método {{jsxref("Array.prototype.keys()")}} foi introduzido. Isso significa que dentro de ambientes with, as "keys" seriam agora o método e não a variável. É aqui que a propriedade de símbolo @@unscopables Array.prototype[@@unscopables] entra em ação e impede que alguns métodos do Array estejam sendo definidos na instrução with.

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

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES2015', '#sec-array.prototype-@@unscopables', 'Array.prototype[@@unscopables]')}}{{Spec2('ES2015')}}Initial definition.
{{SpecName('ESDraft', '#sec-array.prototype-@@unscopables', 'Array.prototype[@@unscopables]')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidade de navegadores

+ +
+ + +

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

+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/concat/index.html b/files/pt-br/web/javascript/reference/global_objects/array/concat/index.html new file mode 100644 index 0000000000..dc8fc20d38 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/concat/index.html @@ -0,0 +1,159 @@ +--- +title: Array.prototype.concat() +slug: Web/JavaScript/Reference/Global_Objects/Array/concat +translation_of: Web/JavaScript/Reference/Global_Objects/Array/concat +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Sumário

+ +

O método concat() retorna um novo array contendo todos os arrays ou valores passados como parâmetro

+ +

Sintaxe

+ +
arr.concat(valor1, valor2, ..., valorN)
+ +

Parâmetros

+ +
+
valorN
+
Arrays ou valores para concatenar (unir) ao array retornado.
+
+ +

Descrição

+ +

concat cria um novo array unindo todos os elementos que foram passados como parâmetro, na ordem dada, para cada argumento e seus elementos (se o elemento passado for um array).

+ +

concat não altera a si mesmo ou a qualquer um dos argumentos passados, apenas providencia um novo array contendo uma cópia de si mesmo e dos argumentos passados. Os elementos copiados são:

+ + + + + +

Exemplos

+ +

Exemplo: Concatenando dois arrays

+ +

O código a seguir une dois arrays:

+ +
var alpha = ["a", "b", "c"];
+var numeric = [1, 2, 3];
+
+// creates array ["a", "b", "c", 1, 2, 3]; alpha and numeric are unchanged
+var alphaNumeric = alpha.concat(numeric);
+
+ +

Exemplo: Concatenando três arrays

+ +

O código a seguir une três arrays:

+ +
var num1 = [1, 2, 3];
+var num2 = [4, 5, 6];
+var num3 = [7, 8, 9];
+
+// creates array [1, 2, 3, 4, 5, 6, 7, 8, 9]; num1, num2, num3 are unchanged
+var nums = num1.concat(num2, num3);
+
+ +

Exemplo: Concatenando valores ao array

+ +

O código a seguir une três valores ao array

+ +
var alpha = ['a', 'b', 'c'];
+
+// creates array ["a", "b", "c", 1, 2, 3], leaving alpha unchanged
+var alphaNumeric = alpha.concat(1, [2, 3]);
+
+ +

Especificação

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
ECMAScript 3rd EditionStandardInitial definition.
+ Implemented in 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')}} 
+ +

Compatibilidade em navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support1.0{{CompatGeckoDesktop("1.7")}}5.5{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/contains/index.html b/files/pt-br/web/javascript/reference/global_objects/array/contains/index.html new file mode 100644 index 0000000000..a0f794df1a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/contains/index.html @@ -0,0 +1,106 @@ +--- +title: Array.prototype.includes() +slug: Web/JavaScript/Reference/Global_Objects/Array/contains +tags: + - Array + - ECMAScript7 + - Experimental + - Expérimental(2) + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Array/includes +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Sumário

+ +

O método includes() determina se um array contém um determinado elemento, retornando true ou false apropriadamente.

+ +

Sintaxe

+ +
array.includes(searchElement[, fromIndex])
+ +

Parâmetros

+ +
+
searchElement
+
O elemento a buscar
+
fromIndex
+
Opcional. A posição no array de onde a busca pelo searchElement se iniciará. Por padrão, 0.
+
+ +

Exemplos

+ +
[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
+
+ +

Polyfill

+ +
// https://tc39.github.io/ecma262/#sec-array.prototype.includes
+if (!Array.prototype.includes) {
+  Object.defineProperty(Array.prototype, 'includes', {
+    value: function(searchElement, fromIndex) {
+
+      // 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 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);
+
+      // 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.
+        // c. Increase k by 1.
+        // NOTE: === provides the correct "SameValueZero" comparison needed here.
+        if (o[k] === searchElement) {
+          return true;
+        }
+        k++;
+      }
+
+      // 8. Return false
+      return false;
+    }
+  });
+}
+
+ +

Especificações

+ +

Proposta ES7: https://github.com/domenic/Array.prototype.contains/blob/master/spec.md

+ +

Compatibilidade

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

Veja Também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/copywithin/index.html b/files/pt-br/web/javascript/reference/global_objects/array/copywithin/index.html new file mode 100644 index 0000000000..4802e87b94 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/copywithin/index.html @@ -0,0 +1,203 @@ +--- +title: Array.prototype.copyWithin() +slug: Web/JavaScript/Reference/Global_Objects/Array/copyWithin +translation_of: Web/JavaScript/Reference/Global_Objects/Array/copyWithin +--- +
{{JSRef}}
+ +

O método copyWithin() copia parte de um array para outra localização dentro deste mesmo array e o retorna, sem alterar seu tamanho. 

+ +

Sintaxe

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

Parâmetros

+ +
+
target
+
Posição para a qual os elementos serão copiados. Caso negativo, o target será contado a partir do final.
+
start
+
Índice inicial de onde se copiará os elementos. Caso negativo, o start será contado a partir do final.
+
end {{optional_inline}}
+
Índice final de onde se copiará os elementos. Caso negativo, o end será contado a partir do final.
+
+ +

Descrição

+ +

Os argumentos target, start e end são restritos a {{jsxref("Number")}} e truncados para valores inteiros.

+ +

Se start for negativo, ele é tratado como length+start, onde length é o comprimento do array. Se end for negativo, ele é tratado como length+end.

+ +

A função copyWithin é intencionalmente genérica, não requer que seu valor this seja um objeto {{jsxref("Array")}} e, adicionalmente, copyWithin é um método mutável, irá mudar o próprio objeto this e retorná-lo, não apenas retornar uma cópia dele.

+ +

Exemplos

+ +
[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}
+
+// Typed Arrays do ES6 são subclasses de Array
+var i32a = new Int32Array([1, 2, 3, 4, 5]);
+
+i32a.copyWithin(0, 2);
+// Int32Array [3, 4, 5, 4, 5]
+
+// Em plataformas que ainda não são compatíveis com ES6:
+[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4);
+// Int32Array [4, 2, 3, 4, 5]
+
+ +

Polyfill

+ +
if (!Array.prototype.copyWithin) {
+  Array.prototype.copyWithin = function(target, start/*, end*/) {
+    // Passos 1-2.
+    if (this == null) {
+      throw new TypeError('this é null ou não definido');
+    }
+
+    var O = Object(this);
+
+    // Passos 3-5.
+    var len = O.length >>> 0;
+
+    // Passos 6-8.
+    var relativeTarget = target >> 0;
+
+    var to = relativeTarget < 0 ?
+      Math.max(len + relativeTarget, 0) :
+      Math.min(relativeTarget, len);
+
+    // Passos 9-11.
+    var relativeStart = start >> 0;
+
+    var from = relativeStart < 0 ?
+      Math.max(len + relativeStart, 0) :
+      Math.min(relativeStart, len);
+
+    // Passos 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);
+
+    // Passo 15.
+    var count = Math.min(final - from, len - to);
+
+    // Passos 16-17.
+    var direction = 1;
+
+    if (from < to && to < (from + count)) {
+      direction = -1;
+      from += count - 1;
+      to += count - 1;
+    }
+
+    // Passo 18.
+    while (count > 0) {
+      if (from in O) {
+        O[to] = O[from];
+      } else {
+        delete O[to];
+      }
+
+      from += direction;
+      to += direction;
+      count--;
+    }
+
+    // Passo 19.
+    return O;
+  };
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES6', '#sec-array.prototype.copyWithin', 'Array.prototype.copyWithin')}}{{Spec2('ES6')}}Definição inicial.
{{SpecName('ESDraft', '#sec-array.prototype.copyWithin', 'Array.prototype.copyWithin')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidade de navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatChrome("45")}}{{CompatGeckoDesktop("32")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("32")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/entries/index.html b/files/pt-br/web/javascript/reference/global_objects/array/entries/index.html new file mode 100644 index 0000000000..8abb0cf088 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/entries/index.html @@ -0,0 +1,117 @@ +--- +title: Array.prototype.entries() +slug: Web/JavaScript/Reference/Global_Objects/Array/entries +translation_of: Web/JavaScript/Reference/Global_Objects/Array/entries +--- +
{{JSRef}}
+ +

O método entries() retorna um novo objeto Array Iterator que contém os pares chave/valor para cada índice no array.

+ +

Sintaxe

+ +
arr.entries()
+ +

Exemplos

+ +
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']
+
+ +

O mesmo que acima, utilizando um loop for…of

+ +
var arr = ['a', 'b', 'c'];
+var eArr = arr.entries();
+
+for (let e of eArr) {
+  console.log(e);
+}
+// [0, 'a']
+// [1, 'b']
+// [2, 'c']
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES6', '#sec-array.prototype.entries', 'Array.prototype.entries')}}{{Spec2('ES6')}}Definição inicial.
{{SpecName('ESDraft', '#sec-array.prototype.entries', 'Array.prototype.entries')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidade de navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatChrome("38")}}{{CompatGeckoDesktop("28")}}{{CompatNo}}{{CompatOpera("25")}}{{CompatSafari("7.1")}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("28")}}{{CompatNo}}{{CompatNo}}8.0
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/every/index.html b/files/pt-br/web/javascript/reference/global_objects/array/every/index.html new file mode 100644 index 0000000000..a7d290e58a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/every/index.html @@ -0,0 +1,176 @@ +--- +title: Array.prototype.every() +slug: Web/JavaScript/Reference/Global_Objects/Array/every +tags: + - Array + - JavaScript + - Método(2) + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/every +--- +
{{JSRef}}
+ +

O método every() testa se todos os elementos do array passam pelo teste implementado pela função fornecida.

+ +

Sintaxe

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

Parâmetros

+ +
+
callback
+
Função que testa cada elemento, recebe três parametros: +
+
currentValue (obrigatório)
+
O elemento atual sendo processado na array. 
+
index (opcional)
+
O índice do elemento atual sendo processado na array.
+
array (opcional)
+
O array de origem.
+
+
+
thisArg
+
Opcional. Valor a ser usado como this quando o callback é executado.
+
+ +

Valor de retorno

+ +

true se a função de callback retorna um valor {{Glossary("truthy")}} para cada um dos elementos do array; caso contrário, false.

+ +

Descrição

+ +

O método every executa a função callback fornecida uma vez para cada elemento presente no array, até encontrar algum elemento em que a função retorne um valor false (valor que se torna false quando convertido para boolean). Se esse elemento é encontrado, o método every imediatamente retorna false. Caso contrário, se a função callback retornar true para todos elementos, o método retorna true.  A função callback é chamada apenas para os elementos do array original que tiverem valores atribuídos; os elementos que tiverem sido removidos ou os que nunca tiveram valores atribuídos não serão considerados.

+ +

A função callback é chamada com três argumentos: o valor do elemento corrente, o índice do elemento corrente e o array original que está sendo percorrido.

+ +

Se o parâmetro thisArg foi passado para o método every, ele será repassado para a função callback no momento da chamada para ser utilizado como o this. Caso contrário, o valor undefined será repassado para uso como o this. O valor do this a ser repassado para o callback é determinado de acordo com as regras usuais para determinar o this visto por uma função.

+ +

O método every não modifica o array original.

+ +

A lista de elementos que serão processados pelo every é montada antes da primeira chamada da função callback. Se um elemento for acrescentado ao array original após a chamada ao every , ele não será visível para o callback. Se os elementos existentes forem modificados, os valores que serão repassados serão os do momento em que o método every chamar o callback. Elementos removidos não serão considerados.

+ +

every funciona como o  qualificador "for all" em matemática. Particularmente, para um vetor vazio, é retornado true. (É verdade por vacuidade que todos os elementos do conjunto vazio satisfazem qualquer condição.)

+ +

Exemplos

+ +

Testando tamanho de todos os elementos do vetor

+ +

O exemplo a seguir testa se todos elementos no array são maiores que 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
+
+ +

Usando arrow functions

+ +

Arrow functions fornecem sintaxe mais curta para o mesmo teste. 

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

Polyfill

+ +

every foi adicionado ao padrão ECMA-262 na 5ª edição; como tal, pode não estar presente em outras implementações do padrão. Você pode contornar isso adicionando o seguinte código no começo dos seus scripts, permitindo o uso de every em implementações que não o suportam nativamente. Esse algoritimo é exatamente o mesmo especificado no ECMA-262, 5ª edição, assumindo que Object e TypeError tem os seus valores originais e que callbackfn.call retorna o valor original de {{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. Let O be the result of calling ToObject passing the this
+    //    value as the argument.
+    var O = Object(this);
+
+    // 2. Let lenValue be the result of calling the Get internal method
+    //    of O with the argument "length".
+    // 3. Let len be ToUint32(lenValue).
+    var len = O.length >>> 0;
+
+    // 4. If IsCallable(callbackfn) is false, throw a TypeError exception.
+    if (typeof callbackfn !== 'function') {
+      throw new TypeError();
+    }
+
+    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+    if (arguments.length > 1) {
+      T = thisArg;
+    }
+
+    // 6. Let k be 0.
+    k = 0;
+
+    // 7. Repeat, while k < len
+    while (k < len) {
+
+      var kValue;
+
+      // a. Let Pk be ToString(k).
+      //   This is implicit for LHS operands of the in operator
+      // b. Let kPresent be the result of calling the HasProperty internal
+      //    method of O with argument Pk.
+      //   This step can be combined with c
+      // c. If kPresent is true, then
+      if (k in O) {
+
+        // i. Let kValue be the result of calling the Get internal method
+        //    of O with argument Pk.
+        kValue = O[k];
+
+        // ii. Let testResult be the result of calling the Call internal method
+        //     of callbackfn with T as the this value and argument list
+        //     containing kValue, k, and O.
+        var testResult = callbackfn.call(T, kValue, k, O);
+
+        // iii. If ToBoolean(testResult) is false, return false.
+        if (!testResult) {
+          return false;
+        }
+      }
+      k++;
+    }
+    return true;
+  };
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES5.1', '#sec-15.4.4.16', 'Array.prototype.every')}}{{Spec2('ES5.1')}}Definição inicial. Implementada no JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.every', 'Array.prototype.every')}}{{Spec2('ES6')}}
+ +

Compatibilidade em navegadores

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

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/fill/index.html b/files/pt-br/web/javascript/reference/global_objects/array/fill/index.html new file mode 100644 index 0000000000..8957bf3023 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/fill/index.html @@ -0,0 +1,125 @@ +--- +title: Array.prototype.fill() +slug: Web/JavaScript/Reference/Global_Objects/Array/fill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/fill +--- +
{{JSRef}}
+ +

O método fill() preenche todos os valores do array a partir do índice inicial a um índice final com um valor estático.

+ +

Sintaxe

+ +
arr.fill(valor[, ínicio = 0[, fim = this.length]])
+ +

Parâmetros

+ +
+
valor
+
Valor para preencher o array.
+
ínicio
+
Opcional. Índice inicial.
+
fim
+
Opcional. Índice final.
+
+ +

Descrição

+ +

O intervalo de preenchimento dos elementos é  [início, fim).

+ +

O método fill pode receber até três argumentos valor, ínicio e fim. Os argumentos ínicio e fim são opcionais com valor padrão 0 (valor) e o tamanho do objeto (fim).

+ +

Se o ínicio for negativo, ele será tratado como tamanho + ínicio onde tamanho é o tamanho total do array. Se o fim for negativo, ele será tratado como tamanho + fim.

+ +

A função fill é intencionalmente genérica, ele não precisa que o valor do this seja um objeto Array.

+ +

O método fill é um método mutável, ele irá mudar o objeto em si, e retorná-lo, não somente uma cópia do objeto.

+ +

Exemplos

+ +
[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, -2);       // [4, 2, 3]
+[1, 2, 3].fill(4, NaN, NaN);     // [1, 2, 3]
+Array(3).fill(4);                // [4, 4, 4]
+[].fill.call({ length: 3 }, 4);  // {0: 4, 1: 4, 2: 4, length: 3}
+
+ +

Polyfill

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

Especificações

+ + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES6', '#sec-array.prototype.fill', 'Array.prototype.fill')}}{{Spec2('ES6')}}Definição inicial.
+ +

Compatibilidade com os navegadores

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

[1] Começando com Chrome 36, isto era disponível com uma mudança nas preferencias. Em chrome://flags, ativar a entrada “Enable Experimental JavaScript”.

+ +

Ver também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/filtro/index.html b/files/pt-br/web/javascript/reference/global_objects/array/filtro/index.html new file mode 100644 index 0000000000..c7b0c08915 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/filtro/index.html @@ -0,0 +1,227 @@ +--- +title: Array.prototype.filter() +slug: Web/JavaScript/Reference/Global_Objects/Array/filtro +tags: + - Array + - ECMAScript 5 + - JavaScript + - Prototype + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/filter +--- +
{{JSRef}}
+ +

O método filter() cria um novo array com todos os elementos que passaram no teste implementado pela função fornecida.

+ +
function isBigEnough(value) {
+  return value >= 10;
+}
+
+var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
+// filtrado é [12, 130, 44]
+
+ +

Sintaxe

+ +
var newArray = arr.filter(callback[, thisArg])
+ +

Parâmetros

+ +
+
callback
+
Função é um predicado, para testar cada elemento do array. Retorna true para manter o elemento, false caso contrário, recebendo três argumentos:
+
+
+
element
+
+

O elemento que está sendo processado no array.

+
+
index
+
O índice do elemento atual que está sendo processado no array.
+
array
+
O array para qual filter foi chamada.
+
+
+
thisArg {{Optional_inline}}
+
Opcional. Valor a ser usado como this durante a execução do callback.
+
+ +

Valor de retorno

+ +

Um novo array com os elementos que passaram no teste.

+ +

Descrição

+ +

filter() chama a função callback fornecida, uma vez para cada elemento do array, e constrói um novo array com todos os valores para os quais o callback retornou o valor true ou  um valor que seja convertido para true. O callback é chamado apenas para índices do array que possuem valores atribuídos; Ele não é invocado para índices que foram excluídos ou para aqueles que não tiveram valor atribuído. Elementos do array que não passaram no teste do callback são simplesmente ignorados, e não são incluídos no novo array.

+ +

callback é invocado com estes três argumentos:

+ +
    +
  1. o valor do elemento
    2. +
  2. o índice do elemento
    3. +
  3. o objeto do array a ser preenchido
    4. +
+ +

Se o parâmetro thisArg for provido para o filter, ele será passado para o callback quando invocado, para ser usado como o valor do this. Caso contrário, será passado undefined como o valor de this. O valor do this finalmente observado pela função de callback é determinado de acordo com a regra que define o valor do this geralmente visto por uma função.

+ +

filter() não altera o array a partir da qual foi invocado.

+ +

O intervalo de elementos processados pela função filter() é definido antes da invocação do primeiro callback. Elementos que forem adicionados ao array depois da invocação do filter() não serão visitados pelo callback. Se elementos existentes no array forem alterados ou deletados, os valores deles que serão passados para o callback são os que eles tiverem quando o  filter() visitá-los; Elementos que forem deletados não são visitados.

+ +

Exemplos

+ +

Exemplo: Filtrando todos os valores pequenos

+ +

Os exemplos a seguir usam filter() para criar um array filtrado em que todos os elementos com valores menores que 10 são removidos.

+ +
function isBigEnough(value) {
+  return value >= 10;
+}
+var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
+// filtered is [12, 130, 44]
+
+ +

Exemplo: Filtrando entradas inválidas para JSON

+ +

O exemplo a seguir usa filter() para criar um JSON filtrado com todos seus elementos diferentes de zero, e id numérico.

+ +
var arr = [
+  { id: 15 },
+  { id: -1 },
+  { id: 0 },
+  { id: 3 },
+  { id: 12.2 },
+  { },
+  { id: null },
+  { id: NaN },
+  { id: 'undefined' }
+];
+
+var invalidEntries = 0;
+
+function filterByID(obj) {
+  if ('id' in obj && typeof(obj.id) === 'number' && !isNaN(obj.id)) {
+    return true;
+  } else {
+    invalidEntries++;
+    return false;
+  }
+}
+
+var arrByID = arr.filter(filterByID);
+
+console.log('Filtered Array\n', arrByID);
+// [{ id: 15 }, { id: -1 }, { id: 0 }, { id: 3 }, { id: 12.2 }]
+
+console.log('Number of Invalid Entries = ', invalidEntries);
+// Number of Invalid Entries = 4
+
+ +

Procurando em um array

+ +

O exemplo a seguir usa filter() para filtrar o conteúdo de um array baseado em um critério de busca

+ +
var fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];
+
+/**
+ * Array filters items based on search criteria (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']
+ +

Implementação ES2015

+ +
const fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];
+
+/**
+ * Array filters items based on search criteria (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']
+ +

Polyfill

+ +

filter() foi adicionado ao padrão ECMA-262 na 5ª edição; assim como pode não estar presente em todas as implementações do padrão. Você pode trabalhar com isso adicionando o seguinte código no início de seus scripts, permitindo o uso do filter() na implementação ECMA-262 que não tem suporte nativo. Esse algoritmo é exatamente aquele especificado na 5ª edição do ECMA-262, assumindo que fn.call veja o valor original de {{jsxref("Function.prototype.call()")}}, e que {{jsxref("Array.prototype.push()")}} tenha seu valor original.

+ +
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];
+
+        // NOTE: Technically this should Object.defineProperty at
+        //       the next index, as push can be affected by
+        //       properties on Object.prototype and Array.prototype.
+        //       But that method's new, and collisions should be
+        //       rare, so use the more-compatible alternative.
+        if (fun.call(thisArg, val, i, t)) {
+          res.push(val);
+        }
+      }
+    }
+
+    return res;
+  };
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES5.1', '#sec-15.4.4.20', 'Array.prototype.filter')}}{{Spec2('ES5.1')}}Definição inicial. Implementada no JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.filter', 'Array.prototype.filter')}}{{Spec2('ES6')}}
+ +

Compatibilidade de Browser

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

Veja também

+ + + + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/find/index.html b/files/pt-br/web/javascript/reference/global_objects/array/find/index.html new file mode 100644 index 0000000000..904f65c200 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/find/index.html @@ -0,0 +1,157 @@ +--- +title: Array.prototype.find() +slug: Web/JavaScript/Reference/Global_Objects/Array/find +translation_of: Web/JavaScript/Reference/Global_Objects/Array/find +--- +
{{JSRef}}
+ +

O método find() retorna o valor do primeiro elemento do array que satisfizer a função de teste provida. Caso contrario, {{jsxref("undefined")}} é retornado.

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

Veja também o método {{jsxref("Array.findIndex", "findIndex()")}}, que retorna o índice do elemento encontrado no array ao invés do seu valor.

+ +

Se você precisa encontrar a posição de um elemento ou se um elemento existe em um array, use {{jsxref("Array.prototype.indexOf()")}} ou {{jsxref("Array.prototype.includes()")}}.

+ +

Sintaxe

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

Parâmetros

+ +
+
callback
+
Função executada a cada iteração do array, recebendo três argumentos: +
+
element
+
O elemento atual que está sendo processado no array.
+
index{{optional_inline}}
+
O índice do elemento atualmente sendo processado no array.
+
array{{optional_inline}}
+
O array sobre o qual find foi chamado.
+
+
+
thisArg{{optional_inline}}
+
Opcional. Objeto usado como this quando executando o callback.
+
+ +

Valor retornado

+ +

O valor do primeiro elemento do array que satisfaz a função de teste fornecida; caso contrário, {{jsxref("undefined")}}.

+ +

Descrição

+ +

O método find executa a função callback uma vez para cada elemento presente no array até que encontre um onde callback  retorne o valor true. Se o elemento é encontrado, find retorna imediatamente o valor deste elemento. Caso contrário, find retorna {{jsxref("Global_Objects/undefined", "undefined")}}. O callback é acionado para todos os índices do array de 0 a tamanho-1, não apenas para aqueles que possuem valores atribuídos. Sendo assim, ele pode ser menos eficiente para arrays muito grandes em que existem outros métodos que só visitam os índices que tenham valor atribuído.

+ +

O callback é acionado com três argumentos: o valor do elemento, o índice do elemento e o objeto do Array que está sendo executado.

+ +

Se um parâmetro thisArg é provido ao find, ele será usado como o this para cada acionamento do callback. Se não for provido, então {{jsxref("Global_Objects/undefined", "undefined")}} é usado.

+ +

O find não altera a array à qual foi acionado.

+ +

O conjunto dos elementos processados por find é definido antes do primeiro acionamento do callback. Elementos que são anexados à array após o início da chamada ao find não serão visitados pelo callback. Se um elemento existente ainda não visitado da array for alterado pelo callback, o valor passado ao callback quando o visitar será o valor no momento que find visita o índice daquele elemento; elementos excluídos ainda são visitados.

+ +

Exemplos

+ +

Encontrar um objeto em um array por uma de suas propriedades

+ +
const inventory = [
+    {name: 'apples', quantity: 2},
+    {name: 'bananas', quantity: 0},
+    {name: 'cerejas', quantity: 5}
+];
+
+function isCherries(fruit) {
+    return fruit.name === 'cerejas';
+}
+
+console.log(inventory.find(isCherries));
+// { name: 'cerejas', quantity: 5 }
+ +

Utilizando arrow function

+ +
const inventory = [
+    {name: 'maças', quantity: 2},
+    {name: 'bananas', quantity: 0},
+    {name: 'cherries', quantity: 5}
+];
+
+const result = inventory.find( fruit => fruit.name === 'cherries' );
+
+console.log(result) // { name: 'cherries', quantity: 5 }
+ +

Encontrar um número primo em um array

+ +

O exemplo a seguir encontra um elemento dentro da array que é número primo (ou retorna {{jsxref("Global_Objects/undefined", "undefined")}} se não houverem números primos).

+ +
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, not found
+console.log([4, 5, 8, 12].find(isPrime)); // 5
+
+ +

Polyfill

+ +

Este método foi adicionado à especificação do ECMAScript 2015 e pode não estar disponível em todas as implementações do JavaScript. Entretanto, você pode fazer um polyfill para o Array.prototype.find com o trecho de código abaixo:

+ +
if (!Array.prototype.find) {
+  Array.prototype.find = function(predicate) {
+    if (this === null) {
+      throw new TypeError('Array.prototype.find 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 value;
+      }
+    }
+    return undefined;
+  };
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES6', '#sec-array.prototype.find', 'Array.prototype.find')}}{{Spec2('ES6')}}Definição inicial.
+ +

Compatibilidade do Navegador

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

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/findindex/index.html b/files/pt-br/web/javascript/reference/global_objects/array/findindex/index.html new file mode 100644 index 0000000000..75c677d20d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/findindex/index.html @@ -0,0 +1,127 @@ +--- +title: Array.prototype.findIndex() +slug: Web/JavaScript/Reference/Global_Objects/Array/findIndex +translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex +--- +
{{JSRef}}
+ +

O método findIndex() retorna o índice no array do primeiro elemento que satisfizer a função de teste provida. Caso contrário, retorna -1, indicando que nenhum elemento passou no teste.

+ +

Veja também o método {{jsxref("Array.find", "find()")}}, que retorna o valor de um elemento encontrado no array em vez de seu índice.

+ +

Sintaxe

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

Parâmetros

+ +
+
callback
+
Função para executar em cada valor no array, tomando três argumentos: +
+
element
+
O elemento atual sendo processado no array.
+
index
+
O índice do elemento atual sendo processado no array.
+
array
+
O array sobre o qual findIndex foi chamado.
+
+
+
thisArg
+
Opcional. Objeto para usar como this na execução do callback.
+
+ +

Descrição

+ +

O método findIndex executa a função callback uma vez para cada elemento presente no array até encontrar um onde o callback retorna um valor verdadeiro. Se tal elemento for encontrado, findIndex imediatamente retorna o índice deste elemento. Caso contrário, findIndex retorna -1. callback é invocado apenas para índices no array que têm valores atribuídos; nunca é invocado para índices que foram deletados ou que nunca tiveram valores atribuídos.

+ +

callback é invocado com três argumentos: o valor do elemento, o índice do elemento e o objeto Array sendo percorrido.

+ +

Se um parâmetro thisArg for fornecido para findIndex, ele será usado como o this para cada invocação do callback. Se não for fornecido, então {{jsxref("undefined")}} é usado.

+ +

findIndex não modifica o array sobre o qual é chamado.

+ +

A série de elementos processados por findIndex é definida antes da primeira invocação do callback. Elementos que são adicionados ao array depois que a chamada a findIndex começa não serão visitados pelo callback. Se um elemento existente não visitado do array for modificado pelo callback, seu valor passado ao callback será o valor no momento em que findIndex visitar o índice deste elemento; elementos que forem deletados não são visitados.

+ +

Exemplos

+ +

Encontrar o índice de um número primo em um array

+ +

O seguinte exemplo encontra o índice de um elemento no array que é um número primo (ou retorna -1 se não houver número primo).

+ +
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, não encontrado
+console.log([4, 6, 7, 12].findIndex(isPrime)); // 2
+
+ +

Polyfill

+ +

Esse método foi adicionado à especificação do ECMAScript 6 e pode não estar disponível em todas as implementações de JavaScript ainda. Contudo, você pode fazer o polyfill de Array.prototype.findIndex com o seguinte trecho de código:

+ +
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;
+  };
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES6', '#sec-array.prototype.findIndex', 'Array.prototype.findIndex')}}{{Spec2('ES6')}}Definição inicial.
{{SpecName('ESDraft', '#sec-array.prototype.findIndex', 'Array.prototype.findIndex')}}{{Spec2('ESDraft')}}
+ +

Compatibilidade de navegadores

+ +
{{Compat("javascript.builtins.Array.findIndex")}}
+ +
+ +
Veja também
+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/flat/index.html b/files/pt-br/web/javascript/reference/global_objects/array/flat/index.html new file mode 100644 index 0000000000..b14ffb006f --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/flat/index.html @@ -0,0 +1,121 @@ +--- +title: Array.prototype.flat() +slug: Web/JavaScript/Reference/Global_Objects/Array/flat +tags: + - Array + - Experimental + - JavaScript + - Method + - Prototype + - flat +translation_of: Web/JavaScript/Reference/Global_Objects/Array/flat +--- +
{{JSRef}} {{SeeCompatTable}}
+ +

O método flat() cria um novo array com todos elementos sub-arrays concatenados nele de forma recursiva até a profundidade especificada.

+ + + + + +

Sintaxe

+ +
var novoArray = arr.flat(depth)
+ +

Parâmetros

+ +
+
depth {{optional_inline}}
+
O nível de profundidade especifíca o quanto um array aninhando deve ser achatado. O Default é 1.
+
+ +

Retorno

+ +

Um novo array com os elementos sub-array concatenados nele.

+ +

Exemplos

+ +

Achatando arrays aninhados

+ +
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]
+
+const arr4 = [1, 2, [3, 4, [5, 6, [7, 8]]]];
+arr4.flat(Infinity);
+// [1, 2, 3, 4, 5, 6, 7, 8]
+ +

Achatando e buracos em array

+ +

o método flat remove espaços vazios do array:

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

Alternativa

+ +

reduce e concat

+ +
var arr1 = [1, 2, [3, 4]];
+arr1.flat();
+
+//achatar array de nível único
+arr1.reduce((acc, val) => acc.concat(val), []);
+// [1, 2, 3, 4]
+
+//para achatamentos mais profundos, use recursividade com reduce e concat
+var arr1 = [1,2,3,[1,2,3,4, [2,3,4]]];
+
+(function flattenDeep(arr1){
+   return arr1.reduce((acc, val) => Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val), []);
+})(arr1);
+
+// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]
+
+
+
+ +

Especificações

+ + + + + + + + + + + + + + +
EspecificaçãoStatusComentários
Array.prototype.flat proposalDraft
+ +

Compatibilidade em Navegadores

+ +
+ + +

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

+
+ +

Veja Também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/flatmap/index.html b/files/pt-br/web/javascript/reference/global_objects/array/flatmap/index.html new file mode 100644 index 0000000000..f75edaf3ef --- /dev/null +++ b/files/pt-br/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}} {{SeeCompatTable}}
+ +

O método flatMap() primeiro mapeia cada elemento usando uma função de mapeamento e, em seguida, nivela o resultado em um novo array. É idêntico a um map seguido por um flat de profundidade 1, mas flatMap é bastante útil e mescla ambos em um método um pouco mais eficiente.\{{EmbedInteractiveExample("pages/js/array-flatmap.html")}}

+ + + +

Sintaxe

+ +
var new_array = arr.flatMap(function callback(currentValue[, index[, array]]) {
+    // retorna o elemento para new_array
+}[, thisArg])
+ +

Parâmetros

+ +
+
callback
+
Função que produz um elemento de uma nova Array, pegando três argumentos: +
+
+
currentValue
+
O valor atual sendo processo na array.
+
index{{optional_inline}}
+
O index do valor atual sendo processo na array.
+
array{{optional_inline}}
+
+ +

O map da array que foi chamado.

+
+
thisArg{{optional_inline}}
+
Valor para ser usado como this quando callback estiver sendo executado.
+
+ +

Valor de retorno

+ +

Uma nova array com cada elemento sendo o resultado da função callback e achatado ao valor de 1.

+ +

Descrição

+ +

Veja {{jsxref("Array.prototype.map()")}} para uma detalhada descrição da função callback. O método flatMap é idêntico ao map seguido por um chamado a flatten de profundidade 1.

+ +

Exemplos

+ +

map e flatMap

+ +
var arr1 = [1, 2, 3, 4];
+
+arr1.map(x => [x * 2]);
+// [[2], [4], [6], [8]]
+
+arr1.flatMap(x => [x * 2]);
+// [2, 4, 6, 8]
+
+//  Só o primeiro nível
+arr1.flatMap(x => [[x * 2]]);
+// [[2], [4], [6], [8]]
+
+ +

Enquanto que acima poderíamos alcançar apenas com a utilização de map, já aqui temos um exemplo onde flatMap é mais apropriado.

+ +

Vamos gerar uma lista de palavras a partir de uma lista de sentenças.

+ +
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"]
+
+ +

Perceba, o comprimento da lista de saída pode ser diferente do comprimento da lista de entrada.

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

Alternativa

+ +

reduce e concat

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

Especificações

+ + + + + + + + + + + + + + +
SpecificationStatusComment
Array.prototype.flatMap proposalRascunho
+ +

Compatibilidade de browser

+ +
+ + +

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

+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/foreach/index.html b/files/pt-br/web/javascript/reference/global_objects/array/foreach/index.html new file mode 100644 index 0000000000..3ff4e43901 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/foreach/index.html @@ -0,0 +1,212 @@ +--- +title: Array.prototype.forEach() +slug: Web/JavaScript/Reference/Global_Objects/Array/forEach +translation_of: Web/JavaScript/Reference/Global_Objects/Array/forEach +--- +
{{JSRef}}
+ +

O método forEach() executa uma dada função em cada elemento de um array.

+ +

Sintaxe

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

Parâmetros

+ +
+
callback
+
Função para executar em cada elemento, recebendo três argumentos: +
+
currentValue
+
O valor atual do elemento sendo processado no array.
+
index {{optional_inline}}
+
O índice do elemento atual sendo processado no array.
+
array {{optional_inline}}
+
O array que forEach() está sendo aplicado.
+
+
+
thisArg {{optional_inline}}
+
Opcional. Valor a ser usado como this quando executar callback.
+
+ +

Valor retornado

+ +

undefined.

+ +

Descrição

+ +

O forEach executa o callback fornecido uma vez para cada elemento da ordem com um valor atribuido. Ele não é invocado para propriedades de índices que foram deletados ou que não foram inicializados (por ex. em arrays esparsos).

+ +

callback é invocado com três argumentos:

+ + + +

Se um parâmetro thisArg for passado para forEach(), ele será passado para o callback  quando invocado como valor para this.  Caso contrário, o valor {{jsxref("undefined")}} será passado como valor para this. O valor de this assumido no callback é determinado de acordo com as regras usuais para determinação do this visto por uma função.

+ +

O intervalo dos elementos processados por forEach() é determinado antes da primeira invocação do callback. Elementos que forem adicionados ao array depois da chamada ao forEach() começar não serão visitados pelo callback. Se os valores dos elementos existentes do array forem alterados, o valor passado para o callback será o valor no momento em que o forEach() visitá-los; elementos que forem deletados antes de serem visitados não serão visitados.

+ +

forEach() executa a a função callback uma vez para cada elemento do array – diferentemente de {{jsxref("Array.prototype.map()", "map()")}} ou {{jsxref("Array.prototype.reduce()", "reduce()")}}, ele sempre retorna o valor {{jsxref("undefined")}} e não é encadeável. O caso de uso típico é alterar o array no final do loop.

+ +
+

A única maneira de parar ou interromper um loop forEach() é disparando uma exceção. Se você precisa desse recurso, o método forEach() é a ferramenta errada. Você estará mais bem servido com um loop simples nesse caso. Se estiver testando o array de elementos para um predicado e precisar de um valor de retorno Boleano, você pode usar {{jsxref("Array.prototype.every()", "every()")}} ou {{jsxref("Array.prototype.some()", "some()")}}. Se estiverem disponíveis, os novos métodos {{jsxref("Array.prototype.find()", "find()")}} e {{jsxref("Array.prototype.findIndex()", "findIndex()")}} também podem ser usados para terminação antecipada em predicados verdadeiros.

+
+ +

Exemplos

+ +

Imprimindo os conteúdos de uma ordem

+ +

Os códigos a seguir logam uma linha para cada elemento na ordem:

+ +
function logArrayElements(element, index, array) {
+    console.log("a[" + index + "] = " + element);
+}
+[2, 5, 9].forEach(logArrayElements);
+// logs:
+// a[0] = 2
+// a[1] = 5
+// a[2] = 9
+
+ +

Função para cópia de um objeto

+ +

O código a seguir cria uma cópia para cada objeto dado. Há diferentes formas de criar uma cópia para um objeto. Esta é somente uma forma de explicar como  Array.prototype.forEach funciona. Ela usa um grupo de novas funções ECMAScript 5 Object.*

+ +
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 looks like o1 now
+
+ +

Compatibilidade

+ +

forEach é uma adição recente para o ECMA-262 standard; assim sendo, pode não estar presente em outras implementações do standard. Você pode contornar isto pela inserção do código a seguir no começo de seus scripts, permitindo o uso de forEach em implementações que normalmente não possuem este suporte.

+ +
if ( !Array.prototype.forEach ) {
+  Array.prototype.forEach = function(fn, scope) {
+    for(var i = 0, len = this.length; i < len; ++i) {
+      fn.call(scope, this[i], i, this);
+    }
+  };
+}
+
+ +

Um algorítimo 100% verdadeiro para a 5ª Edição do ECMA-262, pode ser visto abaixo:

+ +

O algoritmo é exatamente o especificado na 5ª Edição da  ECMA-262, assumindo Object e TypeError possuem seus valores originais e avalia callback.call para o valor original de Function.prototype.call.

+ +
// Production steps of ECMA-262, Edition 5, 15.4.4.18
+// Reference: http://es5.github.com/#x15.4.4.18
+if ( !Array.prototype.forEach ) {
+
+  Array.prototype.forEach = function forEach( callback, thisArg ) {
+
+    var T, k;
+
+    if ( this == null ) {
+      throw new TypeError( "this is null or not defined" );
+    }
+
+    // 1. Let O be the result of calling ToObject passing the |this| value as the argument.
+    var O = Object(this);
+
+    // 2. Let lenValue be the result of calling the Get internal method of O with the argument "length".
+    // 3. Let len be ToUint32(lenValue).
+    var len = O.length >>> 0; // Hack to convert O.length to a UInt32
+
+    // 4. If IsCallable(callback) is false, throw a TypeError exception.
+    // See: http://es5.github.com/#x9.11
+    if ( {}.toString.call(callback) !== "[object Function]" ) {
+      throw new TypeError( callback + " is not a function" );
+    }
+
+    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+    if ( thisArg ) {
+      T = thisArg;
+    }
+
+    // 6. Let k be 0
+    k = 0;
+
+    // 7. Repeat, while k < len
+    while( k < len ) {
+
+      var kValue;
+
+      // a. Let Pk be ToString(k).
+      //   This is implicit for LHS operands of the in operator
+      // b. Let kPresent be the result of calling the HasProperty internal method of O with argument Pk.
+      //   This step can be combined with c
+      // c. If kPresent is true, then
+      if ( Object.prototype.hasOwnProperty.call(O, k) ) {
+
+        // i. Let kValue be the result of calling the Get internal method of O with argument Pk.
+        kValue = O[ k ];
+
+        // ii. Call the Call internal method of callback with T as the this value and
+        // argument list containing kValue, k, and O.
+        callback.call( T, kValue, k, O );
+      }
+      // d. Increase k by 1.
+      k++;
+    }
+    // 8. return undefined
+  };
+}
+
+ +

Compatibilidade de Browser

+ +

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

+ +

Specifications

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES5.1', '#sec-15.4.4.18', 'Array.prototype.forEach')}}{{Spec2('ES5.1')}}Definição inicial. Implementado no 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')}}
+ +

Veja também

+ + 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 +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Resumo

+ +

O método Array.from() cria uma nova instância de um Array quando for passado um array-like ou um iterable object como argumento.

+ +

No  ES6, a sintaxe de classe permite a subclassificação de classes nativas e classes definidas pelo usuário; como resultado, os métodos estáticos pertencentes a classe, como Array.from, são "herdadas" por subclasses do Array e criam novas instâncias da subclasse, não do Array.

+ +

Sintaxe

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

Parâmetros

+ +
+
arrayLike
+
Um array-like ou um objeto iterável para converter em array.
+
mapFn
+
Opcional. Função Map que será chamada para cada elemento do array.
+
thisArg
+
Opcional. Valor a ser utilizado como this quando a mapFn for chamada.
+
+ +

Descrição

+ +

Array.from() deixa você criar um Array de:

+ + + +

Array.from() tem um parametro opcional mapFn, 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, Array.from(obj, mapFn, thisArg) é o mesmo que Array.from(obj).map(mapFn, thisArg), com a excessão de não cria um array intermediário . Isso é importante, principalmente para certas subclasses de array, como typed array, no qual o array intermediário iria necessáriamente ter o valor truncado para encaixar-se no tipo apropriado.

+ +

A propriedade length do método from() é 1.

+ +

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 Array.from() são "herdados" pelas subclasses de Array, e cria novas instâncias da subclasse, não de Array.

+ +

Polyfill

+ +

Array.from foi adicionado ao padrão ECMA-262 em sua 6ª edição; desta forma, não está presente na aplicações anteriores da especificação. Na ausência do código nativo, você pode inserir o código seguinte no início do script, permitindo o uso parcial da funcionalidade do Array.from.  Esse algorítmo  é equivalente ao especificado no ECMA-262, 6ª edição, exceto que Object e TypeError tem seus valores originais e que callback.call retorna o valor original de {{jsxref("Function.prototype.call")}}. Além disso, os verdadeiros iterables não podem ser representados genéricamente no polyfill, criando a principal distinção do que foi definido na especificação.

+ +
// 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;
+    };
+  }());
+}
+
+ +

Exemplos

+ +
// 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]
+
+ +

Especificação

+ + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES6', '#sec-array.from', 'Array.from')}}{{Spec2('ES6')}}Initial definition.
+ +

compatibilidade com navegadores

+ +
+

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

+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/index.html b/files/pt-br/web/javascript/reference/global_objects/array/index.html new file mode 100644 index 0000000000..6130c8d949 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/index.html @@ -0,0 +1,511 @@ +--- +title: Array +slug: Web/JavaScript/Reference/Global_Objects/Array +tags: + - Array + - JavaScript + - NeedsTranslation + - Refer + - TopicStub +translation_of: Web/JavaScript/Reference/Global_Objects/Array +--- +

{{JSRef("Global_Objects", "Array")}}

+ +

Sumário

+ +

O objeto Array do JavaScript é um objeto global usado na construção de 'arrays': objetos de alto nível semelhantes a listas.

+ +

Criando um Array

+ +
var frutas = ['Maçã', 'Banana'];
+
+console.log(frutas.length);
+// 2
+
+ +

Acessar um item (index) do Array

+ +
var primeiro = frutas[0];
+// Maçã
+
+var ultimo = frutas[frutas.length - 1];
+// Banana
+ +

Iterar um Array

+ +
frutas.forEach(function (item, indice, array) {
+  console.log(item, indice);
+});
+// Maçã 0
+// Banana 1
+ +

Adicionar um item ao final do Array

+ +
var adicionar = frutas.push('Laranja');
+// ['Maçã', 'Banana', 'Laranja']
+ +

Remover um item do final do Array

+ +
var ultimo = frutas.pop(); // remove Laranja (do final)
+// ['Maçã', 'Banana'];
+ +

Remover do início do Array

+ +
var primeiro = frutas.shift(); // remove Maçã do início
+// ['Banana'];
+ +

Adicionar ao início do Array

+ +
var adicionar = frutas.unshift('Morango') // adiciona ao início
+// ['Morango', 'Banana'];
+ +

Procurar o índice de um item na Array

+ +
frutas.push('Manga');
+// ['Morango', 'Banana', 'Manga']
+
+var pos = frutas.indexOf('Banana');
+// 1
+ +

Remover um item pela posição do índice

+ +
var removedItem = frutas.splice(pos, 1); // é assim que se remove um item
+// ['Morango', 'Manga']
+ +

Remover itens de uma posição de índice

+ +
var vegetais = ['Repolho', 'Nabo', 'Rabanete', 'Cenoura'];
+console.log(vegetais);
+// ['Repolho', 'Nabo', 'Rabanete', 'Cenoura']
+
+var pos = 1, n = 2;
+
+var itensRemovidos = vegetais.splice(pos, n);
+// Isso é como se faz para remover itens, n define o número de itens a se remover,
+// a partir da posição (pos) em direção ao fim da array.
+
+console.log(vegetais);
+// ['Repolho', 'Cenoura'] (o array original é alterado)
+
+console.log(itensRemovidos);
+// ['Nabo', 'Rabanete']
+ +

Copiar um Array

+ +
var copiar = frutas.slice(); // é assim que se copia
+// ['Morango', 'Manga']
+ +

 

+ +

Sintaxe

+ +
[element0, element1, ..., elementN]
+new Array(element0, element1, ..., elementN)
+new Array(arrayLength)
+
+ +
+
element0, element1, ..., elementN
+
Um array JavaScript é inicializado com os elementos contém,  exceto no caso onde um único argumento é passado para o construtor do Array e esse argumento é um número (veja o parâmetro arrayLength abaixo).  Esse caso especial só se aplica para os arrays JavaScript criados com o construtor Array , e não para literais de array criados com a sintaxe de colchetes [].
+
arrayLength
+
Se o único argumento passado para o construtor do Array for um número inteiro entre 0 and 232-1 (inclusive), um novo array com o tamanho desse número é retornado. Se o argumento for qualquer outro número, uma exceção RangeError é lançada.
+
+ +

Descrição

+ +

Arrays são objetos semelhantes a listas que vêm com uma série de  métodos embutidos para realizar operações de travessia e mutação. Nem o tamanho de um array JavaScript nem os tipos de elementos são fixos. Já que  o tamanho de um array pode ser alterado a qualquer momento e os dados podem ser armazenados em posições não contíguas, arrays JavaScript não tem a garantia de serem densos; isso depende de como o programador escolhe usá-los. De uma maneira geral, essas são características convenientes, mas, se esses recursos não são desejáveis para o seu caso em particular, você pode considerar usar arrays tipados.

+ +

Arrays não podem usar strings como índices (como em um array associativo), devem ser usados números inteiros. Definir ou acessar não-inteiros usando notação de colchetes (ou notação de ponto) não vai definir ou recuperar um elemento do array em si, mas sim definir ou acessar uma variável associada com a coleção de propriedades de objeto daquele array. As propriedades de objeto do array e a lista de elementos do array são separados, e as operações de travessia e mutação não podem ser aplicadas a essas propriedades nomeadas.

+ +

Accessando elementos de um array 

+ +

Arrays JavaScript começam com índice zero: o primeiro elemento de um array está na posição 0 e o último elemento está na  posição equivalente ao valor da propriedade length (tamanho) menos 1.

+ +
var arr = ['este é o primeiro elemento', 'este é o segundo elemento'];
+console.log(arr[0]);              // exibe 'este é o primeiro elemento'
+console.log(arr[1]);              // exibe 'este é o segundo elemento'
+console.log(arr[arr.length - 1]); // exibe 'este é o segundo elemento'
+
+ +

Elementos de um array são somente propriedades de objetos, da forma que toString é uma propriedade. Contudo, note que tentando acessar o primeiro elemento de um array da seguinte forma causará um erro de sintaxe, pois o nome da propriedade é inválido:

+ +
console.log(arr.0); // um erro de sintaxe
+
+ +

Não há nada de especial a respeito de arrays JavaScript e suas propriedades que causam isso. As propriedades JavaScript que começam com um dígito não podem ser referenciadas com notação de ponto. Elas necesitam usar notação de colchetes para poderem ser acessadas. Por exemplo, se você tivesse um objeto com a propriedade "3d", também teria que ser referenciá-la usando notação de colchetes. Por exemplo:

+ +
var anos = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
+console.log(anos.0); // um erro de sintaxe
+console.log(anos[0]); // funciona corretamente
+
+ +
renderer.3d.setTexture(model, 'personagem.png'); // um erro de sintaxe
+renderer['3d'].setTexture(model, 'personagem.png'); //funciona corretamente
+
+ +

Note que no exemplo 3d, '3d' teve de ser colocado entre aspas. É possivel também colocar entre aspas os índices de arrays JavaScript (ou seja, years['2'] ao invés de years[2]), contudo isto não é necessário. O valor 2 em years[2] eventualmente será convertido a uma string pela engine do JavaScript  através de uma conversão explicita com o método toString. E é por esta razão que  '2' e '02' irão referenciar dois slots diferentes no objeto anos e o seguinte exemplo pode ser true:

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

De forma similar, propriedades de objeto que sejam palavras reservadas(!) só podem ser acessadas como strings em notação de colchetes:

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

Relação entre length e propriedades numéricas

+ +

As propriedades length e numéricas de um array Javascript são conectadas. Varios dos métodos javascript pré-definidos (por exemplo, join, slice, indexOf etc.) levam em conta o valor da propriedade length de um array quando eles são chamados. Outros métodos (por exemplo, push, splice etc.) também resultam em uma atualização na propriedade length do array.

+ +
var frutas = [];
+frutas.push('banana', 'maça', 'pêssego');
+
+console.log(frutas.length); // 3
+ +

Quando configurar uma propriedade num array Javascript em que a propriedade é um índice valido do array e este índice está fora do atual limite do array, o array irá crescer para um tamanho grande o suficiente para acomodar o elemento neste índice, e a engine irá atualizar a propriedade length do array de acordo com isto:

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

Configurar a propriedade length diretamente, também resulta em um comportamento especial:

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

Diminuir o valor de length, entretanto, apaga elementos:

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

Criando um array usando o resultado de uma comparação

+ +

O resultado de uma comparação entre uma expressão regular e uma string pode criar um array Javascript. Este array tem propriedades e elementos que disponibilizam informações sobre a comparação. Esse array é o valor de retorno dos métodos {{jsxref("RegExp.exec")}}, {{jsxref("String.match")}}, e {{jsxref("String.replace")}}. Para explicar melhor sobre estas propriedades e elementos, veja o seguinte exemplo e então consulte a tabela abaixo:

+ +
// Encontra um d seguido por um ou mais b's seguido por um d
+// Salva os b's encontrados e o d seguinte
+// Ignora caixa (maiúscula/minúscula)
+
+var minhaRegex = /d(b+)(d)/i;
+var meuArray = minhaRegex.exec('cdbBdbsbz');
+
+ +

As propriedades e elementos retornados desta comparação são os seguintes:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Propriedade/ElementoDescriçãoExemplo
input +

Uma propriedade somente-leitura que reflete a string original a qual a expressão regular foi comparada.

+ 		cdbBdbsbz
indexUma propriedade somente-leitura que é o índice baseado em zero da comparação na string.1
[0]Um elemento somente-leitura que especifica os ultimos caracteres que foram encontrados.dbBd
[1], ...[n]Elementos somente-leitura que especificam as substrings de comparações entre parênteses encontradas, se incluidas na expressão regular. O número de possíveis substrings entre parenteses é ilimitado.[1]: bB
+ [2]: d
+ +

Propriedades

+ +
+
Array.length
+
Propriedade comprimento do construtor Array, cujo valor é 1.
+
{{jsxref("Array.@@species", "get Array[@@species]")}}
+
A função de construtor que é utilizada para criar objetos derivados.
+
+ +
+
{{jsxref("Array.prototype")}}
+
Permite a adição de propriedades para todos os objetos array.
+
+ +

Métodos

+ +
+
+
{{jsxref("Array.from()")}}
+
Cria uma nova instância de Array a partir de um objeto semelhante ou iterável.
+
{{jsxref("Array.isArray()")}}
+
Retorna true se a variável é um array e false caso contrário.
+
{{jsxref("Array.of()")}}
+
Cria uma nova instância de Array com um número variável de argumentos, independentemente do número ou tipo dos argumentos.
+
+
+ +
 
+ +

Instâncias de Array

+ +

Todas as instâncias de Array herdam de Array.prototype.  O protótipo do construtor Array pode ser modificado de forma a afetar todas as instâncias de Array.

+ +

Propriedades

+ +
{{ page('/pt-BR/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Properties') }}
+ +

Métodos

+ +

Métodos modificadores

+ +
{{ page('/pt-BR/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Mutator_methods') }}
+ +

Métodos de acesso

+ +
{{ page('/pt-BR/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Accessor_methods') }}
+ +

Métodos de iteração

+ +
{{ page('/pt-BR/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Iteration_methods') }}
+ +

Métodos genéricos de Array

+ +
+

Métodos genéricos de arrays não seguem o padrão, são obsoletos e serão removidos em breve.

+
+ +

Algumas vezes você poderá querer aplicar métodos de arrays para strings ou outros objetos parecidos com arrays (como em argumentos de funções). Ao fazer isto, você trata uma string como um array de caracteres (ou em outros casos onde trata-se não-arrays como um array).  Por exemplo,  para checar se cada caractere em uma varivável str é uma letra, você poderia escrever:

+ +
function isLetter(character) {
+  return (character >= "a" && character <= "z");
+}
+
+if (Array.prototype.every.call(str, isLetter))
+  alert("A string '" + str + "' contém somente letras!");
+
+ +

Esta notação é um pouco despendiosa e o JavaScript 1.6 introduziu a seguinte abreviação genérica:

+ +
if (Array.every(isLetter, str))
+  alert("A string '" + str + "' contém somente letras!");
+
+ +

Generics também estão disponíveis em String.

+ +

Estes não são atualmente parte dos padrões ECMAScript (através do ES2015 Array.from() pode se conseguir isto). A seguir segue uma adaptação para permitir o uso em todos os navegadores:

+ +
/*globals define*/
+// Assumes Array extras already present (one may use shims for these as well)
+(function () {
+    'use strict';
+
+    var i,
+        // We could also build the array of methods with the following, but the
+        //   getOwnPropertyNames() method is non-shimable:
+        // 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', 'isArray'
+        ],
+        methodCount = methods.length,
+        assignArrayGeneric = function (methodName) {
+            var method = Array.prototype[methodName];
+            Array[methodName] = function (arg1) {
+                return method.apply(arg1, Array.prototype.slice.call(arguments, 1));
+            };
+        };
+
+    for (i = 0; i < methodCount; i++) {
+        assignArrayGeneric(methods[i]);
+    }
+}());
+ +

Exemplos

+ +

Exemplo: Criando um array

+ +

O exemplo a seguir cria um array, msgArray, com length 0, então atribui valores para msgArray[0] e msgArray[99], trocando o length do array para 100.

+ +
var msgArray = new Array();
+msgArray[0] = "Hello";
+msgArray[99] = "world";
+
+if (msgArray.length == 100)
+   print("O length é 100.");
+
+ +

Exemplo: Criando um array bi-dimensional

+ +

O exemplo a seguir cria um tabuleiro de xadrez usando dois arrays bi-dimensionais de string. A primeira jogada é feita copiando o 'p' em 6,4 para 4,4.  A posição antiga de 6,4 é colocada em branco.

+ +
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']];
+print(board.join('\n') + '\n\n');
+
+// Fazendo o King's Pawn avançar 2
+board[4][4] = board[6][4];
+board[6][4] = ' ';
+print(board.join('\n'));
+
+ +

Saída:

+ +
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
+
+ +

Utilizando um array para tabular um conjunto de valores

+ +
values = [];
+for (var x = 0; x < 10; x++){
+ values.push([
+  2 ** x,
+  2 * x ** 2
+ ])
+};
+console.table(values)
+ +

Saída:

+ +
0	1	0
+1	2	2
+2	4	8
+3	8	18
+4	16	32
+5	32	50
+6	64	72
+7	128	98
+8	256	128
+9	512	162
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Definição inicial
{{SpecName('ES5.1', '#sec-15.4', 'Array')}}{{Spec2('ES5.1')}}Novos metodos adicionados: {{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')}}Novos metodos adicionados: {{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('ESDraft', '#sec-array-objects', 'Array')}}{{Spec2('ESDraft')}}Novo metodo adicionado: {{jsxref("Array.prototype.includes()")}}
+ +

Compatibilidade com os navegadores

+ +

{{ CompatibilityTable }}

+ +
+ + + + + + + + + + + + + + + + + + + +
ConfiguraçãoChromeFirefox (Gecko)Internet ExplorerOperaSafari (WebKit)
Suporte básico{{ CompatVersionUnknown }}{{ CompatVersionUnknown }}{{ CompatVersionUnknown }}{{ CompatVersionUnknown }}{{ CompatVersionUnknown }}
+
+ +
+ + + + + + + + + + + + + + + + + + + +
ConfiguraçãoAndroidFirefox Mobile (Gecko)IE PhoneOpera MobileSafari Mobile
Suporte básico{{ CompatVersionUnknown }}{{ CompatVersionUnknown }}{{ CompatVersionUnknown }}{{ CompatVersionUnknown }}{{ CompatVersionUnknown }}
+
+ +

Ver também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/indexof/index.html b/files/pt-br/web/javascript/reference/global_objects/array/indexof/index.html new file mode 100644 index 0000000000..1cb6328be8 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/indexof/index.html @@ -0,0 +1,186 @@ +--- +title: Array.prototype.indexOf() +slug: Web/JavaScript/Reference/Global_Objects/Array/indexOf +tags: + - Array + - JavaScript + - Método(2) + - Prototype + - Referência(2) + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/indexOf +--- +
{{JSRef}}
+ +
O método indexOf() retorna o primeiro índice em que o elemento pode ser encontrado no array, retorna -1 caso o mesmo não esteja presente.
+ +

Sintaxe

+ +
array.indexOf(elementoDePesquisa, [pontoInicial = 0])
+ +

Parâmetros

+ +
+
elementoDePesquisa
+
Elemento a ser pesquisado no array.
+
pontoInicial
+
O índice para iniciar a procura. Se o índice for maior ou igual ao tamanho do array, é retornado -1 e signfica que o item não será procurado. Se o pontoInicial é fornecido com um número negativo,  é tomado como deslocamento da extremidade do array. Nota: se o pontoInicial fornecido é negativo, a procura no array acontece de frente para trás. Se o pontoInicial fornecido é 0, então o array inteiro será pesquisado. Padrão: 0 (pesquisa em todo array).
+
+ +

Descrição

+ +

indexOf() compara o  elementoDePesquisa com os elementos do Array usando igualdade estrita (o mesmo método usado pelo ===, ou triple-equals operator). 

+ +

Exemplos

+ +

Usando indexOf()

+ +

O exemplo seguinte usa indexOf() para localizar valores em um array

+ +
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
+
+ +

Encontrar todas as ocorrências de um elemento

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

Encontrar se um elemento existe ou não e atualizar o array

+ +
function atualizarColecaoVegetais (vegetais, vegetal) {
+    if (vegetais.indexOf(vegetal) === -1) {
+        vegetais.push(vegetal);
+        console.log('Nova coleção de vegetais é : ' + vegetais);
+    } else if (vegetais.indexOf(vegetal) > -1) {
+        console.log(vegetal + ' já existe na coleção de vegetais.');
+    }
+}
+
+var vegetais = ['batata', 'tomate', 'pimenta', 'pimentao'];
+
+atualizarColecaoVegetais(vegetais, 'espinafre');
+// Nova coleção de vegatais é : batata,tomate,pimenta,pimentao,espinafre
+atualizarColecaoVegetais(vegetais, 'espinafre');
+// espinafre já existe na coleção de vegetais.
+
+ +

Polyfill

+ +

indexOf() foi adicionado ao ECMA-262 standard em sua 5 edição; como tal, não pode estar presente em todos navegadores.Você pode contornar isso utilizando o seguinte codigo no inicio de seus scripts. Isto permitirá que voce use o indexOf() quando não possuir suporte nativo. Esse algoritmo corresponde ao especificado no ECMA-262, edição 5, assumindo {{jsxref("Global_Objects/TypeError", "TypeError")}} e {{jsxref("Math.abs()")}} tem seus valores originais.

+ +
// Passos para a produção do ECMA-262, Edition 5, 15.4.4.14
+// Referência: http://es5.github.io/#x15.4.4.14
+if (!Array.prototype.indexOf) {
+  Array.prototype.indexOf = function(elementoDePesquisa, pontoInicial) {
+
+    var k;
+
+    //1. Deixe-o ser o resultado da chamada de toObject
+    // passando o valor de this como argumento.
+    if (this == null) {
+      throw new TypeError('"this" é nulo (null) ou não foi definido (undefined)');
+    }
+
+    var O = Object(this);
+
+    // 2. Deixar o tamanhoValor ser o resultado da
+    // chamada do método interno Get de 0 com o
+    // argumento "length"
+    // 3. Deixar o  tamanhoValor ser um ToUint32(tamanhoValor).
+    var tamanho = O.length >>> 0;
+
+    // 4. se o tamanho é 0, retorna -1.
+    if (tamanho === 0) {
+      return -1;
+    }
+
+    // 5. Se o argumento pontoInicial for passado,
+    // use o ToInteger(pontoInicial); senao use 0.
+    var n = + pontoInicial || 0;
+
+    if (Math.abs(n) === Infinity) {
+      n = 0;
+    }
+
+    //6. Se n >= tamanho, retorna -1.
+    if (n >= tamanho) {
+      return -1;
+    }
+
+    // 7. Se n>= 0, entao k seja n.
+    // 8. Senao, n<0, k seja tamanho - abs(n).
+    // Se k é menor que 0, entao k seja 0.
+    k = Math.max(n >= 0 ? n : tamanho - Math.abs(n), 0);
+
+    // 9. Repita, enquanto k < tamanho
+    while (k < tamanho) {
+      // a. Deixe Pk ser ToString(k).
+      //    isto é implicito para operandos LHS de um operador
+
+      // b. Deixe o kPresent  ser o resultado da chamada do método
+      //    interno de 0 com argumento Pk
+      //    Este passo pode ser combinado com c.
+      // c. Se kPresent é true, entao
+      //    i.  Deixe o  elementK ser o resultado da chamada do metodo
+      //        interno Get de 0 com argumento ToString(k)
+      //   ii.  Deixe o resultado ser aplicado pelo Algoritmo de
+      //        Comparação de Igualdade Estrita (Strict Equality Comparison)
+      //        para o elementoDePesquisa e elementK
+      //  iii.  caso verdadeiro, retorne k.
+      if (k in O && O[k] === elementoDePesquisa) {
+        return k;
+      }
+      k++;
+    }
+    return -1;
+  };
+}
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentários
{{SpecName('ES5.1', '#sec-15.4.4.14', 'Array.prototype.indexOf')}}{{Spec2('ES5.1')}} +

Definição inicial implementada no Javascript 1.6.

+
{{SpecName('ES6', '#sec-array.prototype.indexof', 'Array.prototype.indexOf')}}{{Spec2('ES6')}}
+ +

Compatibilidade entre Navegadores

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

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/isarray/index.html b/files/pt-br/web/javascript/reference/global_objects/array/isarray/index.html new file mode 100644 index 0000000000..328790b8e9 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/isarray/index.html @@ -0,0 +1,141 @@ +--- +title: Array.isArray() +slug: Web/JavaScript/Reference/Global_Objects/Array/isArray +translation_of: Web/JavaScript/Reference/Global_Objects/Array/isArray +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Sumário

+ +

O método Array.isArray() retorna true se um objeto é uma array, e false se não é.

+ +

Sintaxe

+ +
Array.isArray(obj)
+ +

Parâmetros

+ +
+
obj
+
O objeto a ser verificado.
+
+ +

Descrição

+ +

Se o objeto é um {{jsxref("Array")}}, retorna true(verdadeiro), caso contrário é retornado false(falso).

+ +

Veja o artigo “Determinando com absoluta precisão se um objeto em Javascript é ou não uma array” para mais detalhes.

+ +

Exemplos

+ +
// todas as chamadas conseguintes retornam true
+Array.isArray([]);
+Array.isArray([1]);
+Array.isArray(new Array());
+// Pequeno detalhe: Array.prototype por si só é uma array:
+Array.isArray(Array.prototype);
+
+// todas as conseguintes retornam 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 });
+
+ +

Polyfill

+ +

Executando o seguinte código antes de qualquer outro, o método Array.isArray() será criado, caso o browser não o disponibilize nativamente.

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

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES5.1', '#sec-15.4.3.2', 'Array.isArray')}}{{Spec2('ES5.1')}}Definição Inicial. Implementado em JavaScript 1.8.5.
{{SpecName('ES6', '#sec-array.isarray', 'Array.isArray')}}{{Spec2('ES6')}} 
+ +

Compatibilidade com o Browser

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte Básico{{CompatChrome("5")}}{{CompatGeckoDesktop("2.0")}}{{CompatIE("9")}}{{CompatOpera("10.5")}}{{CompatSafari("5")}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte Básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile("2.0")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Baseado na Tabela de Compatibilidade de Kangax.

+ +

Veja Também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/join/index.html b/files/pt-br/web/javascript/reference/global_objects/array/join/index.html new file mode 100644 index 0000000000..703cc76de0 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/join/index.html @@ -0,0 +1,108 @@ +--- +title: Array.prototype.join() +slug: Web/JavaScript/Reference/Global_Objects/Array/join +translation_of: Web/JavaScript/Reference/Global_Objects/Array/join +--- +
{{JSRef}}
+ +
O método join() junta todos os elementos de um array (ou um array-like object) em uma string e retorna esta string.
+ +

Sintaxe

+ +
arr.join([separador = ','])
+ +

Parâmetros

+ +
+
separador {{optional_inline}}
+
Específica uma string para separar cada elemento adjacente do array. O separador é convertido em uma string se necessário. Se omitido, os elementos do array são separados com uma vírgula (","). Se o separador for uma string vazia, todos os elementos são juntados sem nenhum caracter entre eles.
+
+ +

Valor de retorno

+ +
+
Uma string com todos os elementos do array juntos. Se arr.length é 0, uma string vazia é retornada.
+
+ +

Descrição

+ +

As conversões em string de todos os elementos de um array são juntados em apenas uma string.

+ +
+

Obs: Se um elemento é undefined ou null, ele é convertido em uma string vazia.

+
+ +

Exemplos

+ +

Juntando um array de quatro formas diferentes

+ +

O exemplo interativo a seguir cria um array, a, com três elementos, e o junta três vezes: a primeira com virgulas, a segunda so junta os elementos e a terceira com um sinal de menos.

+ +

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

+ + + + + +

Juntando um array-like object (objeto estilo-array)

+ +

O exemplo abaixo junta um array-like object (ex: o objeto arguments), chamando {{jsxref("Function.prototype.call")}} no 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);
+//saida esperada: "1,a,true"
+ + + +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Definição inicial. Implementado em 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')}}
+ +

Compatibilidade com o Browser

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

Veja Também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/keys/index.html b/files/pt-br/web/javascript/reference/global_objects/array/keys/index.html new file mode 100644 index 0000000000..99a61b896a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/keys/index.html @@ -0,0 +1,115 @@ +--- +title: Array.prototype.keys() +slug: Web/JavaScript/Reference/Global_Objects/Array/keys +tags: + - Iteração + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/keys +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Sumário

+ +

O método keys() retorna um novo Array Iterator que contém as chaves para cada index do array.

+ +

Sintaxe

+ +
arr.keys()
+ +

Exemplos

+ +

Exemplo: uso básico

+ +
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 }
+
+ +

Exemplo: keys iterator não ignora lacunas

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

Especificações

+ + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES6', '#sec-array.prototype.keys', 'Array.prototype.keys')}}{{Spec2('ES6')}}Definição inicial.
+ +

Compatibilidade de Browser

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte Básico{{CompatChrome("38")}}{{CompatGeckoDesktop("28")}}{{CompatNo}}{{CompatOpera("25")}}{{CompatSafari("7.1")}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte Básico{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("28")}}{{CompatNo}}{{CompatNo}}iOS 8
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/lastindexof/index.html b/files/pt-br/web/javascript/reference/global_objects/array/lastindexof/index.html new file mode 100644 index 0000000000..0dc189d7f1 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/lastindexof/index.html @@ -0,0 +1,184 @@ +--- +title: Array.prototype.lastIndexOf() +slug: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf +translation_of: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf +--- +
{{JSRef}}
+ +

O método lastIndexOf() retorna o ultimo índice que um certo elemento pode ser encontrado no array, ou -1 se o elemento não estiver presente. O array é pesquisado de trás para frente, começando pelo fromIndex.

+ +

Sintaxe

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

Parâmetros

+ +
+
searchElement
+
Elemento para ser localizado no array.
+
fromIndex
+
Opcional. O índice ao qual a busca será iniciada de traz para frente. O valor padrão é o tamanho total do array menos um (array.length -1), ou seja, todo o array será pesquisado. Se o índice for maior ou igual ao tamanho do array, o array inteiro será pesquisado. Se for negativo, ele é tomado como deslocamento no final do array. Note que mesmo se o índice for negativo, o array ainda será pesquisado de traz para frente. Se o índice calculado for menor que 0, -1 será retornado, ou seja, o array não será pesquisado.
+
+ +

Descrição

+ +

lastIndexOf compara searchElement a elementos do Array usando igualdade rigorosa (o mesmo método usado pelo operador ===, ou "igual triplo").

+ +

Exemplos

+ +

Examplo: Usando lastIndexOf

+ +

O seguinte exemplo utiliza lastIndexOf para localizar elementos em um array.

+ +
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
+
+ +

Exemplo: Encontrando todas as ocorrências de um elemento

+ +

O seguinte exemplo utiliza lastIndexOf para encontrar todos os índices de um elemento em um dado array, utilizando {{jsxref("Array.prototype.push", "push")}} para adicioná-los em outro array quando são encontrados.

+ +
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]
+
+ +

Note que devemos tratar o caso idx == 0 separadamente aqui pois o elemento será sempre encontrado independente do parâmetro fromIndex se ele for o primeiro elemento do array. Isso é diferente do método {{jsxref("Array.prototype.indexOf", "indexOf")}}.

+ +

Polyfill

+ +

lastIndexOf foi adicionado ao padrão ECMA-262 na 5ª edição; devido a isso, não deve estar presente em outras implementações do padrão. Você pode contornar isso inserindo o seguinte código no início dos seus scripts, permitindo o uso de lastIndexOf em implementações que não o suportam nativamente. Esse algorítimo é exatamente o mesmo especificado no padrão ECMA-262, 5ª edição, assumindo que {{jsxref("Global_Objects/Object", "Object")}}, {{jsxref("Global_Objects/TypeError", "TypeError")}}, {{jsxref("Global_Objects/Number", "Number")}}, {{jsxref("Math.floor")}}, {{jsxref("Math.abs")}}, e {{jsxref("Math.min")}} possuem seus valores originais.

+ +
// Production steps of ECMA-262, Edition 5, 15.4.4.15
+// Reference: http://es5.github.io/#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;
+  };
+}
+
+ +

Novamente, perceba que essa implementação foca na absoluta compatibilidade com lastIndexOf no Firefox e no motor JavaScript SpiderMonkey, incluíndo vários casos que são, indiscutivelmente, extremos. Se você pretende usar isso em aplicações reais, é possível calcular from com um código menos complicado se você ignorar esses casos.

+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES5.1', '#sec-15.4.4.15', 'Array.prototype.lastIndexOf')}}{{Spec2('ES5.1')}}Definição inicial. Implementado no JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.lastindexof', 'Array.prototype.lastIndexOf')}}{{Spec2('ES6')}} 
+ +

Compatibilidade de Browser

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatIE("9")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/length/index.html b/files/pt-br/web/javascript/reference/global_objects/array/length/index.html new file mode 100644 index 0000000000..a03b16502c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/length/index.html @@ -0,0 +1,128 @@ +--- +title: Array.prototype.length +slug: Web/JavaScript/Reference/Global_Objects/Array/length +translation_of: Web/JavaScript/Reference/Global_Objects/Array/length +--- +
{{JSRef}}
+ +

A propriedade length representa um inteiro de 32-bit sem sinal, que especifíca o número de elementos em um array.

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

Sintaxe

+ +
arr.length
+ +

Descrição

+ +

O valor da propriedade length é um inteiro com um sinal positivo e valor menor que 2 elevado na 32ª potência(232).

+ +

Você pode setar o a propriedade length para truncar um array a qualquer momento. Quando você extende um array mudando sua propriedade length, o numero de elementos atuais não é incrementado; por exemplo, se você setar o tamanho para 3 quando ele é atualmente 2, o array continua somente com 2 elementos. Assim, a propriedade length não diz nada sobre o tamanho de valores definidos no array. Veja também Relacionamento entre length e propriedades numéricas.

+ +

Exemplos

+ +

Iterando sobre um array

+ +

No exemplo a seguir numbers é iterado considerando a propriedade length para ver quantos elementos ele tem. O valor de cada elemento recebe então o dobro.

+ +
var numbers = [1, 2, 3, 4, 5];
+
+for (var i = 0; i < numbers.length; i++) {
+  numbers[i] *= 2;
+}
+// numbers is now [2, 4, 6, 8, 10]
+
+ +

Encurtando um array

+ +

O exemplo a seguir encurta o array  statesUS para um tamanho de 50 se o tamanho corrente for maior do que 50.

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

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition.
{{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')}} 
+ +

Compatibilidade de Browser

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/map/index.html b/files/pt-br/web/javascript/reference/global_objects/array/map/index.html new file mode 100644 index 0000000000..278e9ba6a4 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/map/index.html @@ -0,0 +1,255 @@ +--- +title: Array.prototype.map() +slug: Web/JavaScript/Reference/Global_Objects/Array/map +translation_of: Web/JavaScript/Reference/Global_Objects/Array/map +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Resumo

+ +

O método map() invoca a função callback passada por argumento para cada elemento do Array e devolve um novo Array como resultado.

+ +

Sintaxe

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

Parâmetros

+ +
+
callback
+
Função cujo retorno produz o elemento do novo Array. Recebe três argumentos: +
+
valorAtual
+
O valor do elemento original do Array de origem. 
+
indice
+
O índice do elemento atual que está sendo processado no array.
+
array
+
O Array de origem.
+
+
+
thisArg
+
Opcional. Valor a ser utilizado como o this no momento da execução da função callback.
+
+ +

Descrição

+ +

O método map chama a função callback recebida por parâmetro para cada elemento do Array original, em ordem, e constrói um novo array com base nos retornos de cada chamada. A função callback é chamada apenas para os elementos do array original que tiverem valores atribuídos; os elementos que estiverem como undefined, que tiverem sido removidos ou os que nunca tiveram valores atribuídos não serão considerados.

+ +

A função callback é chamada com três argumentos: o valor do elemento corrente, o índice do elemento corrente e o array original que está sendo percorrido.

+ +

Se o parametro thisArg foi passado para o método map, ele será repassado para a função callback no momento da invocação para ser utilizado como o this. Caso contrário, o valor {{jsxref("Global_Objects/undefined", "undefined")}} será repassado para uso como o this. O valor do this a ser repassado para o callback deve respeitar as regras para determinar como o this é acessado por uma função (em inglês).

+ +

O método map não modifica o array original. No entanto, a função callback invocada por ele pode fazê-lo.

+ +

A lista de elementos que serão processados pelo map é montada antes da primeira invocação à função callback. Se um elemento for acrescentado ao array original após a chamada ao map, ele não será visível para o callback. Se os elementos existentes forem modificados, os valores que serão repassados serão os do momento em que o método map invocar o callback. Elementos removidos não serão visitados.

+ +

Exemplos

+ +

Exemplo: Mapeando um array de números para um array de raízes quadradas

+ +

O código a seguir mapeia um array de números e cria um novo array contendo o valor da raiz quadrada de cada número do primeiro array.

+ +
var numbers = [1, 4, 9];
+var roots = numbers.map(Math.sqrt);
+// roots é [1, 2, 3], numbers ainda é [1, 4, 9]
+
+ +

Exemplo: Mapeando um array de números usando uma função callback que contém um argumento

+ +

O código a seguir mostrar como o método map funciona quando a função callback possui apenas um argumento. Esse argumento será automaticamente atribuído para cada elemento do array conforme o map itera sobre o array original.

+ +
var numbers = [1, 4, 9];
+var doubles = numbers.map(function(num) {
+  return num * 2;
+});
+// doubles é agora [2, 8, 18]. numbers ainda é [1, 4, 9]
+
+ +

Exemplo: usando map genericamente

+ +

Esse exemplo demonstra como usar o map em um {{jsxref("Global_Objects/String", "String")}} para recuperar a representação em ASCII de cada caracter em um array de bytes:

+ +
var map = Array.prototype.map;
+var a = map.call('Hello World', function(x) { return x.charCodeAt(0); });
+// a agora vale [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
+
+ +

Exemplo: usando map genericamente com querySelectorAll

+ +

Esse exemplo demonstra como iterar sobre uma coleção de objetos recuperada através de querySelectorAll. Nesse caso, vamos pegar todos os options selecionados na tela e imprimir no console:

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

Exemplo: Usando map para inverter uma string

+ +
var str = '12345';
+[].map.call(str, function(x) {
+  return x;
+}).reverse().join('');
+
+// Output: '54321'
+// Bonus: utilize '===' para verificar se a string original e a nova string são palíndromos
+
+ +

Exemplo: Caso de uso mais complexo

+ +

(inspirado nesse post) (em inglês)

+ +

É uma prática comum utilizar o callback com apenas um argumento (o elemento atual do array original). Algumas funções também são comumente utilizadas com um argumento, mesmo tendo argumentos adicionais opcionais. Esses hábitos podem resultar em comportamentos indesejado:

+ +
// Considere:
+['1', '2', '3'].map(parseInt);
+// Enquanto era de se esperar [1, 2, 3]
+// O resultado atual é [1, NaN, NaN]
+
+// parseInt é normalmente usado com apenas um argumento, mas ele possui dois.
+// O primeiro é uma expressão, e o segundo o radical.
+// Para a função callback, o Array.prototype.map repassa 3 argumentos:
+// o elemento corrente, o indice e o array original
+// O terceiro argumento é ignorado pelo parseInt, mas o segundo não, o que certamente gerou o comportamento inesperado. Veja o post para maiores detalhes
+
+function returnInt(element) {
+  return parseInt(element, 10);
+}
+
+['1', '2', '3'].map(returnInt); // [1, 2, 3]
+// O resultado atual é um array de números (como esperado)
+
+// Bonus: Um jeito mais simples de conseguir o mesmo resultado sem nenhuma "pegadinha do Malandro":
+['1', '2', '3'].map(Number); // [1, 2, 3]
+
+ +

Polyfill

+ +

(veja definição em Polyfill)

+ +

O método map foi introduzido ao padrão ECMA-262 na sua 5ª edição, o que significa que ele pode não estar presente em todas as implementações desse padrão. Você pode contornar esse problema inserindo o código a seguir no início dos seus scripts, permitindo o uso do map mesmo que ele não esteja sendo suportado nativamente. Esse algoritmo é exatamente o especificado no ECMA-262 5ª edição, assumindo que {{jsxref("Global_Objects/Object", "Object")}}, {{jsxref("Global_Objects/TypeError", "TypeError")}}, e {{jsxref("Global_Objects/Array", "Array")}} tenham seus valores originais, e que callback.call avalie para o valor original de {{jsxref("Function.prototype.call")}}.

+ +
// Production steps of ECMA-262, Edition 5, 15.4.4.19
+// Reference: http://es5.github.io/#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. Let O be the result of calling ToObject passing the |this|
+    //    value as the argument.
+    var O = Object(this);
+
+    // 2. Let lenValue be the result of calling the Get internal
+    //    method of O with the argument "length".
+    // 3. Let len be ToUint32(lenValue).
+    var len = O.length >>> 0;
+
+    // 4. If IsCallable(callback) is false, throw a TypeError exception.
+    // See: http://es5.github.com/#x9.11
+    if (typeof callback !== 'function') {
+      throw new TypeError(callback + ' is not a function');
+    }
+
+    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+    if (arguments.length > 1) {
+      T = thisArg;
+    }
+
+    // 6. Let A be a new array created as if by the expression new Array(len)
+    //    where Array is the standard built-in constructor with that name and
+    //    len is the value of len.
+    A = new Array(len);
+
+    // 7. Let k be 0
+    k = 0;
+
+    // 8. Repeat, while k < len
+    while (k < len) {
+
+      var kValue, mappedValue;
+
+      // a. Let Pk be ToString(k).
+      //   This is implicit for LHS operands of the in operator
+      // b. Let kPresent be the result of calling the HasProperty internal
+      //    method of O with argument Pk.
+      //   This step can be combined with c
+      // c. If kPresent is true, then
+      if (k in O) {
+
+        // i. Let kValue be the result of calling the Get internal
+        //    method of O with argument Pk.
+        kValue = O[k];
+
+        // ii. Let mappedValue be the result of calling the Call internal
+        //     method of callback with T as the this value and argument
+        //     list containing kValue, k, and O.
+        mappedValue = callback.call(T, kValue, k, O);
+
+        // iii. Call the DefineOwnProperty internal method of A with arguments
+        // Pk, Property Descriptor
+        // { Value: mappedValue,
+        //   Writable: true,
+        //   Enumerable: true,
+        //   Configurable: true },
+        // and false.
+
+        // In browsers that support Object.defineProperty, use the following:
+        // Object.defineProperty(A, k, {
+        //   value: mappedValue,
+        //   writable: true,
+        //   enumerable: true,
+        //   configurable: true
+        // });
+
+        // For best browser support, use the following:
+        A[k] = mappedValue;
+      }
+      // d. Increase k by 1.
+      k++;
+    }
+
+    // 9. return A
+    return A;
+  };
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES5.1', '#sec-15.4.4.19', 'Array.prototype.map')}}{{Spec2('ES5.1')}}Definição inicial implementada no JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.map', 'Array.prototype.map')}}{{Spec2('ES6')}}
+ +

Compatibilidade com os browsers

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

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/observe/index.html b/files/pt-br/web/javascript/reference/global_objects/array/observe/index.html new file mode 100644 index 0000000000..d1b06c5ecf --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/observe/index.html @@ -0,0 +1,128 @@ +--- +title: Array.observe() +slug: Web/JavaScript/Reference/Global_Objects/Array/observe +translation_of: Archive/Web/JavaScript/Array.observe +--- +
{{JSRef}} {{non-standard_header}}
+ +

O método Array.observe() é usado para observar mudanças de forma assíncrona em Arrays, de forma similar ao método {{jsxref("Object.observe()")}} para objetos. O método fornece um conjunto de mudanças em ordem de ocorrência. É equivalente ao método Object.observe() invocado com a lista aceita ["add", "update", "delete", "splice"].

+ +

Sintaxe

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

Parâmetros

+ +
+
arr
+
O array a ser observado.
+
callback
+
A função chamado cada vez que ocorrem mudanças, com o seguinte argumento: +
+
changes
+
Um array de objetos, sendo que cada um representa uma mudança. As propriedades destes objetos são: +
    +
  • name: O nome da propriedade que mudou.
    • +
  • object: O array modificado depois que a mudança ocorreu.
    • +
  • type: Uma string que indica o tipo de mudança que ocorreu. Pode ser "add", "update", "delete", ou "splice".
    • +
  • oldValue: Apenas para os tipos "update" e "delete". O valor antes da mudança.
    • +
  • index: Apenas para o tipo "splice". O índice no qual ocorreu a mudança.
    • +
  • removed: Apenas para o tipo "splice". Um array de elementos removidos.
    • +
  • addedCount: Apenas para o tipo "splice". O número de elementos adicionados.
    • +
+
+
+
+
+ +

Descrição

+ +

A função callback é chamada cada vez que uma mudança é feita em arr, com um array de todas as mudanças na ordem em que elas ocorreram.

+ +
+

Mudanças feitas via métodos de Array, tais como Array.prototype.pop() serão reportados como mudanças do tipo "splice". Mudanças do tipo índice que não alteram o tamanho do array podem ser reportadas como mudanças do tipo "update".

+
+ +

Exemplos

+ +

Adicionando diferentes tipos em log

+ +
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}]
+
+ +

Especificações

+ +

Strawman proposal specification.

+ +

Compatibilidade com Browser

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FuncionalidadeChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatChrome("36")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FuncionalidadeAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatNo}}{{CompatVersionUnknown}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/of/index.html b/files/pt-br/web/javascript/reference/global_objects/array/of/index.html new file mode 100644 index 0000000000..d7d72259cb --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/of/index.html @@ -0,0 +1,108 @@ +--- +title: Array.of() +slug: Web/JavaScript/Reference/Global_Objects/Array/of +tags: + - Array + - ECMAScript6 + - JavaScript + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/of +--- +
{{JSRef}}
+ +

O método Array.of() cria um nova instância de Array com um número variável de argumentos, independentemente do número ou do tipo dos argumentos.

+ +

A diferença entre o Array.of() e o construtor de Array é no tratamento dos argumentos inteiros: Array.of(7) cria um array com um único elemento, 7, enquanto Array(7) cria um array vazio de propriedade length igual a 7 (Nota: isso quer dizer um array com 7 espaços vazios, e não com valores do tipo {{jsxref("undefined")}}).

+ +
Array.of(7);       // [7]
+Array.of(1, 2, 3); // [1, 2, 3]
+
+Array(7);          // array com 7 espaços vazios
+Array(1, 2, 3);    // [1, 2, 3]
+
+ +

Syntaxe

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

Parâmetros

+ +
+
elementN
+
Elementos usados para criar o array.
+
+

Valor de retorno

+
+
Uma nova instância de {{jsxref("Array")}}. 
+
+ +

Descrição

+ +

Esta função é parte do padrão ECMAScript 6 (ou ECMAScript 2015).

+ +

Para maiores informações veja:

+ + + +

Exemplos

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

Polyfill

+ +

Executando o seguinte código antes de qualquer outro c[odigo criará o Array.of() se ele não for disponível nativamente.

+ +
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;
+  };
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES6', '#sec-array.of', 'Array.of')}}{{Spec2('ES6')}}Definição inicial.
+ +

Compatibilidade com os navegadores

+ +
+ + +

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

+
+ +

Ver também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/pop/index.html b/files/pt-br/web/javascript/reference/global_objects/array/pop/index.html new file mode 100644 index 0000000000..6bd4c55b5e --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/pop/index.html @@ -0,0 +1,81 @@ +--- +title: Array.prototype.pop() +slug: Web/JavaScript/Reference/Global_Objects/Array/pop +tags: + - Array + - JavaScript + - Pop +translation_of: Web/JavaScript/Reference/Global_Objects/Array/pop +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Resumo

+ +

O método pop() remove o último elemento de um array e retorna aquele elemento.

+ +

Sintaxe

+ +
arr.pop()
+ +

Descrição

+ +

O método pop remove o último elemento de um array e retorna aquele valor.

+ +

Esse método é intencionalmente genérico. Podendo ser utilizado por {{jsxref("Function.call", "call", "", 1)}} ou {{jsxref("Function.apply", "apply", "", 1)}} em objetos que implementam arrays.

+ +

Se você chamar pop() em um array vazio, ele retorna o valor {{jsxref("Global_Objects/undefined", "undefined")}}.

+ +

Exemplos

+ +

Exemplo: Removendo o último elemento de um array

+ +

O código seguinte cria o array meuPeixe contendo quatro elementos e então remove seu último elemento.

+ +
var meuPeixe = ['acara-bandeira', 'palhaco', 'mandarim', 'esturjao'];
+
+console.log(meuPeixe); // ['acara-bandeira', 'palhaco', 'mandarim', 'esturjao']
+
+var meuPeixePop = meuPeixe.pop();
+
+console.log(meuPeixe); // ['acara-bandeira', 'palhaco', 'mandarim' ]
+
+console.log(meuPeixePop); // 'esturjao'
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoEstadoComentário
ECMAScript 3ª EdiçãoPadrãoDefinição inicial. Implementado no 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')}}
+ +

Compatibilidade nos Navegadores

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

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/array/prototype/index.html new file mode 100644 index 0000000000..e863d9cc69 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/prototype/index.html @@ -0,0 +1,206 @@ +--- +title: Array.prototype +slug: Web/JavaScript/Reference/Global_Objects/Array/prototype +tags: + - Array + - JavaScript + - Propriedade +translation_of: Web/JavaScript/Reference/Global_Objects/Array/prototype +--- +
{{JSRef}}
+ +

Descrição

+ +

Instâncias de {{jsxref("Global_Objects/Array", "Array")}} herdam de Array.prototype. Como em todos os construtores, você pode mudar o  protótipo desse construtor para modificar todas as instâncias de {{jsxref("Global_Objects/Array", "Array")}}.

+ +

Contudo, a adição de métodos não-padronizados ao objeto array pode causar problemas futuros, seja com seu próprio código, ou na adição de novas funcionalidades ao JavaScript.

+ +

Um fato pouco conhecido: O próprio Array.prototype é um {{jsxref("Global_Objects/Array", "Array")}}

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

Propriedades

+ +
+
Array.prototype.constructor
+
Especifica a função que cria um objeto do protótipo.
+  
+
{{jsxref("Array.prototype.length")}}
+
Reflete o número de elementos em um array.
+
+ +

Métodos

+ +

Métodos modificadores

+ +

Esses métodos modificam o array:

+ +
+
{{jsxref("Array.prototype.copyWithin()")}} {{experimental_inline}}
+
Copia uma sequência de elementos do array dentro do array.
+
{{jsxref("Array.prototype.fill()")}} {{experimental_inline}}
+
Preenche todos os elementos de um array com um elemento estático, começando de um índice inicial até um índice final.
+
{{jsxref("Array.prototype.pop()")}}
+
Remove e retorna o último elemento de um array.
+
{{jsxref("Array.prototype.push()")}}
+
Adiciona um ou mais elementos ao fim de um array e retorna o novo comprimeiro do array.
+
{{jsxref("Array.prototype.reverse()")}}
+
Reverte a ordem dos elementos de um array - o primeiro vira o último e o último vira o primeiro.
+
{{jsxref("Array.prototype.shift()")}}
+
Remove o primeiro elemento de um array e o retorna.
+
{{jsxref("Array.prototype.sort()")}}
+
Ordena os elementos do array em questão e retorna o array.
+
{{jsxref("Array.prototype.splice()")}}
+
Adiciona e/ou remove elementos de um array.
+
{{jsxref("Array.prototype.unshift()")}}
+
Adiciona um ou mais elementos ao início de um array e retorna o novo comprimento do array.
+
+ +

Métodos de acesso

+ +

Esses métodos não modificam o array, mas sim retornam alguma representação dele.

+ +
+
{{jsxref("Array.prototype.concat()")}}
+
Retorna um novo array formado por esse array concatenado com outro(s) array(s) e/ou valores.
+
{{jsxref("Array.prototype.contains()")}} {{experimental_inline}}
+
Verifica se o array possui cer, retornandotrue ou false apropriadamente.
+
{{jsxref("Array.prototype.join()")}}
+
Retorna uma string com todos os elementos do array
+
{{jsxref("Array.prototype.slice()")}}
+
Retorna um novo array com uma parte do array sobre o qual o método foi chamado
+
{{jsxref("Array.prototype.toSource()")}} {{non-standard_inline}}
+
Retorna um array literal representando o array especificado; você pode usar esse valor para criar um novo array. Esse método sobrescreve o método {{jsxref("Object.prototype.toSource()")}}.
+
{{jsxref("Array.prototype.toString()")}}
+
Retonar uma string representando o array e seus elementos. Esse método sobrescreve o método {{jsxref("Object.prototype.toString()")}}.
+
{{jsxref("Array.prototype.toLocaleString()")}}
+
Retonar uma string adequada ao idioma do usuário representando o array e seus elementos. Esse método sobrescreve o método {{jsxref("Object.prototype.toLocaleString()")}}.
+
{{jsxref("Array.prototype.indexOf()")}}
+
Representa o índice da primeira ocorrência de um valor especificado no array, ou -1 se o valor não estiver incluso no array.
+
{{jsxref("Array.prototype.lastIndexOf()")}}
+
Representa o índice da última ocorrência de um valor especificado no array, ou -1 se o valor não estiver incluso no array
+
+ +

Métodos de iteração

+ +

Vários métodos tomam como funções de argumento para serem chamados de volta ao processar o array. Quando esses métodos são chamados, o `length` do array é amostrado e qualquer elemento adicionado além deste comprimento (length)  de dentro da função (callback) não é visitado. Outras alterações para o array (Definindo o valor de ou apagando um elemento) pode afetar os resultados da operação se o método visita o elemento alterado posteriormente. Enquanto o comportamento específico destes métodos nestes casos é bem definido, não se deve confiar nisso para não confundir os outros que possoam ler seu código. Em vez disso, deve-se copiar para um novo array para modificá-lo.

+ +
+
{{jsxref("Array.prototype.forEach()")}}
+
Chama a função para cada elemento no array.
+
{{jsxref("Array.prototype.entries()")}} {{experimental_inline}}
+
Retorna um novo objeto Array Iterator que contem o par chave/valor para cada índice no array.
+
{{jsxref("Array.prototype.every()")}}
+
Retorna true se todos elementos no array satisfizer a função de teste fornecida.
+
{{jsxref("Array.prototype.some()")}}
+
Retorna true se pelo menos um elemento no array satisfizer a função de teste fornecida.
+
{{jsxref("Array.prototype.filter()")}}
+
Cria um novo array com todos os elementos do array para qual a função de filtragem fornecida retorne true.
+
{{jsxref("Array.prototype.find()")}} {{experimental_inline}}
+
Retorna o valor encontrado no array, se um elemento no array satisfizer a funçào de teste fornecida ou  `undefined` se não for encontrado.
+
{{jsxref("Array.prototype.findIndex()")}} {{experimental_inline}}
+
Retorna o índice no array, se um elemento no array satisfizer a função de teste fornecida ou -1 se não for encontrado.
+
{{jsxref("Array.prototype.keys()")}} {{experimental_inline}}
+
Retorna um novo Array Iterator que contem a chave para cada índice no array.
+
{{jsxref("Array.prototype.map()")}}
+
Cria um novo array com os resultados da função fornecida chamada em cada elemento na array.
+
{{jsxref("Array.prototype.reduce()")}}
+
Aplica uma função contra um acumulador e cada valor do array (da esquerda para direita) para reduzi-los a um único valor.
+
{{jsxref("Array.prototype.reduceRight()")}}
+
Aplica uma função contra um acumulador e cada valor do array (da direita para esquerda) para reduzi-los a um único valor.
+
{{jsxref("Array.prototype.values()")}} {{experimental_inline}}
+
Retorna um novo objeto Array Iterator que contem os valores de cada índice no array.
+
{{jsxref("Array.prototype.@@iterator()", "Array.prototype[@@iterator]()")}} {{experimental_inline}}
+
Retorna um novo objeto Array Iterator que contem os valores de cada índice no array.
+
+ +

Métodos genéricos

+ +

Vários métodos do objeto Array em Javascript foram feitos para serem aplicados genericamentes em todos os objetos que "pareçam" Arrays. Isso é, eles podem ser usados em qualquer objeto que possuam uma propriedade length (comprimento), e que possa ser usado a partir de propriedades numéricas (como índices no formato array[5]). Alguns métodos, como {{jsxref("Array.join", "join")}}, apenas lêem e as propriedades numéricas do objeto sobre o qual eles sãochamados. Outros, como {{jsxref("Array.reverse", "reverse")}}, exigem que as propriedades numéricas e length sejam mutáveis; sendo assim, esses métodos não podem ser chamados em objetos como {{jsxref("Global_Objects/String", "String")}}, que não permitem que nenhuma das duas propriedades sejam modificadas.

+ +

Especifiações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoSituaçãoComentário
ECMAScript 1st Edition.PadrãoDefinição inicial
{{SpecName('ES5.1', '#sec-15.4.3.1', 'Array.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-array.prototype', 'Array.prototype')}}{{Spec2('ES6')}} 
+ +

Compatibilidade com Navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

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

Resumo

+ +

O método push() adiciona um ou mais elementos ao final de um array e retorna o novo comprimento desse array.

+ +
var numeros = [1, 2, 3];
+numeros.push(4);
+
+console.log(numeros); // [1, 2, 3, 4]
+
+numeros.push(5, 6, 7);
+
+console.log(numeros); // [1, 2, 3, 4, 5, 6, 7]
+
+ +

Sintaxe

+ +
arr.push(elemento1, ..., elementoN)
+ +

Parâmetros

+ +
+
elementoN
+
Os elementos a serem incluídos ao final do array.
+
+ +

Retorno

+ +

O novo valor da propriedade {{jsxref("Array.length", "length")}} do objeto no qual o método foi chamado.

+ +

Descrição

+ +

O método push adiciona valores a um array.

+ +

Esse método é intencionalmente genérico. Podendo ser utilizado por {{jsxref("Function.call", "call()")}} ou {{jsxref("Function.apply", "apply()")}} em objetos que implementam arrays.  O método push depende da propriedade length para determinar onde começar a inserir os valores. Caso a propriedade length não possa ser convertida em número, é utilizado 0 como índice. Isto inclui a possibilidade de length não existir, nesse caso, essa propriedade será criada.

+ +

Os únicos objetos que implementam nativamente array são as {{jsxref("Global_Objects/String", "strings", "", 1)}}, porém elas não são adequadas para a aplicação desse método, pois são imutáveis.

+ +

Exemplos

+ +

Exemplo: Adicionando elementos a um array

+ +

O seguinte código cria um array esportes que contém dois elementos. Então adiciona dois elementos a ele. A variável total contém o novo comprimento do array.

+ +
var esportes = ['futebol', 'beisebol'];
+var total = esportes.push('handebol', 'natacao');
+
+console.log(esportes); // ['futebol, 'beisebol', 'handebol', 'natacao']
+console.log(total);  // 4
+
+ +

Exemplo: Fusão de dois arrays

+ +

Este exemplo utiliza {{jsxref("Function.apply", "apply()")}} para adicionar todos os elementos de um segundo array.

+ +
var vegetais = ['cenoura', 'batata'];
+var maisVegetais = ['aipo', 'beterraba'];
+
+// Adiciona o segundo array no primeiro
+// Equivalente a vegetais.push('aipo', 'beterraba');
+Array.prototype.push.apply(vegetais, maisVegetais);
+
+console.log(vegetais); // ['cenoura', 'batata', 'aipo', 'beterraba']
+ +

Exemplo: Utilizando um object como um array-like

+ +

Como mencionado acima, push é intencionalmente genérico, e podemos usar isso para nossa vantagem. Array.prototype.push pode trabalhar em um objeto muito bem, como mostra este exemplo. Observe que não criamos um array para armazenar uma coleção de objetos. Em vez disso, armazenamos a coleção no objeto em si e usamos a chamada em Array.prototype.push para enganar o método e pensar que estamos lidando com um array, e ele simplesmente funciona, graças à forma como o JavaScript nos permite estabelecer o contexto de execução quando queremos.

+ +
var obj = {
+    length: 0,
+
+    addElem: function addElem(elem) {
+        // obj.length é automaticamente incrementado
+        // toda vez que um elemento for adicionado.
+        [].push.call(this, elem);
+    }
+};
+
+// Vamos adicionar alguns objetos vazios apenas para ilustrar.
+obj.addElem({});
+obj.addElem({});
+console.log(obj.length);
+// → 2
+
+ +

Observe que, embora obj não seja um array, o método push aumentou com sucesso a propriedade de comprimento (length) do obj como se estivéssemos lidando com um array.

+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoEstadoComentário
ECMAScript 3ª EdiçãoPadrãoImplementação inicial. Implentado no 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')}} 
+ +

Compatibilidade em navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatChrome("1.0")}}{{CompatGeckoDesktop("1.7")}}{{CompatIE("5.5")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome para AndroidFirefox Móvel (Gecko)IE MóvelOpera MóvelSafari Móvel
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/reduce/index.html b/files/pt-br/web/javascript/reference/global_objects/array/reduce/index.html new file mode 100644 index 0000000000..0268b64c00 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/reduce/index.html @@ -0,0 +1,513 @@ +--- +title: Array.prototype.reduce() +slug: Web/JavaScript/Reference/Global_Objects/Array/Reduce +tags: + - Array + - JavaScript + - Métodos + - Prototipo + - Referencia + - reduce() +translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce +--- +
{{JSRef}}
+ +

O método reduce() executa uma função reducer (fornecida por você) para cada elemento do array, resultando num único valor de retorno.

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

A função reducer recebe quatro parâmetros:

+ +
    +
  1. Acumulador (acc)
    2. +
  2. Valor Atual (cur)
    3. +
  3. Index Atual (idx)
    4. +
  4. Array original (src)
    5. +
+ +

O valor de retorno da sua função reducer é atribuída ao acumulador. O acumulador, com seu valor atualizado, é repassado para cada iteração subsequente pelo array, que por fim, se tornará o valor resultante, único, final.

+ +

Sintaxe

+ +
array.reduce(callback( acumulador, valorAtual[, index[, array]] )[, valorInicial]))
+ +

Parâmetros

+ +
+
callback
+
Função que é executada em cada valor no array (exceto no primeiro, se nenhum valorInicial for passado); recebe quatro argumentos:
+
+ +

acumulador

+ +

Opcional. O índice do elemento atual que está sendo processado no array. Começa a partir do index 0 se um valorInicial for fornecido. Do contrário, começa do index 1.

+ +
+
valorInicial
+
Opcional. Valor a ser usado como o primeiro argumento da primeira chamada da função callback. Se nenhum valorInicial é fornecido, o primeiro elemento do array será usado como o valor inicial do acumulador e o valorAtual não será lido. Chamar reduce() em uma array vazia sem valor inicial retornará um erro.
+
+ +

Valor retornado

+ +

O valor que resulta da redução.

+ +

Descrição

+ +

O método reduce() executa a função de callback uma vez para cada elemento presente no array, excluindo furos (valores indefinidos), recebendo quatro argumentos:

+ +
    +
  1. acumulador - valor inicial (ou o valor do callback anterior),
    2. +
  2. valorAtual - o valor do elemento atual
    3. +
  3. index - o índice atual e
    4. +
  4. array - o array onde a iteração está ocorrendo.
    5. +
+ +

A primeira vez que o callback é chamado, o acumulador e o valorAtual podem ter um de dois valores possíveis. Se o valorInicial tiver sido fornecido na chamada à função reduce(), então o acumulador será igual ao valorInicial e o valorAtual será igual ao primeiro valor no array. Caso nenhum valorInicial seja fornecido, acumulador será igual ao primeiro valor no array, e valorAtual será igual ao segundo.

+ +
+

Nota: Se o valorInicial não tiver sido passado como argumento, então reduce() executará o callback da função começando a partir do índice 1 (index 1), pulando o primeiro índice (index 0). Se o valorInicial for passado como argumento, a função irá começar no index 0.

+
+ +

Se a array estiver vazia e o valorInicial não tiver sido informado, uma exceção do tipo {{jsxref("Global_Objects/TypeError", "TypeError")}} será lançada.

+ +

Se a array possuir somente um elemento (independente da posição) e o valorInicial não tiver sido fornecido, ou se valorInicial for fornecido, mas a array estiver vazia, o valor será retornado sem que a função de callback seja chamada.

+ +

É mais seguro provir um valorInicial, porque existem até quatro possíveis saídas sem o valorInicial, como mostrado no exemplo:

+ +
var maxCallback = ( acc, cur ) => Math.max( acc.x, cur.x );
+var maxCallback2 = ( max, cur ) => Math.max( max, cur );
+
+// reduce() sem valores iniciais
+[ { x: 22 }, { x: 42 } ].reduce( maxCallback ); // 42
+[ { x: 22 }            ].reduce( maxCallback ); // { x: 22 }
+[                      ].reduce( maxCallback ); // TypeError
+
+// map/reduce; melhor solução, funciona para vetores vazios e tambem para vetores grandes
+[ { x: 22 }, { x: 42 } ].map( el => el.x )
+                        .reduce( maxCallback2, -Infinity );
+ +

Como funciona o reduce()

+ +

Suponha que o seguinte uso de reduce() tenha ocorrido:

+ +
[0, 1, 2, 3, 4].reduce(function(acumulador, valorAtual, index, array) {
+  return acumulador + valorAtual;
+});
+// 10
+ +

O callback será invocado quatro vezes, com os argumentos e valores em cada chamada  sendo:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
acumuladorvalorAtualindexarrayvalor de retorno
primeira chamada011[0, 1, 2, 3, 4]1
segunda chamada122[0, 1, 2, 3, 4]3
terceira chamada333[0, 1, 2, 3, 4]6
quarta chamada644[0, 1, 2, 3, 4]10
+ +

O valor retornado pelo reduce será o da última chamada à callback (10).

+ +

Você também pode usar uma {{jsxref("Functions/Arrow_functions", "Arrow Function","",1)}} em vez de uma função completa. O código abaixo produz a mesma saída que o código do bloco acima:

+ +
[0, 1, 2, 3, 4].reduce( (accum, curr) => accum + curr );
+ +

Se você informar um valorInicial como o segundo argumento de reduce, o resultado será:

+ +
[0, 1, 2, 3, 4].reduce(function(acumulador, valorAtual, indice, array) {
+  return acumulador + valorAtual;
+}, 10);
+
+// 20
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
callbackacumuladorvalorAtualindexarrayvalor de retorno
primeira chamada1000[0, 1, 2, 3, 4]10
segunda chamada1011[0, 1, 2, 3, 4]11
terceira chamada1122[0, 1, 2, 3, 4]13
quarta chamada1333[0, 1, 2, 3, 4]16
quinta chamada1644[0, 1, 2, 3, 4]20
+ +

O retorno da última chamada 20,é retornado como resultado da função reduce().

+ +

Exemplos

+ +

Soma todos os valores de uma array

+ +
let total = [0, 1, 2, 3].reduce(function(acumulador, valorAtual) {
+   return acumulador + valorAtual;
+ }, 0)
+// retorna 6
+ +

outra alternativa é usar uma arrow function:

+ +
var total = [ 0, 1, 2, 3 ].reduce(
+  ( acumulador, valorAtual ) => acumulador + valorAtual,
+  0
+);
+ +

Soma de valores de um objeto de um array

+ +

Para resumir os valores contidos em um array, você deve fornecer um valorInicial, para que cada item passe por sua função.

+ +
var valorInicial = 0;
+var soma = [{x: 1}, {x: 2}, {x: 3}].reduce(function (acumulador, valorAtual) {
+    return acumulador + valorAtual.x;
+}, valorInicial)
+
+console.log(soma) // retorna 6
+ +

Utilizando uma arrow function:

+ +
var valorInicial = 0;
+var soma = [{x: 1}, {x: 2}, {x: 3}].reduce(
+    (acumulador , valorAtual) => acumulador + valorAtual.x
+    , valorInicial
+);
+
+console.log(soma) // retorna 6
+
+ +

Redução de um array de arrays

+ +
let reduzido = [[0, 1], [2, 3], [4, 5]].reduce(
+  function(acumulador, valorAtual) {
+    return acumulador.concat(valorAtual)
+  },
+  []
+)
+// reduzido é [0, 1, 2, 3, 4, 5]
+ +

Utilizando uma arrow function:

+ +
let reduzido = [[0, 1], [2, 3], [4, 5]].reduce(
+  ( acumulador, valorAtual ) => acumulador.concat(valorAtual),
+  []
+);
+ +

Contando valores iguais em um objeto

+ +
let nomes = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice'];
+
+let quantidadeNomes = nomes.reduce(function (todosNomes, nome) {
+  if (nome in todosNomes) {
+    todosNomes[nome]++;
+  }
+  else {
+    todosNomes[nome] = 1;
+  }
+  return todosNomes;
+}, {});
+// quantidade de nomes:
+// { 'Alice': 2, 'Bob': 1, 'Tiff': 1, 'Bruce': 1 }
+
+ +

Agrupando objetos por uma propriedade

+ +
let pessoas = [
+  { nome: 'Alice', idade: 21 },
+  { nome: 'Max', idade: 20 },
+  { nome: 'Jane', idade: 20 }
+];
+
+function agruparPor(objetoArray, propriedade) {
+  return objetoArray.reduce(function (acc, obj) {
+    let key = obj[propriedade];
+    if (!acc[key]) {
+      acc[key] = [];
+    }
+    acc[key].push(obj);
+    return acc;
+  }, {});
+}
+
+let grupodePessoas = agruparPor(pessoas, 'idade');
+// grupodePessoas é:
+// {
+//   20: [
+//     { nome: 'Max', idade: 20 },
+//     { nome: 'Jane', idade: 20 }
+//   ],
+//   21: [{ nome: 'Alice', idade: 21 }]
+// }
+ +

Juntando arrays contidos num array de objetos usando o operador spread e o valorInicial

+ +
// friends - um array de objetos
+// onde o campo "books" é a lista de livros favoritos
+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 - lista que contém todos os livros de friends +
+// lista adicional contida em valorInicial
+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'
+// ]
+ +

Removendo itens duplicados num array

+ +
+

Nota: Se você estiver usando um ambiente compatível com {{jsxref("Set")}} and {{jsxref("Array.from()")}}, você pode usar let orderedArray = Array.from(new Set(myArray)) para obter um array em que os itens duplicados tenham sido removidos.

+
+ +
let arr = [1, 2, 1, 2, 3, 5, 4, 5, 3, 4, 4, 4, 4];
+let result = arr.sort().reduce((init, current) => {
+    if (init.length === 0 || init[init.length - 1] !== current) {
+        init.push(current);
+    }
+    return init;
+}, []);
+console.log(result); //[1,2,3,4,5]
+
+ +

Substituindo .filter().map() por .reduce()

+ +

Usar {{jsxref("Array.filter()")}} seguido por {{jsxref("Array.map()")}} faz com que o array seja percorrido duas vezes. Você pode obter o mesmo resultado percorrendo o array apenas uma vez com {{jsxref("Array.reduce()")}}, o que é, portanto, mais eficiente. (Se você gosta de for loops, você pode usar filter e map percorrendo o array apenas uma vez com {{jsxref("Array.forEach()")}}).

+ +
const numbers = [-5, 6, 2, 0,];
+
+const doubledPositiveNumbers = numbers.reduce((accumulator, currentValue) => {
+  if (currentValue > 0) {
+    const doubled = currentValue * 2;
+    accumulator.push(doubled);
+  }
+  return accumulator;
+}, []);
+
+console.log(doubledPositiveNumbers); // [12, 4]
+ +

Rodando promises em sequência

+ +
/**
+ * Roda promises de um promise array de uma maneira encadeada
+ *
+ * @param {array} arr - promise arr
+ * @return {Object} promise object
+ */
+function runPromiseInSequense(arr) {
+  return arr.reduce((promiseChain, currentPromise) => {
+    return promiseChain.then((chainedResult) => {
+      return currentPromise(chainedResult)
+        .then((res) => res)
+    })
+  }, Promise.resolve());
+}
+
+// promise function 1
+function p1() {
+  return new Promise((resolve, reject) => {
+    resolve(5);
+  });
+}
+
+// promise function 2
+function p2(a) {
+  return new Promise((resolve, reject) => {
+    resolve(a * 2);
+  });
+}
+
+// promise function 3
+function p3(a) {
+  return new Promise((resolve, reject) => {
+    resolve(a * 3);
+  });
+}
+
+const promiseArr = [p1, p2, p3];
+runPromiseInSequense(promiseArr)
+  .then((res) => {
+    console.log(res);   // 30
+  });
+ +

Escrever map usando reduce

+ +
if (!Array.prototype.mapUsingReduce) {
+  Array.prototype.mapUsingReduce = function(callback, thisArg) {
+    return this.reduce(function(mappedArray, currentValue, index, array) {
+      mappedArray[index] = callback.call(thisArg, currentValue, index, array)
+      return mappedArray
+    }, [])
+  }
+}
+
+[1, 2, , 3].mapUsingReduce(
+  (currentValue, index, array) => currentValue + index + array.length
+) // [5, 7, , 10]
+ +

Polyfill

+ +

Array.prototype.reduce foi adicionado ao padrão ECMA-262  na quinta edição; e portanto, pode não estar presente em todas as implementações do padrão. Você pode contornar isso inserindo o código a seguir no início de seus scripts, permitindo o uso do reduce() em implementações que não possuem suporte nativo a ele.

+ +
// Etapas de produção para o ECMA-262, Edition 5, 15.4.4.21
+// Referencia: http://es5.github.io/#x15.4.4.21
+if (!Array.prototype.reduce) {
+  Array.prototype.reduce = function(callback /*, valorInicial*/) {
+    'use strict';
+    if (this == null) {
+      throw new TypeError('Array.prototype.reduce chamado é nulo (null) ou indefinido (undefined)');
+    }
+    if (typeof callback !== 'function') {
+      throw new TypeError(callback + ' não é uma função')
+    }
+    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 possui um array vazio sem um valor inicial');
+      }
+      value = t[k++];
+    }
+    for (; k < len; k++) {
+      if (k in t) {
+        value = callback(value, t[k], k, t);
+      }
+    }
+    return value;
+  };
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES5.1', '#sec-15.4.4.21', 'Array.prototype.reduce')}}{{Spec2('ES5.1')}} +

Definição inicial. Implemetada no JavaScript 1.8.

+
{{SpecName('ES6', '#sec-array.prototype.reduce', 'Array.prototype.reduce')}}{{Spec2('ES6')}}
+ +

Navegadores compatíveis

+ +

A tabela de compatibilidade encontrada nesta página é gerada a partir de dados estruturados. Se você deseja contribuir com os dados, consulte : https://github.com/mdn/browser-compat-data e envie-nos um "pull request".

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

Leia também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/reduceright/index.html b/files/pt-br/web/javascript/reference/global_objects/array/reduceright/index.html new file mode 100644 index 0000000000..67ad0a2bdd --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/reduceright/index.html @@ -0,0 +1,258 @@ +--- +title: Array.prototype.reduceRight() +slug: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight +translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Sumário

+ +

O método reduceRight() aplica à uma função um acumulador e cada valor do array (da direita para esquerda) é reduzido para um valor único.

+ +

Sintaxe

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

Parâmetros

+ +
+
callback
+
Função para executar em cada valor do array, recebendo quatro argumentos: +
+
previousValue
+
O valor anteriormente retornado na ultima invocação do callback, ou o initialValue, se este for o recebido. (Ver abaixo.)
+
currentValue
+
O valor atualmente sendo processado no array.
+
index
+
O índice do valor atualmente sendo processado no array.
+
array
+
O array que foi chamado para ser reduzido.
+
+
+
initialValue
+
Opcional. Objeto para ser usado como argumento inicial da primeria chamada do callback.
+
+ +

Descrição

+ +

reduceRight executa a função callback uma vez para cada elemento presente no array, excluindo buracos no array, recebendo quatro argumentos: o valor inicial (ou o valor da chamada anterior do callback), o valor do elemento atual, o índice do elemento atual, e o array onde a operação está acontecendo.

+ +

A chamada ao callback reduceRight irá parecer com uma chamada assim:

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

A primeira vez que a função é chamada, o previousValue e o currentValue podem ser um de dois valores. Se um initialValue foi recebido na chamada do reduceRight, então o previousValue sera iqual ao initialValue e o currentValue será igual ao ultimo valor no array. Se o initialValue não foi recebido, então o previousValue será igual ao ultimo valor no array e o currentValue será igual ao penultimo valor no array.

+ +

Se o array é vazio e nenhum initialValue foi recebido, {{jsxref("Global_Objects/TypeError", "TypeError")}} será lançado. Se o array somente tem um elemento (independentemente da posição dele) e o initialValue não foi recebido, ou se o initialValue foi recebido mas o array é vazio, o valor em si será retornado sem chamar o callback.

+ +

Alguns exemplos de execuções da função e como será parecida a chamada:

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

O callback será invocado quatro vezes, com os argumentos e valores de retornos em cada chamada será como o seguinte:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
previousValuecurrentValueindexarrayreturn value
Primeira chamada433[0, 1, 2, 3, 4]7
Segunda chamada722[0, 1, 2, 3, 4]9
Terceira chamada911[0, 1, 2, 3, 4]10
Quarta chamada1000[0, 1, 2, 3, 4]10
+ +

O valor retornado pelo reduceRight será o valor retornado pela ultima chamada ao callback(10).

+ +

E se você também passou um initialValue, o resultado irá ser como a seguir:

+ +
[0, 1, 2, 3, 4].reduceRight(function(previousValue, currentValue, index, array) {
+  return previousValue + currentValue;
+}, 10);
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
previousValuecurrentValueindexarrayreturn value
Primeira chamada1044[0, 1, 2, 3, 4]14
Segunda chamada1433[0, 1, 2, 3, 4]17
Terceira chamada1722[0, 1, 2, 3, 4]19
Quarta chamada1911[0, 1, 2, 3, 4]20
Quinta chamada2000[0, 1, 2, 3, 4]20
+ +

O valor retornado pelo reduceRight desta vez será, obviamente, 20.

+ +

Exemplos

+ +

Exemplo: Somando todos os valores presente em um array

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

Exemplo: Juntando um array de arrays

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

Polyfill

+ +

reduceRight foi adicionado no padrão ECMA-262 em sua Quinta edição; sendo assim pode não estar presente em todas as implementações deste padrão. Você pode contornar isso adicionando o seguinte codigo ao inicio do seu script, adicionando a possibilidade de uso do reduceRight em implementações que não o suportam nativamente.

+ +
// Production steps of ECMA-262, Edition 5, 15.4.4.22
+// Reference: http://es5.github.io/#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;
+  };
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES5.1', '#sec-15.4.4.22', 'Array.prototype.reduceRight')}}{{Spec2('ES5.1')}}Definição inicial. Implementado em JavaScript 1.8.
{{SpecName('ES6', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}{{Spec2('ES6')}}
+ +

Compatibilidade com os navegadores

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

Ver também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/reverse/index.html b/files/pt-br/web/javascript/reference/global_objects/array/reverse/index.html new file mode 100644 index 0000000000..ed3b3fe160 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/reverse/index.html @@ -0,0 +1,121 @@ +--- +title: Array.prototype.reverse() +slug: Web/JavaScript/Reference/Global_Objects/Array/reverse +translation_of: Web/JavaScript/Reference/Global_Objects/Array/reverse +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Resumo

+ +

O método reverse() inverte os itens de um array. O primeiro elemento do array se torna o último e o último torna-se o primeiro.

+ +

Sintaxe

+ +
arr.reverse()
+ +

Parâmetros

+ +

Nenhum.

+ +

Descrição

+ +

O método reverse transpõe os elementos do objeto array no mesmo lugar, mutando o array, e retornando uma referência para o mesmo.

+ +

Exemplos

+ +

Exemplo: Invertendo os elementos em um array

+ +

O seguinte exemplo cria um array myArray, contendo três elementos, em seguida inverte-o.

+ +
var myArray = ['one', 'two', 'three'];
+myArray.reverse();
+
+console.log(myArray) // ['three', 'two', 'one']
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
ECMAScript 1ª EdiçãoPadrãoDefinição inicial. Implementado no 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')}} 
+ +

Compatibilidade com navegador

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatChrome("1.0")}}{{CompatGeckoDesktop("1.7")}}{{CompatIE("5.5")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome para AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

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

Sumário

+ +

O método shift()remove o primeiro elemento de um array e retorna esse elemento. Este método muda o tamanho do array. 

+ +

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

+ + + +

Sintaxe

+ +
arr.shift()
+ +

Valor de retorno

+ +

O elemento removido do array; {{jsxref("undefined")}} se o array estiver vazio.

+ +

Descrição

+ +

O método shift remove o elemento de índice zero, diminui em 1 os indices dos demais valores e retorna o valor removido. Se a propriedade {{jsxref("Array.length", "length")}} for 0, então {{jsxref("undefined")}} é retornado.

+ +

shift é intencionalmente genérico; esse método pode ser {{jsxref("Function.call", "chamado", "", 1)}} ou {{jsxref("Function.apply", "aplicado", "", 1)}} para objetos parecidos com arrays. Objetos que não contém a propriedade length representando o tamanho de uma série consecutiva, começando em zero, podem não se comportar de maneira correta.

+ +

Exemplos

+ +

Removendo um elemento de array

+ +

O código a seguir mostra o array minhaLista antes e depois de remover seu primeiro elemento. Ele também mostra o elemento removido.

+ +
var minhaLista = ['anjo', 'casa', 'mandarim', 'medico'];
+
+console.log('minhaLista antes: ' + minhaLista);
+// minhaList antes: ['anjo', 'casa', 'mandarim', 'medico']
+var shifted = minhaLista.shift();
+
+console.log('minhaLista depois: ' + minhaLista);
+// minhaList depois: ['casa', 'mandarim', 'medico']
+console.log('Elemento removido: ' + shifted);
+// Elemento removido: anjo
+
+ +

Usando o método shift() dentro de um loop de while

+ +

O médodo shift() é frequentemente usado como condição dentro de um loop de while. No exemplo a seguir, cada iteração removerá o elemento seguinte do array, até que ele esteja vazio:

+ +
var nomes = ["André", "Eduardo", "Paulo", "Cris", "João"];
+while( (i = nomes.shift()) !== undefined ) {
+    console.log(i);
+}
+// André Eduardo Paulo Cris João
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoEstadoComentário
ECMAScript 3rd EditionStandardImplementação inicial. Implementado no 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')}}
+ +

Compatibilidade de Browser

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

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/slice/index.html b/files/pt-br/web/javascript/reference/global_objects/array/slice/index.html new file mode 100644 index 0000000000..daff58f51f --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/slice/index.html @@ -0,0 +1,224 @@ +--- +title: Array.prototype.slice() +slug: Web/JavaScript/Reference/Global_Objects/Array/slice +tags: + - Array + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice +--- +
{{JSRef}}
+ +

O método slice() retorna uma cópia de parte de um array a partir de um subarray criado entre as posições início e fim (fim não é necessário) de um array original. O Array original não é modificado.

+ +

Syntaxe

+ +
arr.slice([início[,fim]])
+ +

Parâmetros

+ +
+
início {{optional_inline}}
+
Índice baseado em zero no qual se inicia a extração.
+
Como um índice negativo, início indica um deslocamento em relação ao fim da sequência. slice(-2) extrai os dois últimos elementos do array.
+
Se início for omitido, slice inicia a partir do índice 0.
+
Se início for maior que o comprimento do array, é retornado um array vazio.
+
fim {{optional_inline}}
+
Índice baseado em zero o qual é o final da extração. slice extrai até, não incluindo, fim.
+
slice(1,4) extrai do segundo até o quarto elemento (elementos de índice 1, 2 e 3).
+
Como índice negativo, fim indica um deslocamento em relação ao fim do array. slice(2,-1) extrai o terceiro elemento através do segundo-para-o-último elemento no array.
+
Se fim for omitido ou for maior que o tamanho do array, slice considerará o último elemento do array como sendo o fim (arr.length).
+
+ +

Valor de retorno

+ +

Um novo array contendo os elementos extraídos.

+ +

Descrição

+ +

slice não altera o array original. Retorna uma cópia de elementos do array original. Elementos do array original são copiados para o array retornado da seguinte maneira:

+ + + +

Se um novo elemento é adicionado a qualquer array, o outro não é afetado.

+ +

Exemplos

+ +

Retorna uma parte de um array existente

+ +
// Exemplo para extrair 'Laranja' e 'Limao' do array frutas
+var frutas = ['Banana', 'Laranja', 'Limao', 'Maçã', 'Manga'];
+var citricos = frutas.slice(1, 3);
+
+// citricos contem ['Laranja','Limao']
+
+ +

Usando slice

+ +

No exemplo seguinte, slice cria um novo array, novoCarro, do original meuCarro. Ambos incluem uma referência ao objeto,  meuHonda. Quando a cor de meuHonda é alterada para  roxo, ambos os arrays sofrem alteração.

+ +
// Usando slice para criar novoCarro a partir de meuCarro.
+var meuHonda = { cor: 'vermelho', rodas: 4, motor: { cilindros: 4, tamanho: 2.2 } };
+var meuCarro = [meuHonda, 2, 'perfeitas condições', 'comprado em 1997'];
+var novoCarro = meuCarro.slice(0, 2);
+
+// Exibe os valores de meuCarro, novoCarro, e a cor de meuHonda
+//  referenciado de ambos arrays.
+console.log('meuCarro = ' + meuCarro.toSource());
+console.log('novoCarro = ' + novoCarro.toSource());
+console.log('meuCarro[0].cor = ' + meuCarro[0].cor);
+console.log('novoCarro[0].cor = ' + novoCarro[0].cor);
+
+// Altera a cor de meuHonda.
+meuHonda.cor= 'roxo';
+console.log('A nova cor do meu Honda é ' + meuHonda.cor);
+
+// Exibe a cor de meuHonda referenciado de ambos arrays.
+console.log('meuCarro[0].cor = ' + meuCarro[0].cor);
+console.log('novoCarro[0].cor = ' + novoCarro[0].cor);
+
+ +

Esse script escreve:

+ +
meuCarro = [{cor:'vermelho', rodas:4, motor:{cilindros:4, tamanho:2.2}}, 2,'perfeitas condições', 'comprado em 1997']
+novoCarro = [{cor:'vermelho', rodas:4, motor:{cilindros:4, tamanho:2.2}},2]
+meuCarro[0].cor = vermelho
+novoCarro[0].cor = vermelho
+A nova cor do meu Honda é roxo
+meuCarro[0].cor = roxo
+novoCarro[0].cor = roxo
+
+ +

Objetos Array-like

+ +

O método slice pode também ser chamado para converter objetos ou coleções Array-like em um novo Array. Você só precisa encadear o método no Array. Os {{jsxref("Functions/arguments", "arguments")}} dentro de uma função são um exemplo de 'objeto array-like'.

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

Ligações  podem ser feitas com a função .call de {{jsxref("Function.prototype")}} and it can also be reduced using [].slice.call(arguments) ao invés de Array.prototype.slice.call. De qualquer forma, ela pode ser simplificada com {{jsxref("Function.prototype.bind", "bind")}}.

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

Simplificando o comportamento entre navegadores

+ +

Embora os objetos de host (como objetos DOM) não sejam obrigados pela especificação a seguir o comportamento do Mozilla quando convertidos por Array.prototype.slice e IE <9 não o fazem, versões do IE começando pela versão 9 permitem isso. “Shimming” pode permitir um comportamento confiável entre navegadores. Enquanto outros navegadores modernos continuem suportando essa habilidade, como atualmente IE, Mozilla, Chrome, Safari, e Opera fazem, desenvolvedores lendo (DOM-supporting) o código slice confiando neste shim não serão desencaminhados pela semântica; eles podem confiar seguramente na semântica para fornecer o agora aparentemente comportamento padrão de fato. (Isso também corrige o problema com IE < 9 onde o segundo argumento do slice era explicitamente {{jsxref("null")}}/{{jsxref("undefined")}})

+ +
(function () {
+  'use strict';
+  var _slice = Array.prototype.slice;
+
+  try {
+    // Produzirá erro no IE < 9
+    _slice.call(document.documentElement);
+  } catch (e) {
+    // Funciona para arrays, objetos array-like,
+    // NamedNodeMap (atributos, entidades, notações),
+    // NodeList (por exemplo, getElementsByTagName), HTMLCollection (por exemplo, childNodes),
+    // e não vai falhar em outros objetos do DOM (como falham no IE < 9)
+    Array.prototype.slice = function(begin, end) {
+      end = (typeof end !== 'undefined') ? end : this.length;
+
+      // Para arrays, chamamos o método nativo
+      if (Object.prototype.toString.call(this) === '[object Array]'){
+        return _slice.call(this, begin, end);
+      }
+
+      // Para array-like, o processo é manual.
+      var i, cloned = [],
+        size, len = this.length;
+
+      // Lidando com valor negativo para "begin"
+      var start = begin || 0;
+      start = (start >= 0) ? start : Math.max(0, len + start);
+
+      // Lidando com valor negativo para "end"
+      var upTo = (typeof end == 'number') ? Math.min(end, len) : len;
+      if (end < 0) {
+        upTo = len + end;
+      }
+
+      // Tamanho real do corte feito pelo slice
+      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;
+    };
+  }
+}());
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ESDraft', '#sec-array.prototype.slice', 'Array.prototype.slice')}}{{Spec2('ESDraft')}}
{{SpecName('ES6', '#sec-array.prototype.slice', 'Array.prototype.slice')}}{{Spec2('ES6')}}
{{SpecName('ES5.1', '#sec-15.4.4.10', 'Array.prototype.slice')}}{{Spec2('ES5.1')}}
{{SpecName('ES3')}}{{Spec2('ES3')}}Definição inicial. Implementada no JavaScript 1.2.
+ +

Compatibilidade de navegadores

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

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/some/index.html b/files/pt-br/web/javascript/reference/global_objects/array/some/index.html new file mode 100644 index 0000000000..f4724488dd --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/some/index.html @@ -0,0 +1,134 @@ +--- +title: Array.prototype.some() +slug: Web/JavaScript/Reference/Global_Objects/Array/some +translation_of: Web/JavaScript/Reference/Global_Objects/Array/some +--- +
{{JSRef}}
+ +

O método some() testa se ao menos um dos elementos no array passa no teste implementado pela função atribuída e retorna um valor true ou false.

+ +

Sintaxe

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

Parâmetros

+ +
+
callback
+
Função para testar cada elemento, recebendo três argumentos: +
+
currentValue
+
O valor atual do elemento sendo processado no array.
+
index
+
O índice do elemento atual sendo processado no array.
+
array
+
O array onde o método some() foi chamado.
+
+
+
thisArg
+
Opcional. Valor para usar como  this durante a execução do callback.
+
+ +

Valor de retorno

+ +

Esta função retorna true se a função callback retornar true para qualquer elemento do array; caso contrário, false.

+ +

Descrição

+ +

some() executa a função callback uma vez para cada elemento presente no array até achar um onde o callback retorne um valor true. Se em qualquer dos elementos o valor for encontrado, some() imediatamente retorna true. Caso contrario, some() retorna false. callback é invocado somente para índices do array que contenham valor definido; não é invocado para índices que foram deletados ou os quais nunca tiveram valor definido.

+ +

callback é invocado com três argumentos: o valor do elemento, o índice do elemento, e o array onde a função foi chamada.

+ +

Se o parâmetro thisArg foi passado ao some(), ele sera passado ao callback quando o mesmo for invocado, para ser usado como o valor de this internamente na função callback. Caso contrario, o valor {{jsxref("undefined")}} será passado para uso como this. O valor this observado pela callback  é determinado de acordo com as regras usuais para determinar o que é visto por uma função.

+ +

some() não altera o array dentro do qual ele é chamado. 

+ +

O intervalo de elementos processado por some() é definido antes da primeira invocação da callback. Elementos contidos no array antes da chamada some() ser iniciada não serão testados pela callback. Se algum elemento pertencente ao array for alterado pela callback, o valor passado para a callback será o valor do momento em que a função some() encontra o índice daquele elemento. Elementos deletados não são testados.

+ +

Exemplos

+ +

Testando valores de elementos de um array

+ +

O exemplo a seguir testa se algum elemento de um array é maior que 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
+
+ +

Testando valores de elementos de um array usando arrow functions

+ +

Arrow functions fornece uma sintaxe mais curta para o mesmo teste.

+ +
[2, 5, 8, 1, 4].some(elem => elem > 10);  // false
+[12, 5, 8, 1, 4].some(elem => elem > 10); // true
+
+ +

Polyfill

+ +

some() was added to the ECMA-262 standard in the 5th edition; as such it may not be present in all implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of some() in implementations which do not natively support it. This algorithm is exactly the one specified in ECMA-262, 5th edition, assuming {{jsxref("Object")}} and {{jsxref("TypeError")}} have their original values and that fun.call evaluates to the original value of {{jsxref("Function.prototype.call()")}}.

+ +
// Production steps of ECMA-262, Edition 5, 15.4.4.17
+// Reference: http://es5.github.io/#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;
+  };
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES5.1', '#sec-15.4.4.17', 'Array.prototype.some')}}{{Spec2('ES5.1')}}Definição inicial. Implementada em JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.some', 'Array.prototype.some')}}{{Spec2('ES6')}}
+ +

Compatibilidade em navegadores

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

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/sort/index.html b/files/pt-br/web/javascript/reference/global_objects/array/sort/index.html new file mode 100644 index 0000000000..6b1f8fcc15 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/sort/index.html @@ -0,0 +1,232 @@ +--- +title: Array.prototype.sort() +slug: Web/JavaScript/Reference/Global_Objects/Array/sort +translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort +--- +
{{JSRef}}
+ +

O método sort() ordena os elementos do próprio array e retorna o array. A ordenação não é necessariamente estável. A ordenação padrão é de acordo com a  pontuação de código unicode.

+ +

A complexidade do tempo de execução ou a quantidade de memória utilizada pela ordenação não pode ser garantido e depende da implementação realizada.

+ +

Sintaxe

+ +
arr.sort([funcaoDeComparacao])
+ +

Parâmetros

+ +
+
funcaoDeComparacao {{optional_inline}}
+
Especifica uma função que define a ordenação. Se omitido, o array é ordenado de acordo com a pontuação de código Unicode de cada um dos caracteres, de acordo com a conversão de cada elemento para string.
+
    primeiroElemento
+
    O primeiro elemento para a comparação.
+
    segundoElemento
+
    O segundo elemento para comparação.
+
+

Valor de Retorno

+
+
O array ordenado. Note que o array é ordenado de acordo com a pontuação de código Unicode de cada um dos caracteres, e nenhuma cópia é feita.
+
+ +

Descrição

+ +

Se funcaoDeComparacao não for informado, os elementos serão ordenados de acordo com a sua conversão para texto e o texto comparado na pontuação unicode do texto convertido. Por exemplo, "banana" vem antes de "cherry". Em uma ordenação numérica, 9 vem antes de 80, mas porque os números são convertidos para texto e, "80" vem antes de "9" na ordenação Unicode.

+ +
var fruit = ['cherries', 'apples', 'bananas'];
+fruit.sort(); // ['apples', 'bananas', 'cherries']
+
+var scores = [1, 10, 2, 21];
+scores.sort(); // [1, 10, 2, 21]
+// Observe que 10 vem antes do 2,
+// porque '10' vem antes de '2' em ponto de código Unicode.
+
+var things = ['word', 'Word', '1 Word', '2 Words'];
+things.sort(); // ['1 Word', '2 Words', 'Word', 'word']
+// Em Unicode, números vêem antes de letras maiúsculas,
+// as quais vêem antes das minúsculas.
+
+ +

Se o parametro funcaoDeComparacao é fornecido, o array será ordenado de acordo com o valor de retorno da funcaoDeComparacao. Considerando que a e b são dois elementos sendo comparados, então:

+ + + +

Então, a função de comparação tem a seguinte forma:

+ +
function comparar(a, b) {
+  if (a é menor que b em algum critério de ordenação) {
+    return -1;
+  }
+  if (a é maior que b em algum critério de ordenação) {
+    return 1;
+  }
+  // a deve ser igual a b
+  return 0;
+}
+
+ +

Para comparar números ao invés de texto, a função de comparação pode simplesmente subtrair b de a. A função abaixo irá ordenar o array em ordem crescente:

+ +
function compararNumeros(a, b) {
+  return a - b;
+}
+
+ +

O método de ordenação pode convenientemente ser usada com {{jsxref("Operators/function", "funções anônimas", "", 1)}} (e closures):

+ +
var numbers = [4, 2, 5, 1, 3];
+numbers.sort(function(a, b) {
+  return a - b;
+});
+console.log(numbers);
+
+ +

Objetos podem ser ordenados de acordo com o valor de uma de suas propriedades.

+ +
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 must be equal to b
+  return 0;
+});
+
+ +

Exemplos

+ +

Criando, exibindo, e ordenando um array

+ +

O exemplo abaixo cria quatro arrays e mostra seu conteúdo original, então o conteúdo dos arrays ordenado. Os arrays numéricos são ordenados sem a função de comparação, e então, com a função.

+ +
var stringArray = ['Blue', 'Humpback', 'Beluga'];
+var numericStringArray = ['80', '9', '700'];
+var numberArray = [40, 1, 5, 200];
+var mixedNumericArray = ['80', '9', '700', 40, 1, 5, 200];
+
+function compararNumeros(a, b) {
+  return a - b;
+}
+
+console.log('stringArray:', stringArray.join());
+console.log('Ordenada:', stringArray.sort());
+
+console.log('numberArray:', numberArray.join());
+console.log('Ordenada sem função de comparação:', numberArray.sort());
+console.log('Ordenada com compararNumeros:', numberArray.sort(compararNumeros));
+
+console.log('numericStringArray:', numericStringArray.join());
+console.log('Ordenada sem função de comparação:', numericStringArray.sort());
+console.log('Ordenada com compararNumeros:', numericStringArray.sort(compararNumeros));
+
+console.log('mixedNumericArray:', mixedNumericArray.join());
+console.log('Ordenada sem função de comparação:', mixedNumericArray.sort());
+console.log('Ordenada com compararNumeros:', mixedNumericArray.sort(compararNumeros));
+
+ +

Este exemplo gera a saída abaixo. Como as saídas mostram, quando a função de comparação é usada, os números são ordenados corretamente, sejam eles números ou strings numéricas.

+ +
stringArray: Blue,Humpback,Beluga
+Ordenada: Beluga,Blue,Humpback
+
+numberArray: 40,1,5,200
+Ordenada sem função de comparação: 1,200,40,5
+Ordenada com compararNumeros: 1,5,40,200
+
+numericStringArray: 80,9,700
+Ordenada sem função de comparação: 700,80,9
+Ordenada com compararNumeros: 9,80,700
+
+mixedNumericArray: 80,9,700,40,1,5,200
+Ordenada sem função de comparação: 1,200,40,5,700,80,9
+Ordenada com compararNumeros: 1,5,9,40,80,200,700
+
+ +

Ordenando caracteres não-ASCII

+ +

Para ordenar strings com caracteres não-ASCII, i.e. strings com caracteres acentuados (e, é, è, a, ä, etc.), strings de línguas diferentes do Inglês: use {{jsxref("String.localeCompare")}}. Esta função pode comparar estes caracteres, então eles aparecerão na ordem correta.

+ +
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é']
+
+ +

Ordenando com mapa

+ +

A funcaoDeComparacao pode ser invocada múltiplas vezes por elemento do array. Dependendo da natureza da funcaoDeComparacao, isto pode causar um excesso processamento. Quanto mais trabalho a funcaoDeComparacao fizer, e quanto mais elementos houverem para ordenar, seria mais inteligente considerar  o uso de um mapa para a ordenação. A idéia é percorrer o array uma vez para extrair os valores já processados para a ordenação e armazenar em um array temporário, ordenar o array temporário e então percorrer o array temporário para conseguir a ordenação correta.

+ +
// o array a ser ordenado
+var list = ['Delta', 'alpha', 'CHARLIE', 'bravo'];
+
+// array temporário que armazena os objetos com o índice e o valor para ordenação
+var mapped = list.map(function(el, i) {
+  return { index: i, value: el.toLowerCase() };
+})
+
+// ordenando o array mapeado contendo os dados resumidos
+mapped.sort(function(a, b) {
+  return +(a.value > b.value) || +(a.value === b.value) - 1;
+});
+
+// container para o resultado ordenado
+var result = mapped.map(function(el){
+  return list[el.index];
+});
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Definição Inicial.
{{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')}}
+ +

Compatibilidade de navegadores

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

Veja também

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

Resumo

+ +

O método splice() altera o conteúdo de uma lista, adicionando novos elementos enquanto remove elementos antigos.

+ +

Sintaxe

+ +
array.splice(indice[, deleteCount[, elemento1[, ...[, elementoN]]])
+
+array.splice(indice) // SpiderMonkey/Firefox extension
+ +

Parâmetros

+ +
+
indice
+
Índice o qual deve iniciar a alterar a lista. Se maior que o tamanho total da mesma, nenhum elemento será alterado. Se negativo, irá iniciar a partir daquele número de elementos a partir do fim.
+
+ +
+
deleteCount
+
Um inteiro indicando o número de antigos elementos que devem ser removidos.
+
Se o parâmetro deleteCount não é especificado, ou se é maior que o número de elementos restantes na lista iniciando pelo índice, então todos os elementos até o fim da lista serão deletados.
+
Se deleteCount é 0, nenhum elemento é removido. Neste caso você deve especificar pelo menos um novo elemento.
+
+ +
+
elemento1, ..., elementoN
+
Os elementos a adicionar na lista. Se você não especificar nenhum elemento, splice simplesmente removerá elementos da mesma.
+
+ +

Retorno

+ +

Uma lista contendo os elementos removidos. Se apenas um elemento é removido, por exemplo, uma lista contendo apenas um elemento é retornada. Se nenhum elemento é removido, uma lista vazia é retornada.

+ +

Descrição

+ +

Se você especificar um número diferente de elementos a inserir comparado ao número de elementos que você está removendo, a lista terá um tamanho diferente no final da execução.

+ +

Exemplo

+ +

Exemplo: Removendo 0 elementos do indice 2, e inserindo "drum"

+ +

O script a seguir ilustra o uso do splice:

+ +
var myFish = ["angel", "clown", "mandarin", "surgeon"];
+
+//remove 0 elementos a partir do índice 2, e insere "drum"
+var removed = myFish.splice(2, 0, "drum");
+//myFish é ["angel", "clown", "drum", "mandarin", "surgeon"]
+//removed é [], nenhum elemento removido
+
+//remove 1 elemento do índice 3
+removed = myFish.splice(3, 1);
+//myFish é ["angel", "clown", "drum", "surgeon"]
+//removed é ["mandarim"]
+
+//remove 1 elemento a partir do índice 2, e insere "trumpet"
+removed = myFish.splice(2, 1, "trumpet");
+//myFish é ["angel", "clown", "trumpet", "surgeon"]
+//removed é ["drum"]
+
+//remove 2 elementos a partir do índice 0, e insere "parrot", "anemone" e "blue"
+removed = myFish.splice(0, 2, "parrot", "anemone", "blue");
+//myFish é ["parrot", "anemone", "blue", "trumpet", "surgeon"]
+//removed é ["angel", "clown"]
+
+//remove 2 elementos a partir do indice 3
+removed = myFish.splice(3, Number.MAX_VALUE);
+//myFish é ["parrot", "anemone", "blue"]
+//removed é ["trumpet", "surgeon"]
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
ECMAScript 3rd EditionPadrãoDefinição inicial.
+ Implementado no 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')}} 
+ +

Compatibilidade de Navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
AtributoChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte Básico1.0{{CompatGeckoDesktop("1.7")}}5.5{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
AtributoAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte Básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Compatibilidade com Navegadores Antigos

+ +

O método splice retorna o elemento removido, se somente um elemento é removido (parâmetro deleteCount é 1); caso contrário, o método retorna uma lista contendo os elementos removidos. Note que o último navegador a utilizar JavaScript 1.2 foi o Netscape Navigator 4, então você pode utilizar o splice esperando sempre retornar uma lista.

+ +

Veja Também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/tolocalestring/index.html b/files/pt-br/web/javascript/reference/global_objects/array/tolocalestring/index.html new file mode 100644 index 0000000000..7912113ff7 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/tolocalestring/index.html @@ -0,0 +1,140 @@ +--- +title: Array.prototype.toLocaleString() +slug: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString +--- +
{{JSRef}}
+ +
O método toLocaleString() retorna uma representaçao de elementos de um array. Os elementos são convertidos para Strings utilizando seus respectivos métodos toLocaleString e essas cadeias são separadas por uma sequência específica de localidade (separados por virgula ","). 
+ +
 
+ +

Sintaxe

+ +
array.toLocaleString();
+
+ +

 

+ +

Parâmetros

+ +
+
locales {{optional_inline}}
+
Uma string com uma tag de linguagem BCP 47, ou um array como strings. Para uma forma geral e uma interpretação do arquivo locales, veja a página {{jsxref("Intl")}}.
+
options {{optional_inline}}
+
Um objeto com as propriedades de configurações, para números veja {{jsxref("Number.prototype.toLocaleString()")}}, e para datas veja {{jsxref("Date.prototype.toLocaleString()")}}.
+
+ +

Retorno

+ +

Uma string que representa os elementos de um array.

+ +

Exemplos

+ +

Usando toLocaleString

+ +

Os elementos de um array são convertidos para strings usando seus respectivos métodos toLocaleString:

+ + + +
var numero = 1337;
+var data = new Date();
+var meuArray = [numero, data, 'foo'];
+
+var resultado = meuArray.toLocaleString();
+
+console.log(resultado);
+// saída '1337,July 26, 2015 at 20:02:23 GMT-3,foo'
+// se estiver no Brasil com o fuso horario GMT-0300 (BRT) de Brasília.
+
+ +

Para mais exemplos, veja as páginas {{jsxref("Intl")}}, {{jsxref("NumberFormat")}}, e {{jsxref("DateTimeFormat")}}.

+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentários
{{SpecName('ES3')}}{{Spec2('ES3')}}Definição inicial.
{{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')}} 
+ +

Compatibilidade do Browser

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte Básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte Básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/array/tosource/index.html new file mode 100644 index 0000000000..0eeea7211c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/tosource/index.html @@ -0,0 +1,113 @@ +--- +title: Array.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Array/toSource +tags: + - Não-padrão + - Referencia + - prototipos +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toSource +--- +
{{JSRef}} {{non-standard_header}}
+ +

O método toSource() retorna uma representação string do código fonte do array.

+ +

Sintaxe

+ +
arr.toSource()
+ +

Parâmetros

+ +

Nenhum.

+ +

Descrição

+ +

O método toSource retorna os seguintes valores:

+ + + +

Este método normalmente é chamando internamente pelo JavaScript e não explicitamente no código. Você pode chamar toSource durante o debug para examinar o conteúdo de um array.

+ +

Exemplos

+ +

Examinando o código fonte de um array

+ +

Para examinar o código fonte de um array:

+ +
var alpha = new Array('a', 'b', 'c');
+
+alpha.toSource();   //retorna ['a', 'b', 'c']
+
+ +

Especificações

+ +

Não é parte de nenhum padrão. Implementado no JavaScript 1.3.

+ +

Compatibilidade com os navegadores

+ +

A tabela de compatibilidade encontrada nesta página é gerada a partir de dados estruturados. Se você deseja contribuir com os dados, consulte https://github.com/mdn/browser-compat-data e envie-nos um "pull request".

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatNo}}{{CompatVersionUnknown}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatNo}}{{CompatNo}}{{CompatVersionUnknown}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

Ver também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/array/tostring/index.html new file mode 100644 index 0000000000..d10cd2e032 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/tostring/index.html @@ -0,0 +1,115 @@ +--- +title: Array.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Array/toString +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toString +--- +
{{JSRef}}
+ +

O método toString() retorna uma string representando um array específico e seus elementos.

+ +

Sintaxe

+ +
arr.toString()
+ +

Parâmetros

+ +

Nenhum.

+ +

Descrição

+ +

O objeto {{jsxref("Array")}} substitui o método toString() de {{jsxref("Object")}}. Para objetos do tipo Array, o método toString() concatena todos os valores em apenas uma string. Segue exemplo abaixo, de como ele se comporta.

+ +
var monthNames = ['Jan', 'Feb', 'Mar', 'Apr'];
+var myVar = monthNames.toString(); // atribui 'Jan,Feb,Mar,Apr' para myVar.
+
+ +

JavaScript chama o método toString automaticamente quando um Array é para ser representado como um valor de texto ou quando um Array é designado em uma concatenação.

+ +

Semântica ECMAScript 5

+ +

Implementado no JavaScript 1.8.5 (Firefox 4), e compatível com a 5ª versão do ECMAScript, a função toString() é genérica e pode ser usada em qualquer Objeto. Se o objeto tem um método join(), ele será chamado e esse valor será devolvido. Do contrário, {{jsxref("Object.prototype.toString()")}} será chamado, e o valor será retornado.

+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentários
{{SpecName('ES1')}}{{Spec2('ES1')}}Definição inicial. Implementado no 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')}} 
+ +

Browsers compatíveis

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
RecursoChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
RecursoAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/unobserve/index.html b/files/pt-br/web/javascript/reference/global_objects/array/unobserve/index.html new file mode 100644 index 0000000000..a509f16afb --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/unobserve/index.html @@ -0,0 +1,129 @@ +--- +title: Array.unobserve() +slug: Web/JavaScript/Reference/Global_Objects/Array/unobserve +translation_of: Archive/Web/JavaScript/Array.unobserve +--- +
{{JSRef}}
+ +
O método Array.unobserve() é usado para remover observers adicionados pelo {{jsxref("Array.observe()")}}.
+ +
 
+ +

Sintaxe

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

Parâmetros

+ +
+
arr
+
O array para remover os observers.
+
callback
+
A referência para o observer para parar de ser chamada a toda vez em que algo é modificado no array arr.
+
+ +

Descrição

+ +

Array.unobserve() deve ser chamado após o  {{jsxref("Array.observe()")}} a fim de remover um observers de um array.

+ +

O callback deve ser uma referencia à uma função e não a uma função anônima, porquê esta referencia será usada para remover o observer anterior. É inútil chamar o Array.unobserve() com uma função anônima como callback, não removerá nenhum observer.

+ +

Exemplos

+ +

Desobservando um array

+ +
var arr = [1, 2, 3];
+
+var observer = function(changes) {
+  console.log(changes);
+}
+
+Array.observe(arr, observer);
+​
+arr.push(4);
+// [{type: "splice", object: <arr>, index: 3, removed:[], addedCount: 1}]
+
+Array.unobserve(arr, observer);
+
+arr.pop();
+// O callback não foi chamado
+ +

Usando uma função anônima

+ +
var persons = ['Khalid', 'Ahmed', 'Mohammed'];
+
+Array.observe(persons, function (changes) {
+  console.log(changes);
+});
+
+persons.shift();
+// [{type: "splice", object: <arr>, index: 0, removed: [ "Khalid" ], addedCount: 0 }]
+
+Array.unobserve(persons, function (changes) {
+  console.log(changes);
+});
+
+persons.push('Abdullah');
+// [{type: "splice", object: <arr>, index: 2, removed: [], addedCount: 1 }]
+// O callback sempre será chamado
+
+ +

Compatibilidade com os navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatChrome("36")}}{{CompatNo}}{{CompatNo}}{{CompatOpera("23")}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatNo}}{{CompatChrome("36")}}{{CompatNo}}{{CompatNo}}{{CompatOpera("23")}}{{CompatNo}}
+
+ +

Ver também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/unshift/index.html b/files/pt-br/web/javascript/reference/global_objects/array/unshift/index.html new file mode 100644 index 0000000000..bdf6c0e4d9 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/unshift/index.html @@ -0,0 +1,90 @@ +--- +title: Array.prototype.unshift() +slug: Web/JavaScript/Reference/Global_Objects/Array/unshift +tags: + - Array + - JavaScript + - Prototype + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/unshift +--- +
{{JSRef("Global_Objects", "Array")}}
+ +

Introdução

+ +

O método unshift() adiciona um ou mais elementos no início de um array e retorna o número de elementos (propriedade length) atualizado.

+ +

Sintaxe

+ +
arr.unshift([element1[, ...[, elementN]]])
+ +

Parâmetros

+ +
+
elementN
+
Os elementos a serem adicionados no começo do array.
+
+ +

Retorna

+ +

A nova propriedade {{jsxref("Array.length", "length")}} do objeto acima onde o método foi chamado.

+ +

Descrição

+ +

O método unshift insere os valores fornecidos no início de um objeto do tipo array.

+ +

unshift é intencionalmente genérico; este método pode ser chamado via {{jsxref("Function.call", "call", "", 1)}} ou {{jsxref("Function.apply", "apply", "", 1)}} em objetos que se assemelham aos arrays. Objetos que não contêm uma propriedade length que reflete a última de uma série consecutiva de propriedades numéricas, iniciada por 0, podem não comportar-se de maneira significativa.

+ +

Exemplos

+ +
var arr = [1, 2];
+
+arr.unshift(0); // result of call is 3, the new array length
+// arr is [0, 1, 2]
+
+arr.unshift(-2, -1); // = 5
+// arr is [-2, -1, 0, 1, 2]
+
+arr.unshift([-3]);
+// arr is [[-3], -2, -1, 0, 1, 2]
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
ECMAScript 3ª EdiçãoPadrãoDefinição inicial. Implementado no 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')}}
+ +

Compatibilidade entre browsers

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

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/array/values/index.html b/files/pt-br/web/javascript/reference/global_objects/array/values/index.html new file mode 100644 index 0000000000..d3e918e1b9 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/values/index.html @@ -0,0 +1,121 @@ +--- +title: Array.prototype.values() +slug: Web/JavaScript/Reference/Global_Objects/Array/values +translation_of: Web/JavaScript/Reference/Global_Objects/Array/values +--- +
{{JSRef}}
+ +

O método values() retorna um novo objeto de  Array Iterator que contém os valores para cada índice no array.

+ +

Sintaxe

+ +
arr.values()
+ +

Exemplos

+ +

Iteração usando for...of loop

+ +
var arr = ['w', 'y', 'k', 'o', 'p'];
+var eArr = arr.values();
+// seu navegador deve suportar for..of loop
+// e deixar variáveis let-scoped no for loops
+for (let letter of eArr) {
+  console.log(letter);
+}
+
+ +

Iteração alternativa

+ +
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
+
+ +

Especificações

+ + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES6', '#sec-array.prototype.values', 'Array.prototype.values')}}{{Spec2('ES6')}}Definição inicial.
+ +

Compatibilidade de navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

Notas específicas do Firefox

+ + + +

Ver também

+ + -- cgit v1.2.3-54-g00ecf