From a55b575e8089ee6cab7c5c262a7e6db55d0e34d6 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:46:50 +0100 Subject: unslug es: move --- .../global_objects/array/@@iterator/index.html | 89 ++++ .../global_objects/array/@@species/index.html | 76 ++++ .../global_objects/array/@@unscopables/index.html | 78 ++++ .../global_objects/array/concat/index.html | 140 +++++++ .../global_objects/array/copywithin/index.html | 165 ++++++++ .../global_objects/array/entries/index.html | 86 ++++ .../global_objects/array/every/index.html | 195 +++++++++ .../reference/global_objects/array/fill/index.html | 145 +++++++ .../global_objects/array/filter/index.html | 231 +++++++++++ .../reference/global_objects/array/find/index.html | 233 +++++++++++ .../global_objects/array/findindex/index.html | 187 +++++++++ .../reference/global_objects/array/flat/index.html | 174 ++++++++ .../global_objects/array/flatmap/index.html | 128 ++++++ .../global_objects/array/foreach/index.html | 257 ++++++++++++ .../reference/global_objects/array/from/index.html | 242 +++++++++++ .../global_objects/array/includes/index.html | 181 +++++++++ .../reference/global_objects/array/index.html | 449 +++++++++++++++++++++ .../global_objects/array/indexof/index.html | 248 ++++++++++++ .../global_objects/array/isarray/index.html | 128 ++++++ .../reference/global_objects/array/join/index.html | 110 +++++ .../reference/global_objects/array/keys/index.html | 84 ++++ .../global_objects/array/lastindexof/index.html | 164 ++++++++ .../global_objects/array/length/index.html | 143 +++++++ .../reference/global_objects/array/map/index.html | 360 +++++++++++++++++ .../reference/global_objects/array/of/index.html | 97 +++++ .../reference/global_objects/array/pop/index.html | 94 +++++ .../reference/global_objects/array/push/index.html | 140 +++++++ .../global_objects/array/reduce/index.html | 215 ++++++++++ .../global_objects/array/reduceright/index.html | 166 ++++++++ .../global_objects/array/reverse/index.html | 88 ++++ .../global_objects/array/shift/index.html | 124 ++++++ .../global_objects/array/slice/index.html | 287 +++++++++++++ .../reference/global_objects/array/some/index.html | 204 ++++++++++ .../reference/global_objects/array/sort/index.html | 301 ++++++++++++++ .../global_objects/array/splice/index.html | 148 +++++++ .../global_objects/array/tolocalestring/index.html | 177 ++++++++ .../global_objects/array/tosource/index.html | 112 +++++ .../global_objects/array/tostring/index.html | 78 ++++ .../global_objects/array/unshift/index.html | 100 +++++ .../global_objects/array/values/index.html | 82 ++++ 40 files changed, 6706 insertions(+) create mode 100644 files/es/web/javascript/reference/global_objects/array/@@iterator/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/@@species/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/@@unscopables/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/concat/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/copywithin/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/entries/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/every/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/fill/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/filter/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/find/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/findindex/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/flat/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/flatmap/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/foreach/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/from/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/includes/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/indexof/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/isarray/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/join/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/keys/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/lastindexof/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/length/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/map/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/of/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/pop/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/push/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/reduce/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/reduceright/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/reverse/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/shift/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/slice/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/some/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/sort/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/splice/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/tolocalestring/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/tosource/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/tostring/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/unshift/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/values/index.html (limited to 'files/es/web/javascript/reference/global_objects/array') diff --git a/files/es/web/javascript/reference/global_objects/array/@@iterator/index.html b/files/es/web/javascript/reference/global_objects/array/@@iterator/index.html new file mode 100644 index 0000000000..65ac581204 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/@@iterator/index.html @@ -0,0 +1,89 @@ +--- +title: 'Array.prototype[@@iterator]()' +slug: Web/JavaScript/Referencia/Objetos_globales/Array/@@iterator +tags: + - Array + - ECMAScript 2015 + - Iterator + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@iterator +--- +
{{JSRef}}
+ +

El valor inicial de la propiedad @@iterator es el mismo objeto de función que el valor inicial de la propiedad {{jsxref("Array.prototype.values()", "values()")}}.

+ +

Sintaxis

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

Valor de retorno

+ +

El valor inicial dado por el iterador {{jsxref("Array.prototype.values()", "values()")}}. Por defecto, usar arr[Symbol.iterator] devolverá la función {{jsxref("Array.prototype.values()", "values()")}}.

+ +

Ejemplos

+ +

Iteración usando el bucle for...of 

+ +
var arr = ['w', 'y', 'k', 'o', 'p'];
+var eArr = arr[Symbol.iterator]();
+// nuestro navegador debe ser compatible con el bucle for..of
+// y variables let-scoped en bucles for
+for (let letter of eArr) {
+  console.log(letter);
+}
+
+ +

Iteración 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
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES2015', '#sec-array.prototype-@@iterator', 'Array.prototype[@@iterator]()')}}{{Spec2('ES2015')}}Definición inicial..
{{SpecName('ESDraft', '#sec-array.prototype-@@iterator', 'Array.prototype[@@iterator]()')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ +
+ + +

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

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/@@species/index.html b/files/es/web/javascript/reference/global_objects/array/@@species/index.html new file mode 100644 index 0000000000..2f15ad345a --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/@@species/index.html @@ -0,0 +1,76 @@ +--- +title: 'get Array[@@species]' +slug: Web/JavaScript/Referencia/Objetos_globales/Array/@@species +tags: + - Array + - JavaScript + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@species +--- +
{{JSRef}}
+ +

La propiedad de acceso Array[@@species] devuelve el constructor de Array.

+ +

Sintaxis

+ +
Array[Symbol.species]
+
+ +

Valor de retorno

+ +

El constructor {{jsxref("Array")}}.

+ +

Descripción

+ +

La propiedad de acceso species devuelve el constructor predeterminado para objetos Array. Los constructores de subclase pueden anularlo para cambiar la asignación del constructor.

+ +

Ejemplos

+ +

La propiedad species devuelve la función de constructor predeterminada, que es el constructor Array para objetos Array:

+ +
Array[Symbol.species]; // function Array()
+ +

In a derived collection object (e.g. your custom array MyArray), the MyArray species is the MyArray constructor. However, you might want to overwrite this, in order to return parent Array objects in your derived class methods:

+ +
class MyArray extends Array {
+  // Overwrite MyArray species to the parent Array constructor
+  static get [Symbol.species]() { return Array; }
+}
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES6', '#sec-get-array-@@species', 'get Array [ @@species ]')}}{{Spec2('ES6')}}Definición inicial.
{{SpecName('ESDraft', '#sec-get-array-@@species', 'get Array [ @@species ]')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ +
+ + +

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

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/@@unscopables/index.html b/files/es/web/javascript/reference/global_objects/array/@@unscopables/index.html new file mode 100644 index 0000000000..43dc771ae7 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/@@unscopables/index.html @@ -0,0 +1,78 @@ +--- +title: 'Array.prototype[@@unscopables]' +slug: Web/JavaScript/Referencia/Objetos_globales/Array/@@unscopables +tags: + - Array + - JavaScript + - Matriz + - Propiedad + - Prototipo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@unscopables +--- +
{{JSRef}}
+ +

La propiedad de símbolo @@unscopable contiene nombres de propiedad que no se incluyeron en el estándar ECMAScript antes de la versión ES2015. Estas propiedades se excluyen de los enlaces de declaración with.

+ +

Sintaxis

+ +
arr[Symbol.unscopables]
+ +

Descripción

+ +

 

+ +

Las propiedades de matriz predeterminadas que se excluyen de los enlaces with son: copyWithin, entries, fill, find, findIndex, includes, keys, y values.

+ +

Consulte {{jsxref("Symbol.unscopables")}} para saber cómo configurar unscopables para sus propios objetos.

+ +

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

+ +

Ejemplos

+ +

El siguiente código funciona bien en ES5 y más abajo. Sin embargo, en ECMAScript 2015 y posterior, se introdujo el método {{jsxref("Array.prototype.keys()")}}. Eso significa que dentro de los entornos with, las "keys" ahora serían el método y no la variable. Aquí es donde entra en juego la propiedad de símbolo @@unscopables Array.prototype[@@unscopables] incorporada y evita que algunos de los métodos Array tengan un alcance en la instrucción with.

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

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES2015', '#sec-array.prototype-@@unscopables', 'Array.prototype[@@unscopables]')}}{{Spec2('ES2015')}}Definición inicial.
{{SpecName('ESDraft', '#sec-array.prototype-@@unscopables', 'Array.prototype[@@unscopables]')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ +
+ + +

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

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/concat/index.html b/files/es/web/javascript/reference/global_objects/array/concat/index.html new file mode 100644 index 0000000000..dc7dfc999d --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/concat/index.html @@ -0,0 +1,140 @@ +--- +title: Array.prototype.concat() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/concat +tags: + - Array + - JavaScript + - Métodos + - Prototipo + - Referencia + - array.concat + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/concat +--- +
{{JSRef}}
+ +

El método concat() se usa para unir dos o más arrays. Este método no cambia los arrays existentes, sino que devuelve un nuevo array.

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

Sintaxis

+ +
var nuevo_array = viejo_array.concat(valor1[, valor2[, ...[, valorN]]])
+ +

Parámetros

+ +
+
valorN {{optional_inline}}
+
Arrays y/o valores a concatenar en el nuevo array. Ver la descripción posterior para más detalles.
+
+ +

Valor devuelto

+ +
+
Una nueva instancia de {{jsxref("Array")}}.
+
+ +

Descripción

+ +

El método concat crea un nuevo array que consta de los elementos del objeto que lo llama, seguido, en orden de ingreso, por los elementos de cada parámetro (en caso de que el parámetro sea un array), o el parámetro mismo (en caso de que no sea un array). No se aplica de forma recursiva a parámetros con arreglos anidados.

+ +

El método concat no altera this el array original, ni ninguno de los que fueron ingresados como parámetros, sino que devuelve una copia superficial que contiene copias de los mismos elementos de los arrays originales combinados. Los elementos de los arrays originales son copiados en el nuevo array de la siguiente manera:

+ + + +
+

Nota: Al concatenar arrays o valores no se modificarán los originales. Además, las operaciones en el nuevo array (excepto las operaciones en elementos que son referencias a objetos) no tendrán efecto en el array original, y viceversa.

+
+ +

Ejemplos

+ +

Concatenando dos arrays

+ +

En el siguiente código se concatenan dos arrays:

+ +
const letters = ['a', 'b', 'c'];
+const numbers = [1, 2, 3];
+
+letters.concat(numbers);
+// result in ['a', 'b', 'c', 1, 2, 3]
+
+ +

Concatenando tres arrays

+ +

En el siguiente código se concatenan tres arrays:

+ +
const num1 = [1, 2, 3];
+const num2 = [4, 5, 6];
+const num3 = [7, 8, 9];
+
+const numbers = num1.concat(num2, num3);
+
+console.log(numbers);
+// results in [1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+ +

Concatenando valores a un array

+ +

En el siguiente código se concatenan tres valores a un array:

+ +
var alpha = ['a', 'b', 'c'];
+
+var alphaNumeric = alpha.concat(1, [2, 3]);
+
+console.log(alphaNumeric);
+// Da como resultado: ['a', 'b', 'c', 1, 2, 3]
+
+ +

Concatenando arrays anidados

+ +

En el siguiente código concatena arrays anidados y demuestra retención de referencias:

+ +
var num1 = [[1]];
+var num2 = [2, [3]];
+
+var nums = num1.concat(num2);
+
+console.log(nums);
+// Da como resultado: [[1], 2, [3]]
+
+// modifica el primer elemento de num1
+num1[0].push(4);
+
+console.log(nums);
+// Da como resultado: [[1, 4], 2, [3]]
+ +

Especificaciones

+ + + + + + + + + + + + +
Especificación
{{SpecName('ESDraft', '#sec-array.prototype.concat', 'Array.prototype.concat')}}
+ +

Compatibilidad con navegadores

+ +
+

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

+
+ +
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/copywithin/index.html b/files/es/web/javascript/reference/global_objects/array/copywithin/index.html new file mode 100644 index 0000000000..e28b99c382 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/copywithin/index.html @@ -0,0 +1,165 @@ +--- +title: Array.prototype.copyWithin() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/copyWithin +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Prototipo + - Referencia + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/copyWithin +--- +
{{JSRef}}
+ +

El método copyWithin() transfiere una copia  plana de una sección a otra dentro del mismo array ( o contexto similar ), sin modificar su propiedad length y lo devuelve.

+ +

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

+ +

Sintaxis

+ +
arr.copyWithin(target)
+arr.copyWithin(target, start)
+arr.copyWithin(target, start, end)
+ +

Parámetros

+ +
+
target
+
Índice basado en cero que establece en dónde dentro de la secuencia original se insertará la secuencia copiada.  Si es negativo, target se contará desde el final. -1 es el último elemento, -2 el penúltimo, etc.
+
Si target es  igual o mayor que  arr.length, no se copiará nada. Si target es posicionado después de start, la secuencia copiada se recortará para que encaje con arr.length.
+
start {{optional_inline}}
+
Índice basado en cero a partir del cual comenzar la copia de elementos. Si es negativo, start comenzará a contarse desde el final.
+
Si start es omitido, copyWithin copiará desde el principio (por defecto es 0).
+
end {{optional_inline}}
+
Índice basado en cero hasta el cual se copiarán los elementos. copyWithin copiará hasta pero sin incluir el end. Si es negativo, end será contado desde el final.
+
Si end es omitido, copyWithin copiará hasta el final ( por defecto es arr.length ).
+
+ +

Valor de retorno

+ +

El array modificado.

+ +

Descripción

+ +

copyWithin es similar a la función memmove de C y C++  , siendo altamente eficiente para desplazar los datos en un {{jsxref("Array")}} o  {{jsxref("TypedArray")}}. La secuencia de datos es leída y escrita en una sola operación;  la escritura será correcta incluso en el caso de que la zona de lectura y el destino de escritura se solapen.

+ +

La función copyWithin es intencionadamente genérica, permitiendo que se aplique en contextos en los cuales this no sea necesariamente un objeto {{jsxref("Array")}}.

+ +

El método copyWithin es un método mutador. No altera la propiedad length de this, pero cambiará su contenido y creará nuevas propiedades si es necesario.

+ +

Ejemplos

+ +

En los siguientes ejemplos céntrate en los siguientes aspectos:

+ + + +
[1, 2, 3, 4, 5].copyWithin(-2);
+// [1, 2, 3, 1, 2]
+
+[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(-2, -3, -1);
+// [1, 2, 3, 3, 4]
+
+ +

A continuación se aplica en el contexto de un objeto array-like:

+ + + +
[].copyWithin.call({length: 5, 3: 1}, 0, 3);
+// {0: 1, 3: 1, length: 5}
+
+
+ +

Lo que sigue ahora son las subclases tipadas de Array en ES6:

+ +
// Arrays tipados en ES6. Son subclases de Array
+var i32a = new Int32Array([1, 2, 3, 4, 5]);
+
+i32a.copyWithin(0, 2);
+// Int32Array [3, 4, 5, 4, 5]
+
+// En plataformas que todavía no siguen la norma 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 =
+  // Array: Number[, Number[, Number]]
+  function copyWithin(target, start, stop) {
+    var positiveT = target >= 0,
+        positiveS = (start = start | 0) >= 0,
+        length    = this.length,
+        zero      = 0,
+        r         = function() {return ((+new Date) * Math.random()).toString(36)},
+        delimiter = "\b" + r() + "-" + r() + "-" + r() + "\b",
+        hold;
+
+    stop = stop || this.length;
+    hold = this.slice.apply(this,
+      positiveT?
+        [start, stop]:
+      positiveS?
+        [start, -target]:
+      [start])
+    .join(delimiter);
+
+    return this.splice.apply(this,
+      positiveT?
+        [target, stop - start, hold]:
+      positiveS?
+        [target, stop, hold]:
+      [target, start, hold]),
+            this.join(delimiter).split(delimiter).slice(zero, length);
+  }
+}
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES6', '#sec-array.prototype.copyWithin', 'Array.prototype.copyWithin')}}{{Spec2('ES6')}}Definición inicial.
{{SpecName('ESDraft', '#sec-array.prototype.copyWithin', 'Array.prototype.copyWithin')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ +
+

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

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/entries/index.html b/files/es/web/javascript/reference/global_objects/array/entries/index.html new file mode 100644 index 0000000000..89fef6475f --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/entries/index.html @@ -0,0 +1,86 @@ +--- +title: Array.prototype.entries() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/entries +tags: + - Array + - ECMAScript 2015 + - Iterador + - Iterator + - JavaScript + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/entries +--- +
{{JSRef}}
+ +
El método entries() retorna un nuevo objeto Array Iterator que contiene los pares clave/valor para cada índice de la matriz.
+ +
 
+ +
+

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

+
+ +

Sintaxis

+ +
arr.entries()
+ +

Valor de retorno

+ +

Un nuevo objeto iterador {{jsxref("Array")}}.

+ +

Ejemplos

+ +

Usando un bucle for…of 

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

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentarios
{{SpecName('ES6', '#sec-array.prototype.entries', 'Array.prototype.entries')}}{{Spec2('ES6')}}Definición inicial.
{{SpecName('ESDraft', '#sec-array.prototype.entries', 'Array.prototype.entries')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ +
+

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

+
+ +
 
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/every/index.html b/files/es/web/javascript/reference/global_objects/array/every/index.html new file mode 100644 index 0000000000..540ebbdfa9 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/every/index.html @@ -0,0 +1,195 @@ +--- +title: Array.prototype.every() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/every +tags: + - Arreglo + - ECMAScript 5 + - JavaScript + - Prototipo + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/every +--- +
{{JSRef}}
+ +

Determina si todos los elementos en el array satisfacen una condición.

+ +
+

Precaución: ¡Llamar este método en un array vacío devuelve true para cualquier condición!

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

Sintaxis

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

Parámetros

+ +
+
callback
+
Una función para probar cada elemento; recibe tres argumentos: +
+
currentValue (required)
+
El elemento actual del arreglo que está siendo procesado.
+
index {{Optional_inline}}
+
El índice del elemento actual del arreglo que está siendo procesado.
+
array {{Optional_inline}}
+
El arreglo sobre el cual fue llamado every.
+
+
+
thisArg {{Optional_inline}}
+
Valor por usar como this cuando se ejecute callback.
+
+ +

Valor de retorno

+ +

true si la función de devolución de llamada devuelve un valor de {{Glossary("truthy")}} para cada elemento de matriz; de lo contrario, false.

+ +

Descripción

+ +

El método every ejecuta la función callback dada una vez por cada elemento presente en el arreglo hasta encontrar uno que haga retornar un valor falso a callback (un valor que resulte falso cuando se convierta a booleano).  Si no se encuentra tal elemento, el método every de inmediato retorna  false. O si  callback retorna verdadero para todos los elementos, every retornará true. callback es llamada sólo para índices del arreglo que tengan valores asignados; no se llama para índices que hayan sido eliminados o a los que no se les haya asignado un valor.

+ +

callback es llamada con tres argumetos: el valor del elemento, el índice del elemento y el objeto Array que está siendo recorrido.

+ +

Si se proporciona un parámetro thisArg a every, será pasado a la función callback cuando sea llamada, usándolo como valor this. En otro caso, se pasará el valor undefined para que sea usado como valor this.  El valor this observable por parte de  callback se determina de acuerdo a las normas usuales para determinar el this visto por una función.

+ +

every no modifica el arreglo sobre el cual es llamado.

+ +

El intervalo de elementos procesados por every se establece antes de la primera llamada a callback.  Los elementos que se agreguen al arreglo después de que la función every comience no serán vistos por la función callback.  Si se modifican elementos existentes en el arreglo, su valor cuando sea pasado a callback será el valor que tengan cuando sean visitados; los elementos que se eliminen no serán visitados.

+ +

every opera como el cuantificador "para todo" en matemáticas. En particular con el arreglo vacío retorna true. (es una verdad vacua que todos los elementos del conjunto vacío satisfacen una condición dada.)

+ +

Ejemplos

+ +

Probando el tamaño de todos los elementos de un arreglo

+ +

El siguiente ejemplo prueba si todos los elementos de un arreglo son mayores que 10.

+ +
function esSuficientementeGrande(elemento, indice, arrreglo) {
+  return elemento >= 10;
+}
+[12, 5, 8, 130, 44].every(esSuficientementeGrande);   // false
+[12, 54, 18, 130, 44].every(esSuficientementeGrande); // true
+
+ +

Usar funciones flecha

+ +

Las funciones flecha proveen una sintaxis más corta para la misma prueba.

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

Polyfill

+ +

every fue añadida a la norma ECMA-262 en la 5ta edición; por lo que podría no estar presente en otras implementaciones de la norma.  Puede sobrellevarlo insertando el siguiente código al comienzo de su programa,  permitiendo el uso de every  en implementación que no lo soporten de manera nativa. Este algoritmo es exactamente el especificado en ECMA-262, 5ta edición, suponiendo que  Object y TypeError tienen sus valores originales y que  callbackfn.call evalua al 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;
+  };
+}
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES5.1', '#sec-15.4.4.16', 'Array.prototype.every')}}{{Spec2('ES5.1')}}Initial definition. Implemented in JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.every', 'Array.prototype.every')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-array.prototype.every', 'Array.prototype.every')}}{{Spec2('ESDraft')}}
+ +

Compatibilidad con navegadores

+ +
+

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

+
+ +
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/fill/index.html b/files/es/web/javascript/reference/global_objects/array/fill/index.html new file mode 100644 index 0000000000..7113df34bd --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/fill/index.html @@ -0,0 +1,145 @@ +--- +title: Array.prototype.fill() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/fill +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Prototipo + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/fill +--- +
{{JSRef}}
+ +

El método fill() cambia todos los elementos en un arreglo por un valor estático, desde el índice start (por defecto 0) hasta el índice end (por defecto array.length). Devuelve el arreglo modificado.

+ +

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

+ +

Sintaxis

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

Parámetros

+ +
+
value
+
Valor con el que se va a rellenar el arreglo. (Nótese que todos los elementos en el arreglo tendrán este mismo valor).
+
start {{optional_inline}}
+
Índice inicial, por defecto 0.
+
end {{optional_inline}}
+
Índice final, por defecto this.length.
+
+ +

Valor de retorno

+ +

El arreglo modificado, rellenado con valor.

+ +

Descripción

+ + + +

Ejemplos

+ +
[1, 2, 3].fill(4);               // [4, 4, 4]
+[1, 2, 3].fill(4, 1);            // [1, 4, 4]
+[1, 2, 3].fill(4, 1, 2);         // [1, 4, 3]
+[1, 2, 3].fill(4, 1, 1);         // [1, 2, 3]
+[1, 2, 3].fill(4, 3, 3);         // [1, 2, 3]
+[1, 2, 3].fill(4, -3, -2);       // [4, 2, 3]
+[1, 2, 3].fill(4, NaN, NaN);     // [1, 2, 3]
+[1, 2, 3].fill(4, 3, 5);         // [1, 2, 3]
+Array(3).fill(4);                // [4, 4, 4]
+[].fill.call({ length: 3 }, 4);  // {0: 4, 1: 4, 2: 4, length: 3}
+
+// Objects by reference.
+var arr = Array(3).fill({}) // [{}, {}, {}];
+arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }]
+ +

Polyfill

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

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES6', '#sec-array.prototype.fill', 'Array.prototype.fill')}}{{Spec2('ES6')}}Definición inicial.
{{SpecName('ESDraft', '#sec-array.prototype.fill', 'Array.prototype.fill')}}{{Spec2('ESDraft')}}
+ +

Compatibilidad con navegadores

+ +
+

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

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/filter/index.html b/files/es/web/javascript/reference/global_objects/array/filter/index.html new file mode 100644 index 0000000000..98e6843c4f --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/filter/index.html @@ -0,0 +1,231 @@ +--- +title: Array.prototype.filter() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/filter +tags: + - Array + - ECMAScript 5 + - JavaScript + - Prototipo + - Referencia + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/filter +--- +
{{JSRef}}
+ +

El método filter() crea un nuevo array con todos los elementos que cumplan la condición implementada por la función dada.

+ +

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

+ +

Sintaxis

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

Parámetros

+ +
+
callback
+
Función que comprueba cada elemento del array para ver si cumple la condición (también llamada predicado).  Retorna true si el elemento la cumple o en caso contrario retornará false. Acepta tres parámetros:
+
+
+
currentValue
+
El elemento actual del array que está siendo procesado.
+
index {{optional_inline}}
+
El índice del elemento actual del array que está siendo procesado.
+
array {{optional_inline}}
+
El array sobre el que se ha llamado filter.
+
+
+
thisArg {{optional_inline}}
+
Opcional. Valor a utilizar como this cuando se ejecuta callback.
+
+ +

Valor devuelto

+ +

Un nuevo array con los elementos que cumplen la condición. Si ningún elemento cumple la condición, se devolverá un array vacío.

+ +

Descripción

+ +

filter() llama a la función callback  sobre cada elemento del array, y construye un nuevo array con todos los valores para los cuales  callback devuelve un valor verdadero. callback es invocada sólo para índices del array que tengan un valor asignado. No se invoca sobre índices que hayan sido borrados o a los que no se les haya asignado algún valor. Los elementos del array que no cumplan la condición callback  simplemente los salta, y no son incluidos en el nuevo array.

+ +

callback se invoca con tres argumentos:

+ +
    +
  1. El valor de cada elemento
    2. +
  2. El índice del elemento
    3. +
  3. El objeto Array que se está recorriendo
    4. +
+ +

Si se proporciona un parámetro thisArg a filter(), este será pasado a callback cuando sea invocado, para usarlo como valor this.  De lo contrario, se pasará el valor undefined como valor this.  El valor this dentro del callback se determina conforme a las las normas habituales para determinar el this visto por una función.

+ +

filter() no hace mutar el array sobre el cual es llamado.

+ +

El rango de elementos procesados por filter() se establece antes de la primera invocación de  callback. Los elementos que se añadan al array después de que comience la llamada a filter() no serán visitados por callback. Si se modifica o elimina un elemento existente del array, cuando pase su valor a callback será el que tenga cuando filter() lo recorra; los elementos que son eliminados no son recorridos.

+ +

Ejemplos

+ +

Filtrando todos los valores pequeños

+ +

El siguiente ejemplo usa filter() para crear un array filtrado que excluye todos los elementos con valores inferiores a 10.

+ +
function esSuficientementeGrande(elemento) {
+  return elemento >= 10;
+}
+var filtrados = [12, 5, 8, 130, 44].filter(esSuficientementeGrande);
+// filtrados es [12, 130, 44]
+
+ +

Filtrando entradas inválidas desde un JSON

+ +

El siguiente ejemplo emplea filter() para crear un json filtrado con todos lo elementos que tengan id numérico distinto de cero.

+ +
var arr = [
+  { id: 15 },
+  { id: -1 },
+  { id: 0 },
+  { id: 3 },
+  { id: 12.2 },
+  { },
+  { id: null },
+  { id: NaN },
+  { id: 'undefined' }
+];
+
+var entradasInvalidas = 0;
+// Si el elemento tiene un atributo id, y su valor correspondiente es un numero
+// Y no es el valor NaN, entonces es una entrada válida
+function filtrarPorID(obj) {
+  if ('id' in obj && typeof(obj.id) === 'number' && !isNaN(obj.id)) {
+    return true;
+  } else {
+    entradasInvalidas++;
+    return false;
+  }
+}
+
+var arrPorID = arr.filter(filtrarPorID);
+
+console.log('Array Filtrado\n', arrPorID);
+// [{ id: 15 }, { id: -1 }, { id: 0 }, { id: 3 }, { id: 12.2 }]
+
+console.log('Número de Entradas Invalidas = ', entradasInvalidas);
+// 4
+ +

Búsqueda en el arreglo

+ +

El siguiente ejemplo emplea filter() para filtrar el contendio de un arreglo en función de un criterio de búsqueda.

+ +
var fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];
+
+/**
+ * Filtra la matríz en función de un criterio de búsqueda (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']
+ +

Implementación en ES2015

+ +
const fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];
+
+/**
+ * Filtra la matríz en función de un criterio de búsqueda (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() se añadió a la norma ECMA-262 en la 5ta edición; como tal puede no estar presente en todas las implementaciones de la norma. Puedes sobrellevarlo insertando el siguiente código al comienzo de su programa, para permitir el uso de filter() en implementaciones de ECMA-262 que no lo soporten de forma nativa. Este algoritmo es exactamente el especificado en ECMA-262, 5ta edición, supone que  fn.call evalua al valor original de {{jsxref("Function.prototype.call")}}, y que {{jsxref("Array.prototype.push")}} tiene su valor original.

+ +
if (!Array.prototype.filter){
+  Array.prototype.filter = function(func, thisArg) {
+    'use strict';
+    if ( ! ((typeof func === 'Function' || typeof func === 'function') && this) )
+        throw new TypeError();
+
+    var len = this.length >>> 0,
+        res = new Array(len), // preallocate array
+        t = this, c = 0, i = -1;
+
+    var kValue;
+    if (thisArg === undefined){
+      while (++i !== len){
+        // checks to see if the key was set
+        if (i in this){
+          kValue = t[i]; // in case t is changed in callback
+          if (func(t[i], i, t)){
+            res[c++] = kValue;
+          }
+        }
+      }
+    }
+    else{
+      while (++i !== len){
+        // checks to see if the key was set
+        if (i in this){
+          kValue = t[i];
+          if (func.call(thisArg, t[i], i, t)){
+            res[c++] = kValue;
+          }
+        }
+      }
+    }
+
+    res.length = c; // shrink down array to proper size
+    return res;
+  };
+}
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES5.1', '#sec-15.4.4.20', 'Array.prototype.filter')}}{{Spec2('ES5.1')}}Definición Inicial. Implementado en JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.filter', 'Array.prototype.filter')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-array.prototype.filter', 'Array.prototype.filter')}}{{Spec2('ESDraft')}}
+ +

Compatibilidad con navegadores

+ +
+

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

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/find/index.html b/files/es/web/javascript/reference/global_objects/array/find/index.html new file mode 100644 index 0000000000..7de7850cca --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/find/index.html @@ -0,0 +1,233 @@ +--- +title: Array.prototype.find() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/find +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Prototipo + - Referencia + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/find +--- +
{{JSRef}}
+ +

El método find() devuelve el valor del primer elemento del array que cumple la función de prueba proporcionada.

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

Sintaxis

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

Parámetros

+ +
+
callback
+
Función que se ejecuta sobre cada valor en el array, tomando tres argumentos: +
+
element
+
El elemento actual que se está procesando en el array.
+
index {{optional_inline}}
+
El índice (posición) del elemento actual que se está procesando en el array.
+
array {{optional_inline}}
+
El array desde el que se llama al método find.
+
+
+
thisArg {{optional_inline}}
+
Objeto a usar como this cuando se ejecuta callback.
+
+ +

Valor devuelto

+ +

El valor del primer elemento del array que cumple la función de prueba proporcionada; de lo contrario, devuelve {{jsxref("undefined")}}.

+ +

Descripción

+ +

El método find ejecuta la función callback una vez por cada índice del array hasta que encuentre uno en el que el callback devuelva un valor verdadero. Si es así, find devuelve inmediatamente el valor del elemento. En caso contrario, find devuelve {{jsxref("undefined")}}.

+ +

callback se invoca con tres argumentos: el valor del elemento, el índice del elemento y el objeto Array que está siendo recorrido.

+ +

Si un parámetro thisArg es proporcionado al método find, este será utilizado como this para cada invocación del callback. Si no se proporciona el parámetro, entonces se utiliza {{jsxref("undefined")}}.

+ +

El método find no transforma el array desde el cual es llamado, pero la función proporcionada en callback sí. En ese caso, los elementos procesados por find son establecidos antes de la primera invocación de callback. Por lo tanto:

+ + + +

Ejemplos

+ +

Encontrar un objeto en un array por una de sus propiedades

+ +
const inventario = [
+    {nombre: 'manzanas', cantidad: 2},
+    {nombre: 'bananas', cantidad: 0},
+    {nombre: 'cerezas', cantidad: 5}
+];
+
+function esCereza(fruta) {
+    return fruta.nombre === 'cerezas';
+}
+
+console.log(inventario.find(esCereza));
+// { nombre: 'cerezas', cantidad: 5 }
+ +

Utilizando funciones flecha y destructuring

+ +
const inventario = [
+    {nombre: 'manzanas', cantidad: 2},
+    {nombre: 'bananas', cantidad: 0},
+    {nombre: 'cerezas', cantidad: 5}
+];
+
+const resultado = inventario.find( fruta => fruta.nombre === 'cerezas' );
+
+console.log(resultado); // { nombre: 'cerezas', cantidad: 5 }
+ +

Encontrar un número primo en un array

+ +

El siguiente ejemplo encuentra un elemento en un array que sea un número primo (o devuelve {{jsxref("undefined")}} si no hay un número primo).

+ +
function isPrime(element, index, array) {
+  let 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, no encontrado
+console.log([4, 5, 8, 12].find(isPrime)); // 5
+
+ +

Los siguientes ejemplos muestran cómo elementos no existentes o eliminados son visitados y el valor pasado a callback es su valor cuando son visitados.

+ +
// Declarar un array sin elementos en los índices 2, 3 y 4
+const array = [0,1,,,,5,6];
+
+// Muestra todos los índices, no sólo aquellos que tienen valores asignados
+array.find(function(value, index) {
+  console.log('Visited index ' + index + ' with value ' + value);
+});
+
+// Mostrar todos los índices, incluyendo los eliminados
+array.find(function(value, index) {
+
+  // Eliminar el elemento 5 en la primera iteración
+  if (index == 0) {
+    console.log('Deleting array[5] with value ' + array[5]);
+    delete array[5];
+  }
+  // El elemento 5 se visita aun habiendo sido eliminado
+  console.log('Visited index ' + index + ' with value ' + value);
+});
+// expected output:
+// Deleting array[5] with value 5
+// Visited index 0 with value 0
+// Visited index 1 with value 1
+// Visited index 2 with value undefined
+// Visited index 3 with value undefined
+// Visited index 4 with value undefined
+// Visited index 5 with value undefined
+// Visited index 6 with value 6
+
+ +

Polyfill

+ +

Este método ha sido añadido a la espeficicación ECMAScript 2015 y puede no estar disponible en todas las implementaciones de JavaScript aún. Sin embargo, puedes utilizar el siguiente polyfill de Array.prototype.find:

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

Si necesitas dar soporte a motores de JavaScript realmente obsoletos que no soportan Object.defineProperty, es mejor no utilizar el polyfill para los métodos Array.prototype, ya que no podrás hacerlos no enumerables.

+ +

Especificaciones

+ + + + + + + + + + + + +
Especificación
{{SpecName('ESDraft', '#sec-array.prototype.find', 'Array.prototype.find')}}
+ +

Compatibilidad en navegadores

+ +
+

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

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/findindex/index.html b/files/es/web/javascript/reference/global_objects/array/findindex/index.html new file mode 100644 index 0000000000..c249a3b2df --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/findindex/index.html @@ -0,0 +1,187 @@ +--- +title: Array.prototype.findIndex() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/findIndex +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Protitipo + - Referencia + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex +--- +
{{JSRef}}
+ +

El método findIndex() devuelve el índice del primer elemento de un array que cumpla con la función de prueba proporcionada. En caso contrario devuelve -1.

+ +
{{EmbedInteractiveExample("pages/js/array-findindex.html","shorter")}}
+ +

Vea también el método {{jsxref("Array.find", "find()")}}, que devuelve el valor de un elemento encontrado en el array en lugar de su índice.

+ +

Sintaxis

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

Parámetros

+ +
+
callback
+
+

Función a ejecutar en cada uno de los valores del array hasta que devuelve true, indicando que el elemento que la cumple fue encontrado.

+ +

Recibe tres argumentos:

+ +
+
element
+
El elemento actual siendo procesado en el array.
+
index {{optional_inline}}
+
El índice del elemento actual que está siendo procesado en el array.
+
array {{optional_inline}}
+
El array findIndex() de donde fue llamado.
+
+
+
thisArg {{optional_inline}}
+
Objeto opcional para usar como this cuando se ejecuta el callback.
+
+ +

Valor devuelto

+ +

Un índice en el array si un elemento pasa la prueba; en caso contrario, -1.

+ +

Descripción

+ +

El método findIndex() ejecuta la función de callback una vez por cada índice del array hasta que encuentre uno donde callback devuelva un valor verdadero (eso es, un valor que fuerza un true).

+ +

Si dicho elemento es encontrado, findIndex() inmediatamente devuelve el índice del elemento. Si la función callback nunca devuelve un valor verdadero (o el tamaño del array es 0), findIndex devuelve -1.

+ +
+

Alerta de Edge Case: A diferencia de otros métodos de arrays como {{jsxref("Array.some()")}}, callback se ejecuta incluso en índices sin valores asignados.

+
+ +

callback se invoca con tres argumentos:

+ +
    +
  1. El valor del elemento
    2. +
  2. El índice del elemento
    3. +
  3. El Array que será recorrido.
    4. +
+ +

Si el parámetro thisArg es provisto a findIndex, entonces será usado como el this para cada invocación del callback. Si no es provisto, entonces {{jsxref("undefined")}} será utilizado. 

+ +

El rango de elementos procesados por findIndex() se establece antes de la primera invocación de la función callback. Los elementos añadidos al array después de que la llamada a findIndex() comience no serán visitados por el callback. Si un elemento existente que no ha sido visitado en el array es modificado por el callback, el valor pasado al callback que lo visite será el valor en el momento en que findIndex() visite el índice del elemento.

+ +

Los elementos eliminados aún son visitados.

+ +

Ejemplos

+ +

Encontrar el índice de un número primo en un array

+ +

El siguiente ejemplo encuentra el índice de un elemento en el array que sea número primo (o devuelve -1 si no hay ningún número primo).

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

Encontrar un índice utilizando funciones flecha

+ +

El siguiente ejemplo encuentra el índice de una fruta utilizando funciones flecha.

+ +
const fruits = ["apple", "banana", "cantaloupe", "blueberries", "grapefruit"];
+
+const index = fruits.findIndex(fruit => fruit === "blueberries");
+
+console.log(index); // 3
+console.log(fruits[index]); // blueberries
+
+ +

Polyfill

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

Si necesita soporte para motores de JavaScript obsoletos que no soportan Object.defineProperty es mejor no emplear polyfills para métodos Array.prototype, ya que no puede hacerlos no-enumerables.

+ +

Especificaciones

+ + + + + + + + + + +
Specification
{{SpecName('ESDraft', '#sec-array.prototype.findindex', 'Array.prototype.findIndex')}}
+ +

Compatibilidad en navegadores

+ +
+

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

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/flat/index.html b/files/es/web/javascript/reference/global_objects/array/flat/index.html new file mode 100644 index 0000000000..67d1b3a4c7 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/flat/index.html @@ -0,0 +1,174 @@ +--- +title: Array.prototype.flat() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/flat +tags: + - Array + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/flat +--- +
{{JSRef}} {{SeeCompatTable}}
+ +

El método flat() crea una nueva matriz con todos los elementos de sub-array concatenados recursivamente hasta la profundidad especificada.

+ + + + + +

Sintaxis

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

Parámetros

+ +
+
depth {{optional_inline}}
+
El nivel de profundidad que especifica qué tan profunda debe aplanarse una estructura de matriz anidada. El valor predeterminado es 1.
+
+ +

Valor de retorno

+ +

Una nueva matriz con los elementos de la sub-matriz concatenados en ella.

+ +

Ejemplos

+ +

Aplanar matrices anidadas

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

Aplanamiento y huecos de matriz

+ +

El método de aplanar elimina las ranuras vacías en las matrices:

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

Alternativa

+ +

reduce y concat

+ +
var arr1 = [1, 2, [3, 4]];
+arr1.flat();
+
+//aplanar una matriz de nivel único
+arr1.reduce((acc, val) => acc.concat(val), []);// [1, 2, 3, 4]
+
+//o
+const flatSingle = arr => [].concat(...arr);
+
+ +

 

+ +
//para permitir el aplanamiento a nivel profundo use recursión con reduce y 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), []);
+}
+flattenDeep(arr1); // [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]
+
+ +

 

+ +
//aplanamiento profundo no recursivo usando un stack
+var arr1 = [1,2,3,[1,2,3,4, [2,3,4]]];
+function flatten(input) {
+  const stack = [...input];
+  const res = [];
+  while (stack.length) {
+    // elimina ultimo valor del stack
+    const next = stack.pop();
+    if (Array.isArray(next)) {
+      // agrega de nuevo los items al array, sin modificar la entrada original
+      stack.push(...next);
+    } else {
+      res.push(next);
+    }
+  }
+  //invierte para restaurar el orden de entrada
+  return res.reverse();
+}
+flatten(arr1);// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]
+ +

 

+ +
//Aplanamiento profundo recursivo
+function flatten(array) {
+  var flattend = [];
+  !(function flat(array) {
+    array.forEach(function(el) {
+      if (Array.isArray(el)) flat(el);
+      else flattend.push(el);
+    });
+  })(array);
+  return flattend;
+}
+ +

 

+ +

Polyfill

+ +
if (!Array.prototype.flat) {
+  Array.prototype.flat = function(depth) {
+    var flattend = [];
+    (function flat(array, depth) {
+      for (let el of array) {
+        if (Array.isArray(el) && depth > 0) {
+          flat(el, depth - 1);
+        } else {
+          flattend.push(el);
+        }
+      }
+    })(this, Math.floor(depth) || 1);
+    return flattend;
+  };
+}
+ +

Especificaciones

+ + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
Array.prototype.flat proposalFinalizado (4) 
+ +

Compatibilidad con navegadores

+ +
+ + +

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

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/flatmap/index.html b/files/es/web/javascript/reference/global_objects/array/flatmap/index.html new file mode 100644 index 0000000000..0a93f97675 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/flatmap/index.html @@ -0,0 +1,128 @@ +--- +title: Array.prototype.flatMap() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/flatMap +tags: + - Array + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/flatMap +--- +
{{JSRef}} {{SeeCompatTable}}
+ +

El método flatMap() primero mapea cada elemento usando una función de mapeo, luego aplana el resultado en una nueva matriz. Es idéntico a un map seguido de un flatten de profundidad 1, pero flatMap es a menudo útil y la fusión de ambos en un método es ligeramente más eficiente.

+ + + + + +

Sintaxis

+ +
var new_array = arr.flatMap(function callback(currentValue[, index[, array]]) {
+    // return element for new_array
+}[, thisArg])
+ +

Parámetros

+ +
+
callback
+
Función que produce un elemento de la nueva matriz, tomando tres argumentos: +
+
+
currentValue
+
El elemento actual que se procesa en la matriz.
+
index{{optional_inline}}
+
El índice del elemento actual que se procesa en la matriz.
+
array{{optional_inline}}
+
La matriz map fue llamada.
+
+
+
thisArg{{optional_inline}}
+
Valor para usar como this al ejecutar callback.
+
+ +

Valor de retorno

+ +

Una nueva matriz con cada elemento es el resultado de la función de devolución de llamada y se aplana a una profundidad de 1.

+ +

Descripción

+ +

Ver {{jsxref("Array.prototype.map()")}} para una descripción detallada de la función de devolución de llamada. El método flatMap es idéntico a map seguido de una llamada a flatten de profundidad 1.

+ +

Ejemplos

+ +

map y 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]
+
+// solo un nivel es aplanado
+arr1.flatMap(x => [[x * 2]]);
+// [[2], [4], [6], [8]]
+
+ +
//=> [1, 2, 3, 4, 5, 6, 7, 8, 9]
+ +

Alternativa

+ +

reduce y concat

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

Polyfill

+ +

Este polyfill necesita Array.prototype.flat polyfill

+ +
if (!Array.prototype.flatMap) {
+  Array.prototype.flatMap = function() {
+    return Array.prototype.map.apply(this, arguments).flat(1);
+  };
+}
+ +

Especificaciones

+ + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
Array.prototype.flatMap Finalizado (4)
+ +

Compatibilidad con navegadores

+ +
+ + +

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

+
+ +

Ver también

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

El método forEach() ejecuta la función indicada una vez por cada elemento del array.

+ +

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

+ +

Sintaxis

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

Parámetros

+ +
+
callback
+
Función a ejecutar por cada elemento, que recibe tres argumentos:
+
+
+
currentValue
+
El elemento actual siendo procesado en el array.
+
index {{optional_inline}}
+
El índice del elemento actual siendo procesado en el array.
+
array {{optional_inline}}
+
El vector en el que forEach() esta siendo aplicado.
+
+
+
thisArg {{optional_inline}}
+
Valor que se usará como this cuando se ejecute el callback.
+
+ +

Valor de retorno

+ +

{{jsxref("undefined")}}.

+ +

Descripción

+ +

forEach() ejecuta la función callback una vez por cada elemento presente en el array en orden ascendente. No es invocada para índices que han sido eliminados o que no hayan sido inicializados (Ej. sobre arrays sparse)

+ +

callback es invocada con tres argumentos:

+ +
    +
  1. el valor del elemento
    2. +
  2. el índice del elemento
    3. +
  3. el array que está siendo recorrido
    4. +
+ +

Si un parámetro thisArg es proporcionado a forEach, será usado como el valor this para cada invocación de callback como si se llamara a callback.call(thisArg, element, index, array). Si thisArg es undefined o null, el valor this dentro de la función depende si la función está o no en modo estricto (valor pasado si está en modo estricto, objeto global si está en modo no-estricto).

+ +

El rango de elementos procesados por forEach() se establece antes de la primera invocación del callback. Los elementos que sean añadidos al vector después de que inicie la llamada a forEach no serán visitados por callback. Si los valores de los elementos existentes en el vector son modificados, el valor pasado al callback será el valor al momento de que forEach los visite; no se evaluarán los elementos borrados antes de ser visitados por forEach.

+ +

forEach() ejecuta la función callback una vez por cada elemento del array; a diferencia de {{jsxref("Array.prototype.map()", "map()")}} o {{jsxref("Array.prototype.reduce()", "reduce()")}} este siempre devuelve el valor {{jsxref("undefined")}} y no es encadenable. El típico uso es ejecutar los efectos secundarios al final de la cadena.

+ +

foreach() no muta/modifica el array desde el que es llamado (aunque callback, si se invoca, podría hacerlo).

+ +
Nota : No hay forma de detener o cortar un bucle forEach que no sea lanzar una excepción. Si necesita dicho comportamiento, el método .forEach() es la herramienta equivocada, use una simple iteración en su lugar. Si está probando los elementos del array para un predicado y necesita devolver un valor boleano, puede usar {{jsxref("Array.prototype.every()", "every()")}} o {{jsxref("Array.prototype.some()", "some()")}} en su lugar.
+ +

Ejemplos

+ +

Imprimiendo el contenido de un array

+ +

El siguiente código imprime una línea por cada elemento en un array:

+ +
function logArrayElements(element, index, array) {
+    console.log("a[" + index + "] = " + element);
+}
+// Nótese que se evita el 2° índice ya que no hay ningún elemento en esa posición del array
+[2, 5, , 9].forEach(logArrayElements);
+// salida:
+// a[0] = 2
+// a[1] = 5
+// a[2] = 9
+
+ +

Usando thisArg

+ +

El siguiente ejemplo actualiza las propiedades del objeto por cada entrada en el array:

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

Nota: Dado que el parámetro thisArg (this) se referencia en el forEach(), será pasado al callback cuando se invoque, para utilizarse como su valor this.

+ +

Ejemplo: Función que copia objetos

+ +

El siguiente código crea una copia de un objeto dado. Hay diferentes formas de crear una copia de un objeto, ésta es sólo una de ellas y sirve para explicar cómo funciona Array.prototype.forEach utilizando funciones Object.* de ECMAScript 5.

+ +
function copy(o){
+  var copy = Object.create( Object.getPrototypeOf(o) );
+  var propNames = Object.getOwnPropertyNames(o);
+
+  propNames.forEach(function(name){
+    var desc = Object.getOwnPropertyDescriptor(o, name);
+    Object.defineProperty(copy, name, desc);
+  });
+
+  return copy;
+}
+
+var o1 = {a:1, b:2};
+var o2 = copy(o1); // o2 ahora se parece a o1
+
+ +

Si el array se modifica durante la iteración, otros elementos pueden ser omitidos.

+ +

El siguiente ejemplo muestra por consola "uno", "dos", "cuatro". Cuando se alcanza el registro que contiene el valor "dos", el primer registro del array se desplaza, lo que hace que los registros restantes se muevan una posición. Debido a que el elemento "cuatro" está ahora en una posición anterior en el array, "tres" se omitirá. forEach() no hace una copia del array antes de iterar.

+ +
var words = ['uno', 'dos', 'tres', 'cuatro'];
+words.forEach(function(word) {
+  console.log(word);
+  if (word === 'dos') {
+    words.shift();
+  }
+});
+// uno
+// dos
+// cuatro
+
+ +

Polyfill

+ +

forEach se agregó de manera reciente al estándar ECMA-262; así que puede no estar presente en otras implementaciones del estándar. Se puede asegurar el uso del forEach con tan solo agregar el siguiente código al inicio de los scripts, permitiendo así el uso de forEach en implementaciones que no lo soportan de manera nativa. El algoritmo es el mismo que se especifica en la quinta versión de ECMA-262, asumiendo que {{jsxref("Object")}} y {{jsxref("TypeError")}} tienen sus valores originales y que callback.call evalúa el valor original de {{jsxref("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) {
+    'use strict';
+    var T, k;
+
+    if (this == null) {
+      throw new TypeError("this is null or not defined");
+    }
+
+    var kValue,
+        // 1. Let O be the result of calling ToObject passing the |this| value as the argument.
+        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).
+        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 (arguments.length >= 2) {
+      T = thisArg;
+    }
+
+    // 6. Let k be 0
+    k = 0;
+
+    // 7. Repeat, while k < len
+    while (k < len) {
+
+      // 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. 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
+  };
+}
+
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES5.1', '#sec-15.4.4.18', 'Array.prototype.forEach')}}{{Spec2('ES5.1')}}Definición inicial. Implementada en 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')}}
+ +

Compatibilidad con navegadores

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

Vea también

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

El método Array.from() crea una nueva instancia de Array a partir de un objeto iterable.

+ +

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

+ +

Sintaxis

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

Parámetros

+ +
+
arrayLike
+
Objeto iterable para convertirlo en un array.
+
mapFn{{Optional_inline}}
+
Función de mapa para llamar a cada elemento de la matriz.
+
thisArg{{Optional_inline}}
+
Valor para usar como this al ejecutar mapFn.
+
+ +

Valor de retorno

+ +

Una nueva instancia de {{jsxref("Array")}}.

+ +

Descripción

+ +

Array.from() permite crear Arrays de:

+ + + +

Array.from() tiene un parámetro opcional mapFn, que te permite ejecutar una función {{jsxref("Array.prototype.map", "map")}}  a cada elemento del array (o a la subclase del objeto) que se ha creado. Para aclararlo, Array.from(obj, mapFn, thisArg) es igual que Array.from(obj).map(mapFn, thisArg), excepto en que éste no crea un array intermedio. Esto es importante para ciertas subclases de array, vectores tipados, ya que el vector intermedio necesitaría tener valores truncados para trabajar con el tipo adecuado.

+ +

La propiedad length del método from() es 1.

+ +

En ES2015, la sintaxis de clase permite la subclasificación de clases integradas y definidas por el usuario; como resultado, los métodos estáticos como Array.from son "heredados" por subclases de Array y crean nuevas instancias de la subclase, no Array.

+ +

Ejemplos

+ +

Array desde un String

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

Array desde un Set

+ +
const set = new Set(['foo', 'bar', 'baz', 'foo']);
+Array.from(set);
+// [ "foo", "bar", "baz" ]
+ +

Array desde un Map

+ +
const map = new Map([[1, 2], [2, 4], [4, 8]]);
+Array.from(map);
+// [[1, 2], [2, 4], [4, 8]]
+
+const mapper = new Map([['1', 'a'], ['2', 'b']]);
+Array.from(mapper.values());
+// ['a', 'b'];
+
+Array.from(mapper.keys());
+// ['1', '2'];
+
+ +

Array desde un objeto Array-like (argumentos)

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

Usando una función de flecha y Array.from

+ +
// Usando una función de flecha como función
+// para manipular los elementos
+Array.from([1, 2, 3], x => x + x);
+// [2, 4, 6]
+
+
+// Generar secuencia de números
+// Puesto que el array se inicializa con `undefined` en cada posición,
+// el valor de `v` a continuación será `undefined`
+Array.from({length: 5}, (v, i) => i);
+// [0, 1, 2, 3, 4]
+
+ +

Generador de secuencia (rango)

+ +
// Función generadora de secuencia (comúnmente llamado "rango", ej. Clojure, PHP, etc.)
+const range = (start, stop, step) => Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step));
+
+// Genera un rango de números entre 0..4
+range(0, 4, 1);
+// [0, 1, 2, 3, 4]
+
+// Genera un rango de números entre 1..10 con saltos de 2
+range(1, 10, 2);
+// [1, 3, 5, 7, 9]
+
+// Generar el abecedario utilizando Array.from haciendo uso de que se ordena como secuencia
+range('A'.charCodeAt(0), 'Z'.charCodeAt(0), 1).map(x => String.fromCharCode(x));
+// ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]
+
+ +

Polyfill

+ +

Array.from fue añadido en el estándar ECMA-262 en la 6ta edición (ES2015); así que no puede estar presente en otras implementaciones del estándar. Puedes usarlo insertando este código al comienzo de sus scripts, permitiendo el uso de Array.from en implementaciones que no lo soportan. Este algoritmo es el mismo especificado en ECMA-262, 6ta edición, suponiendo que Object y TypeError tengan sus valores originales y callback.call evalúa el valor original de {{jsxref("Function.prototype.call")}}. Adicionalmente, ya que verdaderos iterables pueden no ser polyficados, esta implementación no soporta iterables genéricos como definidos en la 6ta edición de ECMA-262.

+ +
// Pasos de producción de ECMA-262, Edición 6, 22.1.2.1
+// Referencia: 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);
+    };
+
+    // La propiedad length del método from es 1.
+    return function from(arrayLike/*, mapFn, thisArg */) {
+      // 1. Deje a C ser el este valor.
+      var C = this;
+
+      // 2. Deje que los elementos sean ToObject(arrayLike).
+      var items = Object(arrayLike);
+
+      // 3. Retornar IfAbrupt(items).
+      if (arrayLike == null) {
+        throw new TypeError("Array.from requiere un objeto array-like - not null or undefined");
+      }
+
+      // 4. Si mapfn no está definida, entonces deja que sea false.
+      var mapFn = arguments.length > 1 ? arguments[1] : void undefined;
+      var T;
+      if (typeof mapFn !== 'undefined') {
+        // 5. si no
+        // 5. a If IsCallable(mapfn) es false, lanza una excepción TypeError.
+        if (!isCallable(mapFn)) {
+          throw new TypeError('Array.from: si hay mapFn, el segundo argumento debe ser una función');
+        }
+
+        // 5. b. Si thisArg se suministró, deje que T sea thisArg; si no, deje que T esté indefinido.
+        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;
+    };
+  }());
+}
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES6', '#sec-array.from', 'Array.from')}}{{Spec2('ES6')}}Definición inicial.
{{SpecName('ESDraft', '#sec-array.from', 'Array.from')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ +
+

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

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/includes/index.html b/files/es/web/javascript/reference/global_objects/array/includes/index.html new file mode 100644 index 0000000000..3831c7d73d --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/includes/index.html @@ -0,0 +1,181 @@ +--- +title: Array.prototype.includes() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/includes +tags: + - Array + - JavaScript + - Prototipo + - Referencia + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/includes +--- +
{{JSRef}}
+ +

El método includes() determina si una matriz incluye un determinado elemento, devuelve true o false según corresponda.

+ +

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

+ +

Sintaxis

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

Parámetros

+ +
+
valueToFind
+
+

El valor a buscar.

+ +
+

Nota: Al comparar cadenas de texto y caracteres, includes() distingue mayúsculas y minúsculas.

+
+
+
fromIndex {{optional_inline}}
+
Posición en la matriz en la cuál se debe comenzar a buscar valueToFind; el primer caracter a buscar se encuentra en fromIndex. Un valor negativo inicia la búsqueda desde array.length + fromIndex en adelante. El valor por defecto es 0.
+
+ +

Valor devuelto

+ +

Un {{jsxref ("Boolean")}} que es true si el valor valueToFind se encuentra dentro de la matriz (o la parte de la matriz indicada por el índice fromIndex, si se especifica). Todos los valores de cero se consideran iguales independientemente del signo (es decir, -0 se considera igual a 0 y +0), pero false no se considera igual a 0.

+ +
+

Note: Técnicamente hablando, include() usa el algoritmo sameValueZero para determinar si se encuentra el elemento dado

+
+ +

Ejemplos

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

fromIndex es mayor o igual que la longitud de la matriz

+ +

Si fromIndex es mayor o igual que la longitud de la matriz, se devuelve false. No se buscará en la matriz.

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

El índice calculado es menor que 0

+ +

Si fromIndex es negativo, el índice calculado se calcula para usarse como una posición en la matriz en la cual comenzar a buscar searchElement. Si el índice calculado es menor que 0, se buscará la matriz completa.

+ +
// la longitud de la matriz es 3
+// fromIndex es -100
+// el índice calculado es 3 + (-100) = -97
+
+var arr = ['a', 'b', 'c'];
+
+arr.includes('a', -100); // true
+arr.includes('b', -100); // true
+arr.includes('c', -100); // true
+ +

includes() utilizado como método genérico

+ +

El método includes() es intencionalmente genérico. No requiere que este valor sea un objeto Array, por lo que se puede aplicar a otros tipos de objetos (por ejemplo, objetos tipo array). El siguiente ejemplo ilustra el método includes() llamado en el objeto de argumentos de la función.

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

Polyfill

+ +
// https://tc39.github.io/ecma262/#sec-array.prototype.includes
+if (!Array.prototype.includes) {
+  Object.defineProperty(Array.prototype, 'includes', {
+    value: function(searchElement, fromIndex) {
+
+      if (this == null) {
+        throw new TypeError('"this" es null o no está definido');
+      }
+
+      // 1. Dejar que O sea ? ToObject(this value).
+      var o = Object(this);
+
+      // 2. Dejar que len sea ? ToLength(? Get(O, "length")).
+      var len = o.length >>> 0;
+
+      // 3. Si len es 0, devuelve false.
+      if (len === 0) {
+        return false;
+      }
+
+      // 4. Dejar que n sea ? ToInteger(fromIndex).
+      //    (Si fromIndex no está definido, este paso produce el valor 0.)
+      var n = fromIndex | 0;
+
+      // 5. Si n ≥ 0, entonces
+      //  a. Dejar que k sea n.
+      // 6. Else n < 0,
+      //  a. Dejar que k sea len + n.
+      //  b. Si k < 0, Dejar que k sea 0.
+      var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
+
+      function sameValueZero(x, y) {
+        return x === y || (typeof x === 'number' && typeof y === 'number' && isNaN(x) && isNaN(y));
+      }
+
+      // 7. Repite, mientras k < len
+      while (k < len) {
+        // a. Dejar que elementK sea el resultado de ? Get(O, ! ToString(k)).
+        // b. Si SameValueZero(searchElement, elementK) es true, devuelve true.
+        if (sameValueZero(o[k], searchElement)) {
+          return true;
+        }
+        // c. Incrementa k por 1.
+        k++;
+      }
+
+      // 8. Devuelve false
+      return false;
+    }
+  });
+}
+ +

Si necesita admitir motores de JavaScript realmente obsoletos que no son compatibles con Object.defineProperty, es mejor no rellenar los métodos Array.prototype, ya que no puede hacerlos no enumerables.

+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentarios
{{SpecName('ES7', '#sec-array.prototype.includes', 'Array.prototype.includes')}}{{Spec2('ES7')}}Definición inicial.
{{SpecName('ESDraft', '#sec-array.prototype.includes', 'Array.prototype.includes')}}{{Spec2('ESDraft')}}
+ +

Compatibilidad con navegadores

+ +
+

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

+
+ +
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/index.html b/files/es/web/javascript/reference/global_objects/array/index.html new file mode 100644 index 0000000000..45531c7a3e --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/index.html @@ -0,0 +1,449 @@ +--- +title: Array +slug: Web/JavaScript/Referencia/Objetos_globales/Array +tags: + - Array + - JavaScript + - Matriz unidimensional + - Referencia + - Vector +translation_of: Web/JavaScript/Reference/Global_Objects/Array +--- +

{{JSRef}}
+ El objeto Array de JavaScript es un objeto global que es usado en la construcción de arrays, que son objetos tipo lista de alto nivel.

+ +

Descripción

+ +

Los arrays son objetos similares a una lista cuyo prototipo proporciona métodos para efectuar operaciones de recorrido y de mutación. Tanto la longitud como el tipo de los elementos de un array son variables. Dado que la longitud de un array puede cambiar en cualquier momento, y los datos se pueden almacenar en ubicaciones no contiguas, no hay garantía de que los arrays de JavaScript sean densos; esto depende de cómo el programador elija usarlos. En general estas características son cómodas, pero si, en su caso particular, no resultan deseables, puede considerar el uso de arrays con tipo.

+ +

Operaciones habituales

+ +

Crear un Array

+ +
let frutas = ["Manzana", "Banana"]
+
+console.log(frutas.length)
+// 2
+
+ +

Acceder a un elemento de Array mediante su índice

+ +
let primero = frutas[0]
+// Manzana
+
+let ultimo = frutas[frutas.length - 1]
+// Banana
+ +

Recorrer un Array

+ +
frutas.forEach(function(elemento, indice, array) {
+    console.log(elemento, indice);
+})
+// Manzana 0
+// Banana 1
+ +

Añadir un elemento al final de un Array

+ +
let nuevaLongitud = frutas.push('Naranja') // Añade "Naranja" al final
+// ["Manzana", "Banana", "Naranja"]
+ +

Eliminar el último elemento de un Array

+ +
let ultimo = frutas.pop() // Elimina "Naranja" del final
+// ["Manzana", "Banana"]
+ +

Añadir un elemento al principio de un Array

+ +
let nuevaLongitud = frutas.unshift('Fresa') // Añade "Fresa" al inicio
+// ["Fresa" ,"Manzana", "Banana"]
+
+ +

Eliminar el primer elemento de un Array

+ +
let primero = frutas.shift() // Elimina "Fresa" del inicio
+// ["Manzana", "Banana"]
+
+ +

Encontrar el índice de un elemento del Array

+ +
frutas.push('Fresa')
+// ["Manzana", "Banana", "Fresa"]
+
+let pos = frutas.indexOf('Banana') // (pos) es la posición para abreviar
+// 1
+ +

Eliminar un único elemento mediante su posición

+ +
+
  Ejemplo:
+
Eliminamos "Banana" del array pasándole dos parámetros: la posición del primer elemento que se elimina y el número de elementos que queremos eliminar. De esta forma, .splice(pos, 1) empieza en la posición que nos indica el valor de la variable pos y elimina 1 elemento. En este caso, como pos vale 1, elimina un elemento comenzando en la posición 1 del array, es decir "Banana".
+
+ +
let elementoEliminado = frutas.splice(pos, 1)
+// ["Manzana", "Fresa"]
+ +

Eliminar varios elementos a partir de una posición

+ +
+
  Nota:
+
Con .splice() no solo se puede eliminar elementos del array, si no que también podemos extraerlos guardándolo en un nuevo array. ¡Ojo! que al hacer esto estaríamos modificando el array de origen.
+
+ +
let vegetales = ['Repollo', 'Nabo', 'Rábano', 'Zanahoria']
+console.log(vegetales)
+// ["Repollo", "Nabo", "Rábano", "Zanahoria"]
+
+let pos = 1, numElementos = 2
+
+let elementosEliminados = vegetales.splice(pos, numElementos)
+// ["Nabo", "Rábano"] ==> Lo que se ha guardado en "elementosEliminados"
+
+console.log(vegetales)
+// ["Repollo", "Zanahoria"] ==> Lo que actualmente tiene "vegetales"
+ +

Copiar un Array

+ +
let copiaArray = vegetales.slice();
+// ["Repollo", "Zanahoria"]; ==> Copiado en "copiaArray"
+ +

Acceso a elementos de un array

+ +

Los índices de los arrays de JavaScript comienzan en cero, es decir, el índice del primer elemento de un array es 0, y el del último elemento es igual al valor de la propiedad length del array restándole 1.

+ +

Si se utiliza un número de índice no válido, se obtendrá undefined.

+ +
let arr = ['este es el primer elemento', 'este es el segundo elemento', 'este es el último elemento']
+console.log(arr[0])              // escribe en consola 'este es el primer elemento'
+console.log(arr[1])              // escribe en consola 'este es el segundo elemento'
+console.log(arr[arr.length - 1]) // escribe en consola 'este es el último elemento'
+
+ +

Los elementos de un array pueden considerarse propiedades del objeto tanto como toString (sin embargo, para ser precisos, toString() es un método). Sin embargo, se obtendrá un error de sintaxis si se intenta acceder a un elemento de un array de la forma siguiente, ya que el nombre de la propiedad no sería válido:

+ +
console.log(arr.0) // error de sintaxis
+ +

No hay nada especial ni en los arrays de JavaScript ni en sus propiedades que ocasione esto. En JavaScript, las propiedades cuyo nombre comienza con un dígito no pueden referenciarse con la notación punto y debe accederse a ellas mediante la notación corchete.

+ +

Por ejemplo, dado un objeto con una propiedad de nombre '3d', sólo podría accederse a dicha propiedad con la notación corchete.

+ +
let decadas = [1950, 1960, 1970, 1980, 1990, 2000, 2010]
+console.log(decadas.0)  // error de sintaxis
+console.log(decadas[0]) // funciona correctamente
+
+ +
renderizador.3d.usarTextura(modelo, 'personaje.png')
+renderizador['3d'].usarTextura(modelo, 'personaje.png')
+ +

Obsérvese que, en el último ejemplo, ha sido necesario poner '3d' entre comillas. Es posible usar también comillas con los índices del los arrays de JavaScript (p. ej., decadas['2'] en vez de decadas[2]), aunque no es necesario.

+ +

El motor de JavaScript transforma en un string el 2 de decadas[2] a través de una conversión implícita mediante toString. Por tanto, '2' y '02' harían referencia a dos posiciones diferentes en el objeto decadas, y el siguiente ejemplo podría dar true como resultado:

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

Relación entre length y las propiedades numéricas

+ +

La propiedad length de un array de JavaScript está conectada con algunas otras de sus propiedades numéricas.

+ +

Varios de los métodos propios de un array (p. ej., join(), slice(), indexOf(), etc.) tienen en cuenta el valor de la propiedad length de un array cuando se les llama.

+ +

Otros métodos (p. ej., push(), splice(), etc.) modifican la propiedad length de un array.

+ +
const frutas = []
+frutas.push('banana', 'manzana', 'pera')
+
+console.log(frutas.length) // 3
+
+ +

Cuando se le da a una propiedad de un array JavaScript un valor que corresponda a un índice válido para el array pero que se encuentre fuera de sus límites, el motor actualizará el valor de la propiedad length como corresponda:

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

Si se aumenta el valor de length:

+ +
frutas.length = 10
+console.log(frutas)              // ['banana', 'manzana', 'pera', <2 empty items>, 'fresa', <4 empty items>]
+console.log(Object.keys(frutas)) // ['0', '1', '2', '5']
+console.log(frutas.length)       // 10
+console.log(frutas[8])           // undefined
+
+ +

Si se disminuye el valor de la propiedad length pueden eliminarse elementos:

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

Hay más información sobre este tema en la página sobre Array.length.

+ +

Creación de un array a partir de una expresión regular

+ +

El resultado de una búsqueda con una RegExp en un string puede crear un array de JavaScript. Este array tendrá propiedades y elementos que proporcionan información sobre la correspondencia encontrada. Para obtener un array de esta forma puede utilizarse RegExp.exec(), String.match() o String.replace().

+ +

El siguiente ejemplo, y la tabla que le sigue, pueden ayudar a comprender mejor las propiedades y elementos a los que nos referimos:

+ +
// Buscar una d seguida de una o más b y, al final, de otra d
+// Recordar las b y la d final
+// No distinguir mayúsculas y minúsculas
+
+const miRe = /d(b+)(d)/i
+const miArray = miRe.exec('cdbBdbsbz')
+ +

Las propiedades y elementos que se obtienen de esta búsqueda son los siguientes:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Propiedad/ElementoDescripciónEjemplo
input
+ {{ReadOnlyInline}}		El string original sobre el que se ha realizado la búsqueda con la expresión regular"cdbBdbsbz"
index
+ {{ReadOnlyInline}}		El índice de la correspondencia en el string, siendo cero el de la primera posición.1
[0]
+ {{ReadOnlyInline}}		Los últimos caracteres que cumplen la correspondencia"dbBd"
[1], ...[n]
+ {{ReadOnlyInline}}		Elementos que indican las correspondencias de substrings entre paréntesis (si se han incluido) de la expresión regular. No hay límite al número de substrings entre paréntesis que se puedan utilizar.[1]: "bB"
+ [2]: "d"
+ +

Constructor

+ +
+
Array()
+
Crea un nuevo objeto Array.
+
+ +

Propiedades estáticas

+ +
+
get Array[@@species]
+
La función del constructor se utiliza para crear objetos derivados.
+
+ +

Métodos estáticos

+ +
+
Array.from()
+
Crea una nueva instancia de Array a partir de similarAUnArray, un objeto iterable o parecido a un array.
+
Array.isArray()
+
Devuelve true si valor es un array, y false en caso contrario.
+
Array.of()
+
Crea una nueva instancia de Array con un número variable de parámetros, independientemente del número y del tipo de dichos parámetros.
+
+ +

Propiedades de instancia

+ +
+
Array.prototype.length
+
Indica el número de elementos de un array.
+
Array.prototype[@@unscopables]
+
Símbolo que contiene todos los nombres de las propiedades que se excluyen de un ámbito de enlace with.
+
+ +

Métodos de instancia

+ +
+
Array.prototype.concat()
+
Devuelve un nuevo array que es la concatenación de aquél sobre el que se invoca, seguido de otros array(s) o valor(es).
+
Array.prototype.copyWithin()
+
Copia una secuencia de elementos de un array dentro del propio array.
+
Array.prototype.entries()
+
Devuelve un nuevo objeto Array Iterator que contiene los pares clave/valor para cada índice del array.
+
Array.prototype.every()
+
Devuelve true si todos los elementos del array cumplen el predicado que recibe como parámetro.
+
Array.prototype.fill()
+
Asigna un valor estático a todos los elementos del array entre las posiciones inicio y fin.
+
Array.prototype.filter()
+
Devuelve un nuevo array que contiene todos los elementos de aquél para el cual se llama que cumplan el predicado que se le pasa como parámetro.
+
Array.prototype.find()
+
Devuelve el primer elemento del array que cumpla el predicado que se pasa como parámetro, o undefined si ninguno lo cumple.
+
Array.prototype.findIndex()
+
Devuelve el índice del primer elemento del array que cumpla el predicado que se pasa como parámetro, o -1 si nunguno lo cumple.
+
Array.prototype.forEach()
+
Llama a la función pasada como parámetro para todos los elementos del array.
+
Array.prototype.includes()
+
Determina si el array contiene el valorBuscado y devuelve true o false según sea el caso.
+
Array.prototype.indexOf()
+
Devuelve el índice del primer elemento del array que sea igual a elementoBuscado, o -1 si no existe.
+
Array.prototype.join()
+
Concatena en un string todos los elementos de un array.
+
Array.prototype.keys()
+
Devuelve un nuevo Array Iterator que contiene las claves de cada índice del array.
+
Array.prototype.lastIndexOf()
+
Devuelve el índice del último elemento del array que sea igual a elementoBuscado, o -1 si no existe.
+
Array.prototype.map()
+
Devuelve un nuevo array que contiene el resultado de llamar a la función pasada como parámetro a todos los elementos del array sobre el que se invoca.
+
Array.prototype.pop()
+
Elimina el último elemento de un array, y devuelve dicho elemento.
+
Array.prototype.push()
+
Añade uno o más elementos al final de un array y devuelve el nuevo valor de su propiedad length.
+
Array.prototype.reduce()
+
Aplica la función pasada como parámetro a un acumulador y a cada valor del array, que se recorre de izquierda a derecha, para reducirlo a un único valor.
+
Array.prototype.reduceRight()
+
Aplica la función pasada como parámetro a un acumulador y a cada valor del array, que se recorre de derecha a izquierda, para reducirlo a un único valor.
+
Array.prototype.reverse()
+
Invierte el orden de los elementos de un array (el primero pasa a ser el último y el último a ser el primero) en el propio array. Este método modifica el array.
+
Array.prototype.shift()
+
Elimina el primer elemento de un array, y devuelve dicho elemento.
+
Array.prototype.slice()
+
Extrae una porción del array sobre el que se llama y devuelve un nuevo array.
+
Array.prototype.some()
+
Devuelve true si al menos un elemento del array cumple con el predicado que se pasa como parámetro.
+
Array.prototype.sort()
+
Ordena los elementos de un array, modificando éste, y devuelve el array ordenado.
+
Array.prototype.splice()
+
Añade, borra o modifica elementos de un array.
+
Array.prototype.toLocaleString()
+
Devuelve un string adaptado a la configuración regional que representa el array y sus elementos. Redefine el método Object.prototype.toLocaleString().
+
Array.prototype.toString()
+
Devuelve un string que representa el array y sus elementos. Redefine el método Object.prototype.toString().
+
Array.prototype.unshift()
+
Añada uno o más elementos al inicio de un array y devuelve el nuevo valor de length para el array resultante.
+
Array.prototype.values()
+
Devuelve un nuevo objeto Array Iterator que contiene los valores para cada índice del array.
+
Array.prototype[@@iterator]()
+
Devuelve un nuevo objeto Array Iterator que contiene los valores para cada índice del array.
+
+ +

Ejemplos

+ +

Creación de una matriz unidimensional

+ +

El siguiente ejemplo crea un array mensajes con una longitud de 0, y luego asigna valores a mensajes[0] y a mensajes[99], con lo que la longitud del array pasa a ser 100.

+ +
let mensajes = [];
+mensajes[0] = "Hola";
+mensajes[99] = "mundo";
+
+if (mensajes.length === 100) {
+   console.log("La longitud es de 100.");
+}
+
+ +

Creación de una matriz de dos dimensiones

+ +

El siguiente ejemplo crea una matriz bidimensional que representa un tablero de ajedrez. El primer movimiento se realiza copiando la 'p' de tablero[6][4] en tablero[4][4]. La posición [6][4] se limpia.

+ +
let tablero = [
+  ['T','C','A','D','R','A','C','T'],
+  ['P','P','P','P','P','P','P','P'],
+  [' ',' ',' ',' ',' ',' ',' ',' '],
+  [' ',' ',' ',' ',' ',' ',' ',' '],
+  [' ',' ',' ',' ',' ',' ',' ',' '],
+  [' ',' ',' ',' ',' ',' ',' ',' '],
+  ['p','p','p','p','p','p','p','p'],
+  ['t','c','a','d','r','a','c','t'] ]
+
+console.log(tablero.join('\n') + '\n\n')
+
+// Adelantar dos posiciones el peón de rey
+tablero[4][4] = tablero[6][4]
+tablero[6][4] = ' '
+console.log(tablero.join('\n'))
+ +

Este es el resultado:

+ +
T,C,A,D,R,A,C,T
+P,P,P,P,P,P,P,P
+ , , , , , , ,
+ , , , , , , ,
+ , , , , , , ,
+ , , , , , , ,
+p,p,p,p,p,p,p,p
+t,c,a,d,r,a,c,t
+
+P,P,P,P,P,P,P,P
+ , , , , , , ,
+ , , , , , , ,
+ , , , ,p, , ,
+ , , , , , , ,
+p,p,p,p, ,p,p,p
+t,c,a,d,r,a,c,t
+
+ +

Uso de un array para tabular un conjunto de valores

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

da como resultado:

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

(La primera columna es el índice).

+ +

Especificaciones

+ + + + + + + + + + + + + + +
EspecificaciónPublicación inicial
{{SpecName('ESDraft', '#sec-array-objects', 'Array')}}ECMAScript 1
+ +

Compatibilidad con navegadores

+ + + +

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

+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/indexof/index.html b/files/es/web/javascript/reference/global_objects/array/indexof/index.html new file mode 100644 index 0000000000..7aad7773b1 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/indexof/index.html @@ -0,0 +1,248 @@ +--- +title: Array.prototype.indexOf() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/indexOf +tags: + - Array + - JavaScript + - Method + - Prototype + - Referencia + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/indexOf +--- +
{{JSRef}}
+ +

El método indexOf() retorna el primer índice en el que se puede encontrar un elemento dado en el array, ó retorna -1 si el elemento no esta presente.

+ +
+

Nota: Para el método String, ver {{jsxref("String.prototype.indexOf()")}}.

+
+ +

Sintaxis

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

Parámetros

+ +
+
searchElement
+
Elemento a encontrar en el array.
+
fromIndex {{optional_inline}}
+
Indica el índice por el que se comienza la búsqueda. Por defecto es 0, por lo que se busca en todo el array. Si el índice es mayor o igual a la longitud del array, devuelve -1, ya que no se buscaría en el array. Si el valor es negativo, se toma restando posiciones desde el final del array. Hay que tener en cuenta que aunque el índice sea negativo, la búsqueda seguirá realizándose en un orden incremental. Si el índice calculado es menor de 0, la búsqueda se realizará por todo el array.
+
+ +

Valor de retorno

+ +

El primer índice del elemento en la matriz; -1 si no se encuentra.

+ +

Descripción

+ +

indexOf() compara searchElement con los elementos del array usando igualdad estricta (el mismo método que cuando se usa ===, o el operador igualdad-triple).

+ +

Ejemplos

+ +

Usando indexOf()

+ +

El siguiente ejemplo usa indexof() para localizar valores en un array 

+ +
var array = [2, 9, 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 las apariciones de un elemento

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

Encontrar si un elemento existe en la matriz o no y actualizar la matriz

+ +
function updateVegetablesCollection (veggies, veggie) {
+    if (veggies.indexOf(veggie) === -1) {
+        veggies.push(veggie);
+        console.log('La nueva colección de vegetales es: ' + veggies);
+    } else if (veggies.indexOf(veggie) > -1) {
+        console.log(veggie + ' ya existe en la colección de verduras.');
+    }
+}
+
+var veggies = ['patata', 'tomate', 'chiles', 'pimientoverde'];
+
+updateVegetablesCollection(veggies, 'espinaca');
+// La nueva colección de verduras es : patata, tomate, chiles, pimientoverde, espinaca
+updateVegetablesCollection(veggies, 'espinaca');
+// La espinaca ya existe en la colección de verduras.
+ +

 

+ +

Polyfill

+ +

indexOf() se agregó al estándar ECMA-262 en la 5a edición; por tanto no está implementado en todos los navegadores. Puedes hacerlo funcionar insertando el siguiente código al comienzo de tus scripts, permitiendo usar  indexOf() en implementaciones que no lo soporten de forma nativa. Este algoritmo es exáctamente el especificado en ECMA-262, 5ª edición, suponiendo que {{jsxref("Global_Objects/TypeError", "TypeError")}} y {{jsxref("Math.abs()")}} tienen sus valores originales.

+ + +
if (!Array.prototype.indexOf) {
+  Array.prototype.indexOf = function indexOf(member, startFrom) {
+    /*
+    En el modo no estricto, si la variable `this` es null o indefinida, entonces se establece
+    en el objeto ventana. De lo contrario, `this` se convierte automáticamente en un objeto.
+    En modo estricto, si la variable `this` es nula o indefinida, se lanza `TypeError`.
+    */
+    if (this == null) {
+      throw new TypeError("Array.prototype.indexOf() - no se puede convertir `" + this + "` en objeto");
+    }
+
+    var
+      index = isFinite(startFrom) ? Math.floor(startFrom) : 0,
+      that = this instanceof Object ? this : new Object(this),
+      length = isFinite(that.length) ? Math.floor(that.length) : 0;
+
+    if (index >= length) {
+      return -1;
+    }
+
+    if (index < 0) {
+      index = Math.max(length + index, 0);
+    }
+
+    if (member === undefined) {
+      /*
+        Dado que `member` no está definido, las claves que no existan tendrán el valor de `same`
+        como `member` y, por lo tanto, es necesario verificarlas.
+      */
+      do {
+        if (index in that && that[index] === undefined) {
+          return index;
+        }
+      } while (++index < length);
+    } else {
+      do {
+        if (that[index] === member) {
+          return index;
+        }
+      } while (++index < length);
+    }
+
+    return -1;
+  };
+}
+ +

Sin embargo, si está más interesado en todos los pequeños trozos técnicos definidos por el estándar ECMA, y está menos preocupado por el rendimiento o la concisión, entonces usted puede encontrar esta polyfill más descriptivo que sea más útil.

+ +
// Pasos de producción de ECMA-262, Edición 5, 15.4.4.14
+// Referencia: http://es5.github.io/#x15.4.4.14
+if (!Array.prototype.indexOf) {
+  Array.prototype.indexOf = function(searchElement, fromIndex) {
+
+    var k;
+
+    // 1. Dejar que `o` sea el resultado de llamar a ToObject
+    //    pasando este valor como argumento.
+    if (this == null) {
+      throw new TypeError('"this" is null or not defined');
+    }
+
+    var o = Object(this);
+
+    // 2. Dejar que `lenValue` sea el resultado de llamar al método interno
+    //    de `o` con el argumento "length".
+    // 3. Dejar que len sea ToUint32(lenValue).
+    var len = o.length >>> 0;
+
+    // 4. Si `len` es 0, devolver -1.
+    if (len === 0) {
+      return -1;
+    }
+
+    // 5. Si se pasó el argumento `fromIndex`, deje que `n` sea
+    //    ToInteger(fromIndex); si no, que `n` sea 0.
+    var n = fromIndex | 0;
+
+    // 6. Si n >= len, devolver -1.
+    if (n >= len) {
+      return -1;
+    }
+
+    // 7. Si n >= 0, entonces deja que `k` sea `n`.
+    // 8. Si no, n<0, deja que `k` sea `len - abs(n)`.
+    //    Si `k` es menor que 0, entonces deja que `k` sea 0.
+    k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
+
+    // 9. Repite, mientras k < len
+    while (k < len) {
+      // a. Dejar que `Pk` sea ToString(k).
+      //   Esto está implícito para los operandos LHS del operador in
+      // b. Dejar que kPresent sea el resultado de llamar al método
+      //    interno `HasProperty` de `o` con el argumento `Pk`.
+      //   Este paso se puede combinar con `c`
+      // c. Si kPresent es verdadero, entonces
+      //    i.  Dejar que `elementK` sea el resultado de llamar al método
+      //        interno de `o` con el argumento ToString(k).
+      //   ii.  Deje que `same` sea el resultado de aplicar el
+      //        Algoritmo de comparación de igualdad estricta a
+      //        searchElement y elementK.
+      //  iii.  Si `same` es true, devuelve `k`.
+      if (k in o && o[k] === searchElement) {
+        return k;
+      }
+      k++;
+    }
+    return -1;
+  };
+}
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES5.1', '#sec-15.4.4.14', 'Array.prototype.indexOf')}}{{Spec2('ES5.1')}}Definición inicial. Implementado en JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.indexof', 'Array.prototype.indexOf')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-array.prototype.indexof', 'Array.prototype.indexOf')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ +

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

+ +

Notas de compatibilidad

+ + + +
 
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/isarray/index.html b/files/es/web/javascript/reference/global_objects/array/isarray/index.html new file mode 100644 index 0000000000..b2a115a814 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/isarray/index.html @@ -0,0 +1,128 @@ +--- +title: Array.isArray() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/isArray +tags: + - Array + - ECMAScript5 + - JavaScript + - Referencia + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/isArray +--- +
{{JSRef}}
+ +

El método Array.isArray() determina si el valor pasado es un {{jsxref("Array")}}.

+ +
Array.isArray([1, 2, 3]);  // true
+Array.isArray({foo: 123}); // false
+Array.isArray('foobar');   // false
+Array.isArray(undefined);  // false
+
+ +

Sintaxis

+ +
Array.isArray(obj)
+ +

Parámetros

+ +
+
obj
+
El objeto a evaluar.
+
+ +

Valor de retorno

+ +

true si el objeto es un {{jsxref("Array")}}; en caso contrario, false.

+ +

Descripción

+ +

Si el objeto es un {{jsxref("Array")}}, devuelve true; false, en cualquier otro caso.

+ +

Vea el artículo “Determining with absolute accuracy whether or not a JavaScript object is an array” para más detalles.

+ +

Ejemplos

+ +
// las siguientes llamadas devuelven true
+Array.isArray([]);
+Array.isArray([1]);
+Array.isArray(new Array());
+Array.isArray(new Array('a', 'b', 'c', 'd'));
+Array.isArray(new Array(3));
+// Hecho poco conocido: Array.prototype es también un array:
+Array.isArray(Array.prototype);
+
+// todas las siguientes llamadas devuelven false
+Array.isArray();
+Array.isArray({});
+Array.isArray(null);
+Array.isArray(undefined);
+Array.isArray(17);
+Array.isArray('Array');
+Array.isArray(true);
+Array.isArray(false);
+Array.isArray({ __proto__: Array.prototype });
+
+ +

instanceof vs isArray

+ +

Al comprobar una instancia Array, Array.isArray es más recomendado que instanceof porque funciona a través de iframes.

+ +
var iframe = document.createElement('iframe');
+document.body.appendChild(iframe);
+xArray = window.frames[window.frames.length - 1].Array;
+var arr = new xArray(1,2,3); // [1,2,3]
+
+// Comprobando correctamente un Array
+Array.isArray(arr);  // true
+// Considerado peligroso, porque no funciona a través de iframes
+arr instanceof Array; // false
+
+ +

Polyfill

+ +

Ejecutar el siguiente código antes de cualquier otro código creará un Array.isArray() si no está disponible de forma nativa.

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

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES5.1', '#sec-15.4.3.2', 'Array.isArray')}}{{Spec2('ES5.1')}}Definición inicial. Implementado en JavaScript 1.8.5.
{{SpecName('ES6', '#sec-array.isarray', 'Array.isArray')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-array.isarray', 'Array.isArray')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

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

Vea también

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

El método join() une todos los elementos de una matriz (o un objeto similar a una matriz) en una cadena y devuelve esta cadena.

+ +

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

+ +

Sintaxis

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

Parámetros

+ +
+
separador {{optional_inline}}
+
Es una cadena usada para separar cada uno de los elementos del arreglo. El separador es convertido a una cadena si es necesario. Si este se omite, los elementos del arreglo son separados con una coma (","). Si el separador es una cadena vacía todos los elementos son unidos sin ningún carácter entre ellos.
+
+ +

Valor de retorno

+ +

Una cadena con todos los elementos de la matriz unidos. Si arr.length es 0, se devuelve la cadena vacía.

+ +

Descripción

+ +

Las conversiones de cadena de todos los elementos de la matriz se unen en una cadena.

+ +
+

Si un elemento no está definido o es nulo, se convierte en la cadena vacía.

+
+ +

Ejemplos

+ +

Uniendo un arreglo cuatro veces en diferentes formas

+ +

El siguiente ejemplo crea un arreglo a con tres elementos para luego unir el arreglo cuatro veces: usando el separador predeterminado, luego una coma y un espacio, luego un signo de suma, y finalmente una cadena vacío.

+ +
var a = ['Viento', 'Lluvia', 'Fuego'];
+var miVar1 = a.join();      // asigna 'Viento,Lluvia,Fuego' a miVar1
+var miVar2 = a.join(', ');  // asigna 'Viento, Lluvia, Fuego' a miVar2
+var miVar3 = a.join(' + '); // asigna 'Viento + Lluvia + Fuego' a miVar3
+var miVar4 = a.join('');    // asigna 'VientoLluviaFuego' a miVar4
+
+ +

Unirse a un objeto tipo matriz

+ +

El siguiente ejemplo une un objeto parecido a una matriz (argumentos), llamando a {{jsxref("Function.prototype.call")}} en 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);
+//resultado esperado: "1,a,true"
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
ECMAScript 1st EditionEstándarDefinición inicial. Implementado en 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')}} 
+ +

Compatibilidad con navegadores

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

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/keys/index.html b/files/es/web/javascript/reference/global_objects/array/keys/index.html new file mode 100644 index 0000000000..ff7cb593f5 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/keys/index.html @@ -0,0 +1,84 @@ +--- +title: Array.prototype.keys() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/keys +tags: + - Array + - ECMAScript 2015 + - Iterator + - JavaScript + - Matriz + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/keys +--- +
{{JSRef}}
+ +

El método keys() devuelve un nuevo objeto  Array Iterator que contiene las claves de índice con las que acceder a cada elemento en el array.

+ +

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

+ +

Sintaxis

+ +
arr.keys()
+ +

Valor de retorno

+ +

Un nuevo objeto iterador {{jsxref("Array")}}.

+ +

Ejemplos

+ +

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

El iterador no ignora los huecos

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

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES6', '#sec-array.prototype.keys', 'Array.prototype.keys')}}{{Spec2('ES6')}}Definición inicial.
{{SpecName('ESDraft', '#sec-array.prototype.keys', 'Array.prototype.keys')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

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

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/lastindexof/index.html b/files/es/web/javascript/reference/global_objects/array/lastindexof/index.html new file mode 100644 index 0000000000..19667a54af --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/lastindexof/index.html @@ -0,0 +1,164 @@ +--- +title: Array.prototype.lastIndexOf() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/lastIndexOf +tags: + - Array + - Arreglo + - ECMAScript 5 + - JavaScript + - Matriz + - Prototipo + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf +--- +
{{JSRef}}
+ +

El método lastIndexOf() devuelve el último índice en el que un cierto elemento puede encontrarse en el arreglo, ó -1 si el elemento no se encontrara. El arreglo es recorrido en sentido contrario, empezando por el índice fromIndex.

+ +

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

+ +

Sintaxis

+ +
arr.lastIndexOf(searchElement) arr.lastIndexOf(searchElement, fromIndex)
+ +

Parámetros

+ +
+
searchElement
+
Elemento a encontrar en el arreglo.
+
fromIndex {{optional_inline}}
+
El índice en el que empieza la búsqueda en sentido contrario. Por defecto la longitud del arreglo menos uno (arr.length - 1), es decir, todo el arreglo será recorrido. Si el índice es mayor o igual que la longitud del arreglo, todo el arreglo será recorrido. Si es un valor negatigo, se usará como inicio del desplazamiento el final del arreglo. Darse cuenta que aún cuando el índice es negativo, el arreglo todavía será recorrido desde atrás hacia delante. Si el índice calculado es menor de 0, se devolverá -1, es decir, el arreglo no será recorrido.
+
+ +

Valor de retorno

+ +

El último índice del elemento en el arreglo; -1 si no se encuentra.

+ +

Descripción

+ +

lastIndexOf compara searchElement con los elementos del arreglo usando igualdad estricta (el mismo método es usado para la ===, operador triple igualdad).

+ +

Ejemplos

+ +

Usando lastIndexOf

+ +

El siguiente ejemplo usa lastIndexOf para encontrar valores en un arreglo.

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

Encontrar todas las apariciones de un elemento

+ +

El siguiente ejemplo uses lastIndexOf encuentra todos los índices de un elemento en un arreglo dado, usando {{jsxref("Array.prototype.push", "push")}} añadiéndolos a otro arreglo como elementos 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]
+
+ +

Darse cuenta que en este caso tenemos que tratar idx == 0  de forma separada por que el elemento siempre será encontrado independiemente del valor del parámetro fromIndex  si este es el primer elemento del arreglo. Diferente de como se trata en el método {{jsxref("Array.prototype.indexOf", "indexOf")}}.

+ +

Polyfill

+ +

lastIndexOf fue añadido al estándar ECMA-262 en la 5ª edición; por tanto puede que no este presente en otras implementaciones del estándar. Puedes solucionarlo escribiendo el siguiente código al principio de tus scripts, pudiendo usar lastIndexOf en implementaciones que no tiene soporte de forma nativa. Este algoritmo es exactamente el especificado en ECMA-262, 5ª edición, suponiendo que {{jsxref("Object")}}, {{jsxref("TypeError")}}, {{jsxref("Number")}}, {{jsxref("Math.floor")}}, {{jsxref("Math.abs")}}, y {{jsxref("Math.min")}} tienen sus valores originales.

+ +
// Pasos de producción de ECMA-262, Edición 5, 15.4.4.15
+// Referencia: 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;
+  };
+}
+
+ +

De nuevo, darse cuenta que esta implementación tiene como objeto la completa compatibilidad con lastIndexOf en Firefox y el motor SpiderMonkey JavaScript, en particular en varios casos que son posiblemente extremos. Si pretendes usar esta funcionalidad en aplicaciones reales, es posible que puedes calcular from con código menos complejo si ignoras estos casos.

+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES5.1', '#sec-15.4.4.15', 'Array.prototype.lastIndexOf')}}{{Spec2('ES5.1')}}Definición inicial. Implementado en JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.lastindexof', 'Array.prototype.lastIndexOf')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-array.prototype.lastindexof', 'Array.prototype.lastIndexOf')}}{{Spec2('ESDraft')}}
+ +

Compatibilidad con navegadores

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

Notas de compatibilidad

+ + + +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/length/index.html b/files/es/web/javascript/reference/global_objects/array/length/index.html new file mode 100644 index 0000000000..cbbb1a46db --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/length/index.html @@ -0,0 +1,143 @@ +--- +title: Array.prototype.length +slug: Web/JavaScript/Referencia/Objetos_globales/Array/length +tags: + - Array + - JavaScript + - Propiedad + - Referencia + - Vector +translation_of: Web/JavaScript/Reference/Global_Objects/Array/length +--- +
{{JSRef}}
+ +

La propiedad length de un objeto que es una instancia de tipo Array establece o devuelve la cantidad de elementos en esa matriz. El valor es un entero sin signo de 32 bits que siempre es numéricamente mayor que el índice más alto en la matriz.

+ +
+

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

+
+ +

Descripción

+ +

El valor de la propiedad length es un número entero con un signo positivo y un valor menor que 2 a la 32a potencia (232).

+ +
var namelistA = new Array(4294967296); //2 a la 32a potencia = 4294967296
+var namelistC = new Array(-100) //signo negativo
+
+console.log(namelistA.length); //RangeError: longitud de la matriz inválida
+console.log(namelistC.length); //RangeError: longitud de la matriz inválida
+
+
+
+var namelistB = [];
+namelistB.length = Math.pow(2,32)-1; //establecer una longitud de la matriz menor que 2 a la 32ª potencia
+console.log(namelistB.length);
+
+//4294967295
+ +

Puedes establecer la propiedad length para truncar una matriz unidimensional en cualquier momento. Cuando extiende una matriz cambiando su propiedad length, el número de elementos reales aumenta; por ejemplo, si se establece length en 3 cuando actualmente es 2, la matriz ahora contiene 3 elementos, lo que hace que el tercer elemento sea undefined.

+ +
var arr = [1, 2, 3];
+printEntries(arr);
+
+arr.length = 5; // establecer la longitud de la matriz en 5 mientras que actualmente es 3.
+printEntries(arr);
+
+function printEntries(arr) {
+  var length = arr.length;
+  for (var i = 0; i < length; i++) {
+    console.log(arr[i]);
+  }
+  console.log('=== printed ===');
+}
+
+// 1
+// 2
+// 3
+// === impreso ===
+// 1
+// 2
+// 3
+// undefined
+// undefined
+// === impreso ===
+ +

Pero, la propiedad length no necesariamente indica el número de valores definidos en la matriz. Ver también Relación entre length y las propiedades numéricas.

+ +

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

+ + + +

Ejemplos

+ +

Iterando sobre una matriz

+ +

En el siguiente ejemplo, la matriz numbers se itera a través de la propiedad length. El valor en cada elemento se duplica.

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

Acortando una matriz

+ +

El siguiente ejemplo acorta los numbers de la matriz a una longitud de 3 si la longitud actual es mayor que 3.

+ +
var numbers = [1, 2, 3, 4, 5];
+
+if (numbers.length > 3) {
+  numbers.length = 3;
+}
+
+console.log(numbers); // [1, 2, 3]
+console.log(numbers.length); // 3
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
ECMAScript 1ra Edición.EstándarDefinición inicial.
{{SpecName('ES5.1', '#sec-15.4.5.2', 'Array.length')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-properties-of-array-instances-length', 'Array.length')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-properties-of-array-instances-length', 'Array.length')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

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

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/map/index.html b/files/es/web/javascript/reference/global_objects/array/map/index.html new file mode 100644 index 0000000000..8b958a4945 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/map/index.html @@ -0,0 +1,360 @@ +--- +title: Array.prototype.map() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/map +tags: + - Array + - Arreglo + - Callback + - ECMAScript5 + - Polifill + - Prototype + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/map +--- +
{{JSRef}}
+ +

El método map() crea un nuevo array con los resultados de la llamada a la función indicada aplicados a cada uno de sus elementos.

+ +
var numbers = [1, 5, 10, 15];
+var doubles = numbers.map(function(x) {
+   return x * 2;
+});
+// doubles is now [2, 10, 20, 30]
+// numbers is still [1, 5, 10, 15]
+
+var numbers = [1, 4, 9];
+var roots = numbers.map(function(num) {
+    return Math.sqrt(num);
+});
+// roots is now [1, 2, 3]
+// numbers is still [1, 4, 9]
+
+ +

Sintaxis

+ +
var nuevo_array = arr.map(function callback(currentValue, index, array) {
+    // Elemento devuelto de nuevo_array
+}[, thisArg])
+ +

Parámetros

+ +
+
callback
+
Función que producirá un elemento del nuevo array, recibe tres argumentos:
+
+
+
currentValue
+
El elemento actual del array que se está procesando.
+
index
+
El índice del elemento actual dentro del array.
+
array
+
El array sobre el que se llama map.
+
+
+
thisArg
+
Opcional. Valor a usar como this al ejecutar callback.
+
+ +

Descripción

+ +

map llama a la función callback provista una vez por elemento de un array, en orden, y construye un nuevo array con los resultados. callback se invoca sólo para los índices del array que tienen valores asignados; no se invoca en los índices que han sido borrados o a los que no se ha asignado valor.

+ +

callback es llamada con tres argumentos: el valor del elemento, el índice del elemento, y el objeto array que se está recorriendo.

+ +

Si se indica un parámetro thisArg a un map, se usará como valor de this en la función callback. En otro caso, se pasará {{jsxref("Global_Objects/undefined", "undefined")}} como su valor this. El valor de this observable por el callback se determina de acuerdo a las reglas habituales para determinar el valor this visto por una función.

+ +

map no modifica el array original en el que es llamado (aunque callback, si es llamada, puede modificarlo).

+ +

El rango de elementos procesado por map es establecido antes de la primera invocación del callback. Los elementos que sean agregados al array después de que la llamada a map comience no serán visitados por el callback. Si los elementos existentes del array son modificados o eliminados, su valor pasado al callback será el valor en el momento que el map lo visita; los elementos que son eliminados no son visitados.

+ +

Ejemplos

+ +

Procesar un array de números aplicándoles la raíz cuadrada

+ +

El siguiente código itera sobre un array de números, aplicándoles la raíz cuadrada a cada uno de sus elementos, produciendo un nuevo array a partir del inicial.

+ +
var numeros= [1, 4, 9];
+var raices = numeros.map(Math.sqrt);
+// raices tiene [1, 2, 3]
+// numeros aún mantiene [1, 4, 9]
+
+ +

Usando map para dar un nuevo formato a los objetos de un array

+ +

El siguiente código toma un array de objetos y crea un nuevo array que contiene los nuevos objetos formateados.

+ +
var kvArray = [{clave:1, valor:10},
+               {clave:2, valor:20},
+               {clave:3, valor: 30}];
+
+var reformattedArray = kvArray.map(function(obj){
+   var rObj = {};
+   rObj[obj.clave] = obj.valor;
+   return rObj;
+});
+
+// reformattedArray es ahora [{1:10}, {2:20}, {3:30}],
+
+// kvArray sigue siendo:
+// [{clave:1, valor:10},
+//  {clave:2, valor:20},
+//  {clave:3, valor: 30}]
+
+ +

Mapear un array de números usando una función con un argumento

+ +

El siguiente código muestra cómo trabaja map cuando se utiliza una función que requiere de un argumento. El argumento será asignado automáticamente a cada elemento del arreglo conforme map itera el arreglo original.

+ +
var numeros = [1, 4, 9];
+var dobles  = numeros.map(function(num) {
+  return num * 2;
+});
+
+// dobles es ahora [2, 8, 18]
+// numeros sigue siendo [1, 4, 9]
+
+ +

Usando map de forma genérica

+ +

Este ejemplo muestra como usar map en {{jsxref("Global_Objects/String", "String")}} para obtener un arreglo de bytes en codifcación ASCII representando el valor de los caracteres:

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

Usando map genérico con querySelectorAll

+ +

Este ejemplo muestra como iterar sobre una colección de objetos obtenidos por querySelectorAll. En este caso obtenemos todas las opciones seleccionadas en pantalla y se imprimen en la consola:

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

Usando map para invertir una cadena

+ +
var str = '12345';
+[].map.call(str, function(x) {
+  return x;
+}).reverse().join('');
+
+// Salida: '54321'
+// Bonus: usa'===' para probar si la cadena original era un palindromo
+
+ +

Caso de uso engañoso

+ +

(inspirado por este artículo)

+ +

Es común utilizar el callback con un argumento (el elemento siendo pasado). Ciertas funciones son también usadas comunmente con un argumento, aún cuando toman argumentos adicionales opcionales.  Estos hábitos pueden llevar a comportamientos confusos.

+ +
// Considera:
+['1', '2', '3'].map(parseInt);
+// Mientras uno esperaría [1, 2, 3]
+// en realidad se obtiene [1, NaN, NaN]
+
+// parseInt se usa comúnmente con un argumento, pero toma dos.
+// El primero es una expresión y el segundo el radix.
+// a la función callback, Array.prototype.map pasa 3 argumentos:
+// el elemento, el índice y el array.
+// El tercer argumento es ignorado por parseInt, pero no el segundo,
+// de ahí la posible confusión. Véase el artículo del blog para más detalles
+
+function returnInt(element) {
+  return parseInt(element, 10);
+}
+
+['1', '2', '3'].map(returnInt); // [1, 2, 3]
+// El resultado es un arreglo de números (como se esperaba)
+
+// Un modo más simple de lograr lo de arriba, mientras de evita el "gotcha":
+['1', '2', '3'].map(Number); // [1, 2, 3]
+
+ +

Polyfill

+ +

map fue agregado al estandar ECMA-262 en la 5th edición; por lo tanto podría no estar presente en todas la implementaciones del estándar. Puedes sobrepasar esto insertando el siguiente código al comienzo de tus scripts, permitiendo el uso de map en implementaciones que no lo soportan de forma nativa. Este algoritmo es exactamente el mismo especificado en ECMA-262, 5th edición, asumiendo {{jsxref("Global_Objects/Object", "Object")}}, {{jsxref("Global_Objects/TypeError", "TypeError")}}, y {{jsxref("Global_Objects/Array", "Array")}} tienen sus valores originales y que el callback.call evalua el 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;
+  };
+}
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES5.1', '#sec-15.4.4.19', 'Array.prototype.map')}}{{Spec2('ES5.1')}}Definición inicial. Implementado en JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.map', 'Array.prototype.map')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-array.prototype.map', 'Array.prototype.map')}}{{Spec2('ESDraft')}}
+ +

Compatibilidad con navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeEdgeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoDesktop("1.8")}}{{CompatIE("9")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome para AndroidEdgeFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Soporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile("1.8")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Véase también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/of/index.html b/files/es/web/javascript/reference/global_objects/array/of/index.html new file mode 100644 index 0000000000..f57c7e2bc1 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/of/index.html @@ -0,0 +1,97 @@ +--- +title: Array.of() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/of +tags: + - Array + - ECMAScript 2015 + - JavaScript + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/of +--- +
{{JSRef}}
+ +

El método Array.of() crea una nueva instancia Array con un número variable de elementos pasados como argumento, independientemente del número o del tipo.

+ +

La diferencia entre Array.of() y el constructor Array reside en como maneja los parámetros de tipo entero: Array.of(7) crea un array con un solo elemento, 7, mientras que Array(7) crea un array vacío con una propiedad length de 7 (Nota: esto implica un array de 7 ranuras vacías, no ranuras con valores undefined).

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

Sintaxis

+ +
Array.of(elemento0[, elemento1[, ...[, elementoN]]])
+ +

Parámetros

+ +
+
elementoN
+
Valores con los que se creará el Array en su respectivo indice.
+
+

Valor de retorno

+
+
Una nueva instancia de {{jsxref("Array")}}.
+
+ +

Descripción

+ +

Esta función es parte del estándar ECMAScript 2015. Para obtener más información, consulte Array.of y Array.from proposal y Array.of polyfill.

+ +

Ejemplos

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

Polyfill

+ +

Escribiendo el siguiente código antes que cualquier otro, podemos emular la funcionalidad de Array.of() si es que ésta no está disponible de forma nativa.

+ +
if (!Array.of) {
+  Array.of = function() {
+    return Array.prototype.slice.call(arguments);
+  };
+}
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES2015', '#sec-array.of', 'Array.of')}}{{Spec2('ES2015')}}Definición inicial.
{{SpecName('ESDraft', '#sec-array.of', 'Array.of')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ +
+ + +

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

+
+ +

Ver también

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

El método pop() elimina el último elemento de un array y lo devuelve. Este método cambia la longitud del array.

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

Sintaxis

+ +
arr.pop()
+ +

Valor devuelto

+ +

El elemento que ha sido eliminado del array; {{jsxref("undefined")}} si el array está vacío.

+ +

Descripción

+ +

El método pop elimina el último elemento de un array y devuelve su valor al método que lo llamó.

+ +

pop es intencionadamente genérico; este método puede ser {{jsxref("Function.call", "called", "", 1)}} o {{jsxref("Function.apply", "applied", "", 1)}} en objectos similares a un array. En objetos que no contengan una propiedad length, que refleje su forma en una serie de propiedades numéricas consecutivas en base cero, puede no comportarse de manera significativa.

+ +

Si se llama a pop() en un array vacío, devuelve {{jsxref("undefined")}}.

+ +

Ejemplos

+ +

Eliminando el último elemento de un array

+ +

El siguiente código crea el array myFish, que contiene cuatro elementos, a continuación, elimina su último elemento.

+ +
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
+
+var popped = myFish.pop();
+
+console.log(myFish); // ['angel', 'clown', 'mandarin' ]
+
+console.log(popped); // 'sturgeon'
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES3')}}EstándarDefinición inicial. Implementada en JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.4.4.6', 'Array.prototype.pop')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-array.prototype.pop', 'Array.prototype.pop')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-array.prototype.pop', 'Array.prototype.pop')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ +
+

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

+
+ +

Vea también

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

El método push() añade uno o más elementos al final de un array y devuelve la nueva longitud del array.

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

Sintaxis

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

Parámetros

+ +
+
elementN
+
Los elementos a añadir al final del array.
+
+ +

Valor devuelto

+ +

La nueva propiedad {{jsxref("Array.length", "length")}} del objeto sobre el cual se efectuó la llamada.

+ +

Descripción

+ +

El método push es muy práctico para añadir valores a un array.

+ +

push es genérico intencionadamente. Este método puede ser {{jsxref("Function.call", "call()")}} o {{jsxref("Function.apply", "apply()")}} a objetos que representen arrays. El método push depende de la propiedad length para decidir donde empezar a insertar los valores dados. Si el valor de la propiedad length no puede ser convertido en numérico, el índice 0 es usado. Esto permite la posibilidad de que la propiedad length sea inexistente, y en este caso length será creado.

+ +

Los únicos objetos nativos que se asemejen al array son {{jsxref("Global_Objects/String", "strings", "", 1)}} objetos, aunque estos no se puedan usar en la aplicación de este método ya que son inmutables.

+ +

Ejemplos

+ +

Ejemplo: Añadiendo elementos a un array

+ +

El siguiente código crea el array sports que contiene dos elementos, luego añade 2 elementos más. Tras ejecutar el código, sports contiene 4 elementos: "soccer", "baseball", "football" and "swimming".

+ +
var sports = ['soccer', 'baseball'];
+var total = sports.push('football', 'swimming');
+
+console.log(sports); // ['soccer', 'baseball', 'football', 'swimming']
+console.log(total);  // 4
+
+ +

Uniendo dos arrays

+ +

This example uses {{jsxref("Function.apply", "apply()")}} to push all elements from a second array.

+ +

Do not use this method if the second array (moreVegs in the example) is very large, because the maximum number of parameters that one function can take is limited in practice. See {{jsxref("Function.apply", "apply()")}} for more details.

+ +
var vegetables = ['parsnip', 'potato'];
+var moreVegs = ['celery', 'beetroot'];
+
+// Merge the second array into the first one
+// Equivalent to vegetables.push('celery', 'beetroot');
+Array.prototype.push.apply(vegetables, moreVegs);
+
+console.log(vegetables); // ['parsnip', 'potato', 'celery', 'beetroot']
+
+ +

Using an object in an array-like fashion

+ +

Como se menciona anteriormente, push es intencionadamente genérico, y podemos usar eso a nuestro favor. Array.prototype.push puede funcionar bien con un objeto, como muestra este ejemplo. Ten en cuenta que no se crea un array para almacenar una colección de objetos. En su lugar, almacenamos la colección en el propio objeto y se utiliza el método call sobre Array.prototype.push para hacer creer al método que estamos tratando a un array, y simplemente funciona, gracias a la forma en que JavaScript nos permite establecer el contexto de la ejecución.

+ +
var obj = {
+    length: 0,
+
+    addElem: function addElem(elem) {
+        // obj.length is automatically incremented
+        // every time an element is added.
+        [].push.call(this, elem);
+    }
+};
+
+// Let's add some empty objects just to illustrate.
+obj.addElem({});
+obj.addElem({});
+console.log(obj.length);
+// → 2
+
+ +

Tenga en cuenta que aunque obj no es un array, el método push ha incrementado satisfactoriamente la propiedad length de obj tal y como si se tratara de un array.

+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES3')}}{{Spec2('ES3')}}Definición inicial. Implementado en 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')}} 
{{SpecName('ESDraft', '#sec-array.prototype.push', 'Array.prototype.push')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad en navegadores

+ +
+ + +

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

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/reduce/index.html b/files/es/web/javascript/reference/global_objects/array/reduce/index.html new file mode 100644 index 0000000000..68d7a9cb2f --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/reduce/index.html @@ -0,0 +1,215 @@ +--- +title: Array.prototype.reduce() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/reduce +tags: + - Array + - ECMAScript 5 + - JavaScript + - Prototype + - Reduce + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce +--- +
{{JSRef}}
+ +

El método reduce() ejecuta una función reductora sobre cada elemento de un array, devolviendo como resultado un único valor.

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

La función reductora recibe cuatro argumentos:

+ +
    +
  1. Acumulador (acc)
    2. +
  2. Valor Actual (cur)
    3. +
  3. Índice Actual (idx)
    4. +
  4. Array (src)
    5. +
+ +

El valor devuelto de la función reductora se asigna al acumulador, cuyo valor se recuerda en cada iteración de la matriz y, en última instancia, se convierte en el valor final, único y resultante.

+ +

Sintaxis

+ +
arr.reduce(callback(acumulador, valorActual[, índice[, array]])[, valorInicial])
+ +

Parámetros

+ +
+
callback
+
Función a ejecutar sobre cada elemento del array (excepto para el primero, si no se proporciona valorInicial), que recibe cuatro parámetros: +
+
acumulador
+
El acumulador acumula el valor devuelto por la función callback. Es el valor acumulado devuelto en la última invocación de callback, o el valorInicial, si se proveyó. (Ver a continuación).
+
valorActual
+
El elemento actual que está siendo procesado en el array.
+
índice {{optional_inline}}
+
El índice del elemento actual que está siendo procesado en el array. Empieza desde el índice 0 si se provee valorInicial. En caso contrario, comienza desde el índice 1.
+
array {{optional_inline}}
+
El array sobre el cual se llamó el método reduce().
+
+
+
valorInicial {{optional_inline}}
+
Un valor a usar como primer argumento en la primera llamada de la función callback. Si no se proporciona el valorInicial, el primer elemento del array será utilizado y saltado. Llamando a reduce() sobre un array vacío sin un valorInicial lanzará un {{jsxref("TypeError")}}.
+
+ +

Descripción

+ +

El método reduce() ejecuta callback una vez por cada elemento presente en el array, excluyendo los huecos del mismo, recibe cuatro argumentos:

+ + + +

La primera vez que se llama la función, valorAnterior y valorActual pueden tener uno de dos valores. Si se proveyó un valorInicial al llamar a reduce, entonces valorAnterior será igual al valorInicial y valorActual será igual al primer elemento del array. Si no se proveyó un valorInicial, entonces valorAnterior será igual al primer valor en el array y valorActual será el segundo.

+ +

Si el array está vacío y no se proveyó un valorInicial lanzará un {{jsxref("Global_Objects/TypeError", "TypeError")}}. Si el array tiene un sólo elemento (sin importar la posición) y no se proveyó un valorInicial, o si se proveyó un valorInicial pero el arreglo está vacío, se retornará ese único valor sin llamar a la función.

+ +

Suponga que ocurre el siguiente uso de reduce:

+ +
[0,1,2,3,4].reduce(function(valorAnterior, valorActual, indice, vector){
+  return valorAnterior + valorActual;
+});
+
+// Primera llamada
+valorAnterior = 0, valorActual = 1, indice = 1
+
+// Segunda llamada
+valorAnterior = 1, valorActual = 2, indice = 2
+
+// Tercera llamada
+valorAnterior = 3, valorActual = 3, indice = 3
+
+// Cuarta llamada
+valorAnterior = 6, valorActual = 4, indice = 4
+
+// el array sobre el que se llama a reduce siempre es el objeto [0,1,2,3,4]
+
+// Valor Devuelto: 10
+
+ +

Y si proporcionas un valorInicial, el resultado sería como este:

+ +
[0,1,2,3,4].reduce(function(valorAnterior, valorActual, indice, vector){
+  return valorAnterior + valorActual;
+}, 10);
+
+// Primera llamada
+valorAnterior = 10, valorActual = 0, indice = 0
+
+// Segunda llamada
+valorAnterior = 10, valorActual = 1, indice = 1
+
+// Tercera llamada
+valorAnterior = 11, valorActual = 2, indice = 2
+
+// Cuarta llamada
+valorAnterior = 13, valorActual = 3, indice = 3
+
+// Quinta llamada
+valorAnterior = 16, valorActual = 4, indice = 4
+
+// el array sobre el que se llama a reduce siempre es el objeto [0,1,2,3,4]
+
+// Valor Devuelto: 20
+
+ +

Polyfill

+ +
+

Polyfill se refiere a unas líneas de código o un plugin que permite "tener"  (en realidad se simulan de alguna otra manera) las nuevas funcionalidades   de HTML5 en aquellos navegadores que nativamente no lo soportan. Consigue que, en adelante, el código sea transparente para el programador, como si el navegador soportase la funcionalidad nativamente.

+
+ +

reduce es una extensión de JavaScript al estándar ECMA-262; como tal puede que no esté presente en otras implementaciones del estándar. Puedes trabajar con ésto insertando el siguiente código al comienzo de tus scripts, permitiendo el uso de reduce en implementaciones de ECMA-262 que no lo implementan de modo nativo. Este algoritmo es exactamente el mismo usando en Firefox y SpiderMonkey.

+ +
if (!Array.prototype.reduce)
+{
+  Array.prototype.reduce = function(fun /*, inicial*/)
+  {
+    var longitud = this.length;
+    if (typeof fun != "function")
+      throw new TypeError();
+
+    // no se devuelve ningún valor si no hay valor inicial y el array está vacío
+    if (longitud == 0 && arguments.length == 1)
+      throw new TypeError();
+
+    var indice = 0;
+    if (arguments.length >= 2)
+    {
+      var rv = arguments[1];
+    }
+    else
+    {
+      do
+      {
+        if (indice in this)
+        {
+          rv = this[indice++];
+          break;
+        }
+
+        // si el array no contiene valores, no existe valor inicial a devolver
+        if (++indice >= longitud)
+          throw new TypeError();
+      }
+      while (true);
+    }
+
+    for (; indice < longitud; indice++)
+    {
+      if (indice in this)
+        rv = fun.call(null, rv, this[indice], indice, this);
+    }
+
+    return rv;
+  };
+}
+
+ +

Ejemplos

+ +

Ejemplo: Sumar todos los valores de un array

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

Ejemplo: Integrar un array a partir de varios arrays

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

Especificaciones

+ + + + + + + + + + + + +
Especificación
{{SpecName('ESDraft', '#sec-array.prototype.reduce', 'Array.prototype.reduce()')}}
+ +

Compatibilidad con navegadores

+ +
+ + +

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

+
+ +

Ver también

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

Resumen

+ +

Aplica una función simultáneamente contra un acumulador y cada elemento de un array (de derecha a izquierda) para reducirlo a un único valor.

+ +

Sintaxis

+ +
array.reduceRight(
+funcion[,
+valorInicial])
+
+ +

Parámetros

+ +
+
callback
+
Función a ejecutar para cada valor del array.
+
initialValue
+
Objeto a usar como primer argumento en la primera llamada de la funcion.
+
+ +

Descripción

+ +

reduceRight ejecuta la funcion una vez para cada elemento presente en el array, excluyendo los huecos del mismo, recibiendo cuatro argumentos: el valor inicial (o valor de la llamada previa de funcion), el valor del elemento actual, el índice actual y el array sobre el que ocurre la iteración.

+ +

La llamada a la funcion de reduceRight sería similar a esto:

+ +
.reduceRight(function(valorPrevio, valorActual, indice, array){
+  // ...
+})
+
+ +

La primera vez que se llama a la función, el valorPrevio y el valorActual puede ser uno de los dos valores. Si se incluye un valorInicial en la llamada a reduceRight, entonces el valorPrevio será igual al valorInicial y el valorActual será igual al último valor del array. Si no se incluye ningún valorInicial, entonces el valorPrevio será igual al último valor del array y el valorActual será igual al penúltimo valor.

+ +

Algún ejemplo de la ejecución de la función paso a paso sería similar a esto:

+ +
[0,1,2,3,4].reduceRight(function(valorPrevio, valorActual, indice, array){
+  return valorPrevio + valorActual;
+});
+
+// First call
+valorPrevio = 4, valorActual = 3, indice = 3
+
+// Second call
+valorPrevio = 7, valorActual = 2, indice = 2
+
+// Third call
+valorPrevio = 9, valorActual = 1, indice = 1
+
+// Fourth call
+valorPrevio = 10, valorActual = 0, indice = 0
+
+// el array sobre el que se llama a reduceRight siempre es el objeto [0,1,2,3,4]
+
+// Valor Devuelto: 10
+
+ +

Y si proporcionas un valorInicial, el resultado sería como este:

+ +
[0,1,2,3,4].reduceRight(function(valorPrevio, valorActual, indice, array){
+  return valorPrevio + currentValue;
+}, 10);
+
+// Primera llamada
+valorPrevio = 10, valorActual = 4, indice = 4
+
+// Segunda llamada
+valorPrevio = 14, valorActual = 3, indice = 3
+
+// Tercera llamada
+valorPrevio = 17, valorActual = 2, indice = 2
+
+// Cuarta llamada
+valorPrevio = 19, valorActual = 1, indice = 1
+
+// Quinta llamada
+valorPrevio = 20, valorActual = 0, indice = 0
+
+// el array sobre el que se llama a reduce siempre es el objeto [0,1,2,3,4]
+
+// Valor Devuelto: 20
+
+ +

Compatibilidad

+ +

reduceRight es una extensión de JavaScript al estándar ECMA-262; como tal puede que no esté presente en otras implementaciones del estándar. Puedes trabajar con ésto insertando el siguiente código al comienzo de tus scripts, permitiendo el uso de reduceRight en implementaciones de ECMA-262 que no lo implementan de modo nativo. Este algoritmo es exactamente el mismo usando en Firefox y SpiderMonkey.

+ +
if (!Array.prototype.reduceRight)
+{
+  Array.prototype.reduceRight = function(fun /*, inicial*/)
+  {
+    var longitud = this.length;
+    if (typeof fun != "function")
+      throw new TypeError();
+
+    // no se devuelve ningún valor si no hay valor inicial y el array está vacío
+    if (longitud == 0 && arguments.length == 1)
+      throw new TypeError();
+
+    var indice = longitud - 1;
+    if (arguments.length >= 2)
+    {
+      var rv = arguments[1];
+    }
+    else
+    {
+      do
+      {
+        if (indice in this)
+        {
+          rv = this[indice--];
+          break;
+        }
+
+        // si el array no contiene valores, no existe valor incial a devolver
+        if (--indice < 0)
+          throw new TypeError();
+      }
+      while (true);
+    }
+
+    for (; indice >= 0; indice--)
+    {
+      if (indice in this)
+        rv = fun.call(null, rv, this[indice], indice, this);
+    }
+
+    return rv;
+  };
+}
+
+ +

Ejemplos

+ +

Ejemplos: Resumir todos los valores de un array

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

Ejemplo: Integrar un array a partir de varios arrays

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

Véase también

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

El método reverse() invierte el orden de los elementos de un array in place. El primer elemento pasa a ser el último y el último pasa a ser el primero.

+ +

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

+ +

Sintaxis

+ +
a.reverse()
+ +

Valor devuelto

+ +

El array invertido.

+ +

Descripción

+ +

El método reverse cruza los elementos del objeto matriz invocados en su lugar, mutando la matriz, y retornando una referencia a la misma.

+ +

Ejemplos

+ +

Colocar al revés los elementos de un array

+ +

El siguiente ejemplo crea un array a que contiene tres elementos y luego lo invierte.
+ La llamada a reverse() devuelve una referencia al array a invertido.

+ +
const a = [1, 2, 3];
+
+console.log(a); // [1, 2, 3]
+
+a.reverse();
+
+console.log(a); // [3, 2, 1]
+
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES1')}}{{Spec2('ES1')}}Definición inicial. Implementado en JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.4.4.8', 'Array.prototype.reverse')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-array.prototype.reverse', 'Array.prototype.reverse')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-array.prototype.reverse', 'Array.prototype.reverse')}}{{Spec2('ESDraft')}} 
+ + + +

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

+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/shift/index.html b/files/es/web/javascript/reference/global_objects/array/shift/index.html new file mode 100644 index 0000000000..7391f6c325 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/shift/index.html @@ -0,0 +1,124 @@ +--- +title: Array.prototype.shift() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/shift +translation_of: Web/JavaScript/Reference/Global_Objects/Array/shift +--- +
{{JSRef}}
+ +

El método shift() elimina el primer elemento del array y lo retorna. Este método modifica la longitud del array.

+ +

Sintaxis

+ +
arr.shift()
+ +

Descripción

+ +

El método shift elimina el elemento en el índice cero y desplaza los valores consecutivos hacia abajo, devolviendo el valor eliminado. Si la propiedad {{jsxref("Array.length", "length")}} es 0, devuelve {{jsxref("undefined")}}.

+ +

shift es genérico; este método puede utilizarse con {{jsxref("Function.call", "call", "", 1)}} o {{jsxref("Function.apply", "apply", "", 1)}} a objetos simliares a arrays. Los objetos que no tengan una propiedad length que refleje el último elemento de una serie consecutiva de propiedades numéricas con índice base cero pueden no comportarse de manera significativa.

+ +

Ejemplos

+ +

Eliminando un elemento de un array

+ +

El siguiente código muestra el contenido del array miPescado antes y después de eliminar el primer elemento. También muestra el elemento eliminado:

+ +
var miPescado = ['ángel', 'payaso', 'mandarín', 'cirujano'];
+
+console.log('miPescado antes: ' + miPescado);
+// "miPescado antes: ángel,payaso,mandarín,cirujano"
+
+var eliminado = miPescado.shift();
+
+console.log('miPescado después: ' + miPescado);
+// "miPescado after: payaso,mandarín,cirujano"
+
+console.log('Elemento eliminado: ' + eliminado);
+// "Elemento eliminado: ángel"
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES3')}}{{Spec2('ES3')}}Definición inicial. Implementado en Javascript 1.2.
{{SpecName('ES5.1', '#sec-15.4.4.9', 'Array.prototype.shift')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-array.prototype.shift', 'Array.prototype.shift')}}{{Spec2('ES6')}}
+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte básico{{CompatChrome("1.0")}}{{CompatGeckoDesktop("1.7")}}{{CompatIE("5.5")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Soporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Ver también

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

El método slice() devuelve una copia de una parte del array dentro de un nuevo array empezando por inicio hasta fin (fin no incluido). El array original no se modificará.

+ +

El código fuente de esta demostración interactiva está alojado en un repositorio Github. Si desea contribuir con ella, por favor clone https://github.com/mdn/interactive-examples y envíenos un "pull request".

+ +

Sintaxis 

+ +
arr.slice([inicio [, fin]])
+ +

Parámetros

+ +
+
inicio
+
Índice donde empieza la extracción. El primer elemento corresponde con el índice  0.
+
Si el índice especificado es negativo, indica un desplazamiento desde el final del array. slice(-2)extrae los dos últimos elementos del array
+
Si inicio es omitido el valor por defecto es 0.
+
Si inicio es mayor a la longitud del array, se devuelve un array vacío.
+
fin
+
Índice  que marca el final de la extracción. slice extrae hasta, pero sin incluir el final.
+
slice(1,4) extrae desde el segundo elemento hasta el cuarto  (los elementos con índices 1, 2,  y 3).
+
Con un índice negativo, fin indica un desplazamiento desde el final de la secuencia. slice(2,-1) extrae desde el tercer hasta el penúltimo elemento en la secuencia.
+
Si fin es omitido, slice extrae hasta el final de la secuencia (arr.length).
+
Si fin es mayor a la longitud del array, slice extrae hasta el final de la secuencia (arr.length).
+
+ +

Valor de retorno

+ +

Un nuevo array con los valores extraídos.

+ +

Descripción

+ +

slice no modifica el array original. Devuelve una copia plana (shallow copy) de los elementos especificados del array original. Los elementos del array original son copiados en el array devuelto de la siguiente manera:

+ + + +

Si un nuevo elemento es agregado a cualquiera de los arrays, el otro array no es afectado.

+ +

Ejemplos

+ +

Ejemplo: Devolver una porción de un array existente

+ +
var nombres = ['Rita', 'Pedro', 'Miguel', 'Ana', 'Vanesa'];
+var masculinos = nombres.slice(1, 3);
+
+// masculinos contiene ['Pedro','Miguel']
+
+ +

Ejemplo: Utilizando slice

+ +

Presta especial atención a:

+ + + +

En el siguiente ejemplo, slice crea un nuevo array, nuevoCoche, de myCoche. Los dos incluyen una referncia al objecto miHonda se cambia a púrpura, ambas matrices reflejan el cambio.

+ +
var miHonda = { color: 'red', ruedas: 4, motor: { cilindros: 4, cantidad: 2.2 } };
+var miCoche = [miHonda, 2, 'Buen estado', 'comprado 1997'];
+var nuevoCoche = miCoche.slice(0, 2);
+
+//  Muestra los valores de myCar, newCar y el color de myHonda.
+console.log('miCoche = ' + JSON.stringify(miCoche));
+console.log('nuevoCoche = ' + JSON.stringify(nuevoCoche));
+console.log('miCoche[0].color = ' + miCoche[0].color);
+console.log('nuevoCoche[0].color = ' + nuevoCoche[0].color);
+
+// Cambia el color de miHonda.
+miHonda.color = 'azul';
+console.log('El nuevo color de mi Honda es ' + miHonda.color);
+
+// Muestra el color de myHonda referenciado desde ambos arrays. 
+console.log('miCoche[0].color = ' + miCoche[0].color);
+
+console.log('nuevoCoche[0].color = ' + nuevoCoche[0].color);
+ +

Este script escribe:

+ +
miCoche = [{color: 'rojo', ruedas: 4, motor: {cilindros: 4, cantidad: 2.2}}, 2,
+         'buen estado', 'comprado 1997']
+nuevoCoche = [{color: 'rojo', ruedas: 4, motor: {cilindros: 4, cantidad: 2.2}}, 2]
+miCoche[0].color = rojo
+nuevoCoche[0].color = rojo
+El nuevo color de miHonda es azul
+miCoche[0].color = azul
+nuevoCoche[0].color = azul
+ +

Objetos array-like

+ +
+

Se dice que un objeto es array-like ( similar o que se asemeja a un array) cuando entre sus propiedades existen algunas cuyos nombres son números y en particular tiene una propiedad llamada length. Este hecho  hace  suponer que el objeto es algún tipo de colección de elementos indexados por números. Es conveniente, a veces, convertir estos objetos a arrays para otorgarles la funcionalidad que de serie se incorpora en todos los arrays a través de su prototipo. 

+
+ +

El método slice puede ser usado para convertir objetos parecidos a arrays o colecciones a un nuevo Array. Simplemente debe enlazar el método al objeto. El  {{jsxref("Functions_and_function_scope/arguments", "arguments")}} dentro de una función es un ejemplo de un objeto parecido a arrays.

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

El enlazado puede realizarse con la función .call de  {{jsxref("Function.prototype")}} y puede ser abreviado también usando  [].slice.call(arguments) en lugar de Array.prototype.slice.call. En cualquier caso, puede ser simplificado usando {{jsxref("Function.prototype.bind", "bind")}}.

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

Coordinación del comportamiento entre navegadores

+ +

 

+ +

La especificación permite a los objetos del host  ( entre ellos los objetos del DOM )  ser dependientes de la implementación.  Esta NO obligatoriedad, origina diferencias en el comportamiento entre aquellos comprometidos con los estándares, como Mozilla, y los que no. En lo que concierne a  Array.prototype.slice , por lo tanto, existen importantes incompatibilidades en IE < 9 . Versiones de IE a partir de la 9 permiten un comportamiento compatible más fiable.  Se puede recurrir al  “shimming”  para alcanzar la compatibilidad en otros casos.  Mientras otros navegadores modernos continúan mejorando para soportar esta habilidad, en la forma en que actualmente lo hacen Mozilla, Chrome, Safari, Opera  e IE, los desarrolladores de código preocupados por el soporte DOM que confíen en este shim no deben dejarse engañar por la semántica, deben confiar de forma segura en ella para proporcionar el comportamiento estándar que aparentemente ahora es la norma.

+ +

El shim también soluciona que IE pueda tratar con el caso de que el segundo argumento de slice() pueda ser un valor {{jsxref("Global_Objects/null", "null")}}/{{jsxref("Global_Objects/undefined", "undefined")}} explícito. Esto era un problema en versiones anteriores de IE, pero todos los navegadores modernos, incluído IE >= 9, lo hacen actualmente.

+ +
/**
+ * Shim para "solucionar" la falta de soporte de IE (IE < 9) para aplicar slice
+ * sobre objetos del host, tal como NamedNodeMap, NodeList, y HTMLCollection
+ * (técnicamente, al ser los objetos del host dependientes de la implementación,
+ * al menos anteriormente a ES2015, IE no tenía la necesidad de trabajar de este modo).
+ * También funciona sobre strings, solucionando que IE < 9 admita un undefined explícito
+ * como segundo argumento (igual que en Firefox), y previniendo errores cuando se llama
+ * sobre otros objetos del DOM.
+ */
+(function () {
+  'use strict';
+  var _slice = Array.prototype.slice;
+
+  try {
+    // Fallará al usarse con elementos DOM en IE < 9
+    _slice.call(document.documentElement);
+  } catch (e) { // Fails in IE < 9
+    // Funcionará con arrays genuinos, objetos array-like,
+    // NamedNodeMap (attributes, entities, notations),
+    // NodeList (e.g., getElementsByTagName), HTMLCollection (e.g., childNodes),
+    // and will not fail on other DOM objects (as do DOM elements in IE < 9)
+    Array.prototype.slice = function(begin, end) {
+      // A IE < 9 no le gustan los undefined como argumento end.
+      end = (typeof end !== 'undefined') ? end : this.length;
+
+      // Con objetos Array nativos, podemos usar la función slice
+      if (Object.prototype.toString.call(this) === '[object Array]'){
+        return _slice.call(this, begin, end);
+      }
+
+      // Con objetos array-like debemos manejarlo por nuestra cuenta.
+      var i, cloned = [],
+        size, len = this.length;
+
+      // Maneja valores negativos para el argumento "inicio"
+      var start = begin || 0;
+      start = (start >= 0) ? start : Math.max(0, len + start);
+
+      // Maneja valores negativos para el argumento "fin"
+      var upTo = (typeof end == 'number') ? Math.min(end, len) : len;
+      if (end < 0) {
+        upTo = len + end;
+      }
+
+      // Tamaño esperado para el 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;
+    };
+  }
+}());
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoObservaciones
ECMAScript 3ª ediciónEstandarDefinición inicial Implementado en JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.4.4.10', 'Array.prototype.slice')}}{{Spec2('ES5.1')}} 
{{SpecName('ES2015', '#sec-array.prototype.slice', 'Array.prototype.slice')}}{{Spec2('ES2015')}} 
+ +

Compatibilidad con navegadores

+ +

La tabla de compatibilidad en esta página esta generada desde datos estructurados. Si desea contribuir con los datos, por favor "checkout" https://github.com/mdn/browser-compat-data  y envíenos un "pull request".

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

Ver también 

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

El método some() comprueba si al menos un elemento del array cumple con la condición implementada por la función proporcionada.

+ +
+

Nota: Este método devuelve false para cualquier condición puesta en un array vacío.

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

Sintaxis

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

Parámetros

+ +
+
callback
+
Función que verifica cada elemento, toma tres argumentos: +
+
element
+
El elemento actual siendo procesado en el array.
+
index {{Optional_inline}}
+
El índice del elemento del array que se está procesando.
+
array {{Optional_inline}}
+
El array sobre el que ha sido llamada la función some().
+
+
+
thisArg {{Optional_inline}}
+
Valor a usar como this cuando se ejecute callback.
+
+ +

Valor devuelto

+ +

true si la función callback devuelve un valor {{Glossary("truthy")}} para cualquier elemento del array; en caso contrario, false.

+ +

Descripción

+ +

some() ejecuta la función callback una vez por cada elemento presente en el array hasta que encuentre uno donde callback retorna un valor verdadero (true). Si se encuentra dicho elemento, some() retorna true inmediatamente. Si no, some() retorna false. callback es invocada sólo para los índices del array que tienen valores asignados; no es invocada para índices que han sido borrados o a los que nunca se les han asignado valores.

+ +

callback es invocada con tres argumentos: el valor del elemento, el índice del elemento, y el objeto array sobre el que se itera.

+ +

Si se indica un parámetro thisArg a some(), se pasará a callback cuando es invocada, para usar como valor this. Si no, el valor {{jsxref("undefined")}} será pasado para usar como valor this. El valor this value observable por callback se determina de acuerdo a las reglas habituales para determinar el this visible por una función.

+ +

some() no modifica el array con el cual fue llamada.

+ +

El rango de elementos procesados por some() es configurado antes de la primera invocación de callback. Los elementos anexados al array luego de que comience la llamada a some() no serán visitados por callback. Si un elemento existente y no visitado del array es alterado por callback, su valor pasado al callback será el valor al momento que some() visita el índice del elemento; los elementos borrados no son visitados.

+ +

Ejemplos

+ +

Verificando el valor de los elementos de un array

+ +

El siguiente ejemplo verifica si algún elemento del array es mayor a 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
+
+ +

Verificando los elementos de un array usando funciones flecha

+ +

Las funciones flecha (Arrow functions) brindan una sintáxis más corta para el mismo test.

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

Comprobando si un elemento existe en un array

+ +

Para imitar la función del método includes(), esta función personalizada devuelve true si el elemento existe en el array:

+ +
var fruits = ['apple', 'banana', 'mango', 'guava'];
+
+function checkAvailability(arr, val) {
+  return arr.some(function(arrVal) {
+    return val === arrVal;
+  });
+}
+
+checkAvailability(fruits, 'kela');   // false
+checkAvailability(fruits, 'banana'); // true
+ +

Comprobando si un elemento existe en un array con funciones flecha

+ +
var fruits = ['apple', 'banana', 'mango', 'guava'];
+
+function checkAvailability(arr, val) {
+  return arr.some(arrVal => val === arrVal);
+}
+
+checkAvailability(fruits, 'kela');   // false
+checkAvailability(fruits, 'banana'); // true
+ +

Convirtiendo cualquier valor a Boolean

+ +
var TRUTHY_VALUES = [true, 'true', 1];
+
+function getBoolean(value) {
+  'use strict';
+
+  if (typeof value === 'string') {
+    value = value.toLowerCase().trim();
+  }
+
+  return TRUTHY_VALUES.some(function(t) {
+    return t === value;
+  });
+}
+
+getBoolean(false);   // false
+getBoolean('false'); // false
+getBoolean(1);       // true
+getBoolean('true');  // true
+ +

Polyfill

+ +

some() fue agregado al estándar ECMA-262 en la 5ta edición; por ello, puede no estar presente en todas las implementaciones del estándar. Puedes trabajar sobre esto insertando el siguiente código al comienzo de tus scripts, permitiendo el uso de some() en implementaciones que no tienen soporte nativo. Este algoritmo es exactamente el mismo especificado en ECMA-262, 5ta edición, asumiendo que {{jsxref("Global_Objects/Object", "Object")}} y {{jsxref("Global_Objects/TypeError", "TypeError")}} tienen sus valores originales y que fun.call evalúa el valor original de{{jsxref("Function.prototype.call()")}}.

+ +
// Pasos de producción de ECMA-262, Edición 5, 15.4.4.17
+// Referencia: 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;
+  };
+}
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES5.1', '#sec-15.4.4.17', 'Array.prototype.some')}}{{Spec2('ES5.1')}}Definición inicial. Implementado en JavaScript 1.6.
{{SpecName('ES6', '#sec-array.prototype.some', 'Array.prototype.some')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-array.prototype.some', 'Array.prototype.some')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad en navegadores

+ +
+ + +

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

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/sort/index.html b/files/es/web/javascript/reference/global_objects/array/sort/index.html new file mode 100644 index 0000000000..ac28826327 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/sort/index.html @@ -0,0 +1,301 @@ +--- +title: Array.prototype.sort() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/sort +tags: + - Array + - JavaScript + - Método(2) + - Prototipo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort +--- +
{{JSRef}}
+ +

El método sort() ordena los elementos de un arreglo (array) localmente y devuelve el arreglo ordenado. La ordenación no es necesariamente estable. El modo de ordenación por defecto responde a la posición del valor del string de acuerdo a su valor Unicode.

+ +

La fuente de este ejemplo interactivo se almacena en un repositorio de GitHub. Si desea contribuir al proyecto de ejemplos interactivos, clone https://github.com/mdn/interactive-examples y envíenos una solicitud de extracción (pull request).

+ +

Sintaxis

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

Parámetros

+ +
+
compareFunction
+
Opcional. Especifica una función que define el modo de ordenamiento. Si se omite, el array es ordenado atendiendo a la posición del valor Unicode de cada caracter, según la conversión a string de cada elemento.
+
firstEl
+
El primer elemento a comparar.
+
secondEl
+
El segundo elemento a comparar.
+
+ +

Valor devuelto

+ +

El array ordenado.

+ +

Descripción

+ +

Si no se provee compareFunction, los elementos son ordenados convirtiéndolos a strings y comparando la posición del valor Unicode de dichos strings. Por ejemplo, "Cherry" viene antes que "banana"  (porque las mayúsculas van antes que las minúsculas en la codificación Unicode) . En un ordenamiento numérico, 9 está antes que 80, pero dado que los números son convertidos a strings y ordenados según el valor Unicode, el resultado será "80" antes que "9".

+ +
var frutas = ['guindas', 'manzanas', 'bananas'];
+frutas.sort(); // ['bananas', 'guindas', 'manzanas']
+
+var puntos = [1, 10, 2, 21];
+puntos.sort(); // [1, 10, 2, 21]
+// Tenga en cuenta que 10 viene antes que 2
+// porque '10' viene antes que '2' según la posición del valor Unicode.
+
+var cosas = ['word', 'Word', '1 Word', '2 Words'];
+cosas.sort(); // ['1 Word', '2 Words', 'Word', 'word']
+// En Unicode, los números vienen antes que las letras mayúsculas
+// y estas vienen antes que las letras minúsculas.
+
+ +

Si se provee compareFunction, los elementos del array son ordenados de acuerdo al valor que retorna dicha función de comparación. Siendo a y b dos elementos comparados, entonces:

+ + + +

Entonces, la función de comparación tiene la siguiente forma:

+ +
function compare(a, b) {
+  if (a es menor que b según criterio de ordenamiento) {
+    return -1;
+  }
+  if (a es mayor que b según criterio de ordenamiento) {
+    return 1;
+  }
+  // a debe ser igual b
+  return 0;
+}
+
+ +

Para comparar números en lugar de strings, la función de comparación puede simplemente restar b de a. La siguiente función ordena el array de modo ascendente:

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

El metodo sort puede ser usado convenientemente con {{jsxref("Operators/function", "function expressions", "", 1)}} (y closures):

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

Los objectos pueden ser ordenados por el valor de una de sus propiedades.

+ +
var items = [
+  { name: 'Edward', value: 21 },
+  { name: 'Sharpe', value: 37 },
+  { name: 'And', value: 45 },
+  { name: 'The', value: -12 },
+  { name: 'Magnetic', value: 13 },
+  { 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;
+});
+
+ +

Ejemplos

+ +

Ordenando un array

+ +

Un array de elementos string, sin especificar una función de comparación:

+ +
var arr = [ 'a', 'b', 'Z', 'Aa', 'AA' ];
+arr.sort();  //[ 'AA', 'Aa', 'Z', 'a', 'b' ]
+
+ +

Un array de elementos numéricos,  sin función de comparación:

+ +
var arr = [ 40, 1, 5, 200 ];
+arr.sort();  //[ 1, 200, 40, 5 ]
+
+ +

Un array de elementos numéricos, usando una función de comparación:

+ +
var arr = [ 40, 1, 5, 200 ];
+function comparar ( a, b ){ return a - b; }
+arr.sort( comparar );  // [ 1, 5, 40, 200 ]
+ +

Lo mismo pero usando una función anónima normal:

+ +
var arr = [ 40, 1, 5, 200 ];
+arr.sort(function(a,b){return a - b;});  // [ 1, 5, 40, 200 ]
+ +

Lo mismo escrito más compacto mediante una función flecha:

+ +
var arr = [ 40, 1, 5, 200 ];
+arr.sort((a,b)=>a-b);  // [ 1, 5, 40, 200 ]
+ +

+ +

Creando, mostrando, y ordenando un array

+ +

El siguiente ejemplo abunda en la idea de ordenar con y sin función de comparación. Además, ilustra una manera de mostrar un array una vez creado. El método join es usado para convertir el array en una cadena de texto que imprimir. Al no pasarle un argumento que indique el separador, usará la coma por defecto para separar los elementos del array dentro de la cadena.

+ +
var arr = ['80', '9', '700', 40, 1, 5, 200];
+function comparar(a, b) {
+  return a - b;
+}
+console.log('original:', arr.join());
+console.log('ordenado sin función:', arr.sort());
+console.log('ordenado con función:', arr.sort(comparar));
+
+ +

El ejemplo produce el siguiente resultado. Como muestra la salida, cuando una función de comparación es usada, los números se ordenan correctamente, sean estos valores numéricos o strings numéricos.

+ +
original: 80,9,700,40,1,5,200
+ordenado sin función: 1,200,40,5,700,80,9
+ordenado con función: 1,5,9,40,80,200,700
+
+ +

Ordenando caracteres no ASCII

+ +

Para ordenar strings con characters no ASCII, i.e. strings con caracteres con acento (e, é, è, a, ä, etc.), strings de lenguajes diferentes al inglés: use {{jsxref("String.localeCompare")}}. Esta función puede comparar esos caracteres para que aparezcan en el orden correcto.

+ +
var items = ['réservé', 'premier', 'cliché', 'communiqué', 'café', 'adieu'];
+items.sort(function (a, b) {
+  return a.localeCompare(b);
+});
+
+// items is ['adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé']
+
+ +

Ordenando con map

+ +

La compareFunction puede ser invocada múltiples veces por elemento dentro del array. Dependiendo de la naturaleza de compareFunction, este puede resultar en una alta penalización de rendimiento. Cuanto más trabajo hace una compareFunction y más elementos hay para ordenar, resulta más recomendable usar una función map para ordenar. La idea es recorrer el array una sola vez para extraer los valores usados para ordenar en un array temporal, ordenar el array temporal y luego recorrer el array para lograr el orden correcto.

+ +
// el array a ordenar
+var list = ['Delta', 'alpha', 'CHARLIE', 'bravo'];
+
+// array temporal contiene objetos con posición y valor de ordenamiento
+var mapped = list.map(function(el, i) {
+  return { index: i, value: el.toLowerCase() };
+})
+
+// ordenando el array mapeado que contiene los valores reducidos
+mapped.sort(function(a, b) {
+  if (a.value > b.value) {
+    return 1;
+  }
+  if (a.value < b.value) {
+    return -1;
+  }
+  return 0;
+});
+
+// contenedor para el orden resultante
+var result = mapped.map(function(el){
+  return list[el.index];
+});
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
ECMAScript 1st EditionStandardDefinicióñ 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')}}
+ +

Compatibilidad en navegadores

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

Compatibilidad en navegadores

+ +

La tabla de compatibilidad en esta página es generada por una data estructurada. Si deseas contribuir a la data, por favor entra a https://github.com/mdn/browser-compat-data y envíanos un pull request.

+ +

Ver también

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

El método splice() cambia el contenido de un array eliminando elementos existentes y/o agregando nuevos elementos.

+ +

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

+ +

Sintaxis

+ +
array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
+
+ +

Parámetros

+ +
+
start
+
Índice donde se comenzará a cambiar el array (con 0 como origen). Si es mayor que la longitud del array, el punto inicial será la longitud del array. Si es negativo, empezará esa cantidad de elementos contando desde el final.
+
deleteCount {{optional_inline}}
+
Un entero indicando el número de elementos a eliminar del array antiguo.
+
Si deleteCount se omite, o si su valor es mayor que arr.length - start (esto significa, si es mayor que el número de elementos restantes del array, comenzando desde start), entonces todos los elementos desde start hasta el final del array serán eliminados.
+
Si deleteCount es igual a 0 o negativo, no se eliminará ningún elemento. En este caso, se debe especificar al menos un nuevo elemento (ver más abajo).
+
item1, item2, ...  {{optional_inline}}
+
Los elementos que se agregarán al array, empezando en el índice start. Si no se especifica ningún elemento, splice() solamente eliminará elementos del array.
+
+ +

Valor devuelto

+ +

Un array que contiene los elementos eliminados. Si sólo se ha eliminado un elemento, devuelve un array con un solo elemento. Si no se ha eliminado ningún elemento, devuelve un array vacío.

+ +

Descripción

+ +

Si especifica un número diferente de elementos a agregar que los que se eliminarán, el array tendrá un tamaño diferente al original una vez finalizada la llamada.

+ +

Ejemplos

+ +

Eliminar 0 elementos desde el índice 2 e insertar "drum"

+ +
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
+var removed = myFish.splice(2, 0, 'drum');
+
+// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"]
+// removed is [], no elements removed
+
+ +

Eliminar 1 elemento desde el índice 3

+ +
var myFish = ['angel', 'clown', 'drum', 'mandarin', 'sturgeon'];
+var removed = myFish.splice(3, 1);
+
+// removed is ["mandarin"]
+// myFish is ["angel", "clown", "drum", "sturgeon"]
+
+ +

Eliminar 1 elemento desde el índice 2 e insertar "trumpet"

+ +
var myFish = ['angel', 'clown', 'drum', 'sturgeon'];
+var removed = myFish.splice(2, 1, 'trumpet');
+
+// myFish is ["angel", "clown", "trumpet", "sturgeon"]
+// removed is ["drum"]
+ +

Eliminar 2 elementos desde el índice 0 e insertar "parrot", "anemone" y "blue"

+ +
var myFish = ['angel', 'clown', 'trumpet', 'sturgeon'];
+var removed = myFish.splice(0, 2, 'parrot', 'anemone', 'blue');
+
+// myFish is ["parrot", "anemone", "blue", "trumpet", "sturgeon"]
+// removed is ["angel", "clown"]
+ +

Eliminar 2 elementos desde el índice 2

+ +
var myFish = ['parrot', 'anemone', 'blue', 'trumpet', 'sturgeon'];
+var removed = myFish.splice(myFish.length - 3, 2);
+
+// myFish is ["parrot", "anemone", "sturgeon"]
+// removed is ["blue", "trumpet"]
+ +

Eliminar 1 elemento desde el índice -2

+ +
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
+var removed = myFish.splice(-2, 1);
+
+// myFish is ["angel", "clown", "sturgeon"]
+// removed is ["mandarin"]
+ +

Eliminar todos los elementos tras el índice 2 (incl.)

+ +
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
+var removed = myFish.splice(2);
+
+// myFish is ["angel", "clown"]
+// removed is ["mandarin", "sturgeon"]
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES3')}}{{Spec2('ES3')}}Initial definition. Implemented in 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')}} 
{{SpecName('ESDraft', '#sec-array.prototype.splice', 'Array.prototype.splice')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ +
+

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

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/tolocalestring/index.html b/files/es/web/javascript/reference/global_objects/array/tolocalestring/index.html new file mode 100644 index 0000000000..0fc418ab47 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/tolocalestring/index.html @@ -0,0 +1,177 @@ +--- +title: Array.prototype.toLocaleString() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/toLocaleString +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString +--- +
{{JSRef}}
+ +

El método toLocaleString() devuelve una cadena de texto representando los elementos del array. Los elementos son convertidos a texto usando su método toLocaleString  y dichos Strings son separados por un caracter específico para la localidad (como una coma para la separación de decimales “,”).

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

Sintaxis

+ +
arr.toLocaleString([locales[, options]]);
+
+ +

Parámetros

+ +
+
locales {{optional_inline}}
+
Una cadena de texto con una etiqueta de idioma BCP 47, o un array de dichos strings. Para la forma general e interpretación the los argumentos locales, ver la página {{jsxref("Intl")}}.
+
options {{optional_inline}}
+
Un objeto con las configuraciones, para números ver {{jsxref("Number.prototype.toLocaleString()")}}, y para fechas ver {{jsxref("Date.prototype.toLocaleString()")}}.
+
+ +

Valor de retorno

+ +

Una cadena de texto representando los elementos del array.

+ +

Ejemplos

+ +

Usando locales y options

+ +

Los elementos del array son convertidos a strings usando sus métodos toLocaleString.

+ + + +

Siempre mostrar la moneda para los strings y números en el array precios:

+ +
var precios = ['$7', 500, 8123, 12];
+precios.toLocaleString('es-AR', { style: 'currency', currency: 'ARS' });
+
+// "$7, $500, $8.123, $12"
+
+ +

Para más ejemplos, ver también {{jsxref("Intl")}}, {{jsxref("NumberFormat")}}, y {{jsxref("DateTimeFormat")}}.

+ +

Polyfill

+ +
// https://tc39.github.io/ecma402/#sup-array.prototype.tolocalestring
+if (!Array.prototype.toLocaleString) {
+  Object.defineProperty(Array.prototype, 'toLocaleString', {
+    value: function(locales, options) {
+      // 1. Let O be ? ToObject(this value).
+      if (this == null) {
+        throw new TypeError('"this" is null or not defined');
+      }
+
+      var a = Object(this);
+
+      // 2. Let len be ? ToLength(? Get(A, "length")).
+      var len = a.length >>> 0;
+
+      // 3. Let separator be the String value for the
+      //    list-separator String appropriate for the
+      //    host environment's current locale (this is
+      //    derived in an implementation-defined way).
+      // NOTE: In this case, we will use a comma
+      var separator = ',';
+
+      // 4. If len is zero, return the empty String.
+      if (len === 0) {
+        return '';
+      }
+
+      // 5. Let firstElement be ? Get(A, "0").
+      var firstElement = a[0];
+      // 6. If firstElement is undefined or null, then
+      //  a.Let R be the empty String.
+      // 7. Else,
+      //  a. Let R be ?
+      //     ToString(?
+      //       Invoke(
+      //        firstElement,
+      //        "toLocaleString",
+      //        « locales, options »
+      //       )
+      //     )
+      var r = firstElement == null ?
+        '' : firstElement.toLocaleString(locales, options);
+
+      // 8. Let k be 1.
+      var k = 1;
+
+      // 9. Repeat, while k < len
+      while (k < len) {
+        // a. Let S be a String value produced by
+        //   concatenating R and separator.
+        var s = r + separator;
+
+        // b. Let nextElement be ? Get(A, ToString(k)).
+        var nextElement = a[k];
+
+        // c. If nextElement is undefined or null, then
+        //   i. Let R be the empty String.
+        // d. Else,
+        //   i. Let R be ?
+        //     ToString(?
+        //       Invoke(
+        //        nextElement,
+        //        "toLocaleString",
+        //        « locales, options »
+        //       )
+        //     )
+        r = nextElement == null ?
+          '' : nextElement.toLocaleString(locales, options);
+
+        // e. Let R be a String value produced by
+        //   concatenating S and R.
+        r = s + r;
+
+        // f. Increase k by 1.
+        k++;
+      }
+
+      // 10. Return R.
+      return r;
+    }
+  });
+}
+
+ +

Si necesitas soportar motores de JavaScript obsoletos que no compatibilizan con Object.defineProperty, es mejor no utilizar los métodos Array.prototype, ya que no se pueden hacer no-enumerables.

+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ESDraft', '#sec-array.prototype.tolocalestring', 'Array.prototype.toLocaleString')}}{{Spec2('ESDraft')}}La definicion original fue en ECMAScript 3.
{{SpecName('ES Int Draft', '#sup-array.prototype.tolocalestring', 'Array.prototype.toLocaleString')}}{{Spec2('ES Int Draft')}}Esta definición reemplaza la proporcionada en ECMA-262.
+ +

Compatibilidad con navegadores

+ +
+ + +

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

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/tosource/index.html b/files/es/web/javascript/reference/global_objects/array/tosource/index.html new file mode 100644 index 0000000000..ffd8df0b3b --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/tosource/index.html @@ -0,0 +1,112 @@ +--- +title: Array.prototype.toSource() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/toSource +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toSource +--- +
{{JSRef}} {{non-standard_header}}
+ +

El método toSource() devuelve un string representando el código fuente de un arreglo.

+ +

Sintaxis

+ +
arr.toSource()
+ +

Valor devuelto

+ +

Un string representando el código fuente del arreglo.

+ +

Descripción

+ +

El método toSourcer retorna los siguientes valores:

+ + + +

Este método suele ser llamado internamente por JavaScript y no explícitamente en código. Puede usar toSource mientras depura para examinar el contenido de un arreglo.

+ +

Ejemplos

+ +

Examinar el código fuente de un arreglo

+ +

Para examinar el código fuente de un arreglo:

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

Especificaciones

+ +

No hace parte de ningún estándar. Implementado en JavaScript 1.3.

+ +

Compatibilidad con navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeEdgeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte básico{{CompatNo}}{{CompatNo}}{{CompatVersionUnknown}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome for AndroidEdgeFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Soporte básicot{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatVersionUnknown}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/tostring/index.html b/files/es/web/javascript/reference/global_objects/array/tostring/index.html new file mode 100644 index 0000000000..402f011e0f --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/tostring/index.html @@ -0,0 +1,78 @@ +--- +title: Array.prototype.toString() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/toString +tags: + - Array + - JavaScript + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toString +--- +
{{JSRef}}
+ +

El método toString() devuelve una cadena de caracteres representando el array especificado y sus elementos.

+ +

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

+ +

Sintaxis 

+ +
arr.toString()
+ +

Valor devuelto

+ +

Una cadena de caracteres representando los elementos del array.

+ +

Descripción

+ +

El objeto {{jsxref("Array")}} sustituye al método toString de {{jsxref("Object")}}. Para los objetos Array, el método toString une el array y devuelve una cadena de caracteres que contiene cada elemento del array separado por comas.

+ +

JavaScript llama al método toString automáticamente cuando un array va a ser representado como un valor de texto o cuando se referencia a un array en una concatenación de caracteres.

+ +

Semántica de ECMAScript 5 

+ +

Desde JavaScript 1.8.5 (Firefox 4), y consistente con la 5ª edición de semántica de ECMAScript, el método toString() es genérico y puede ser usado con cualquier objeto. {{jsxref("Object.prototype.toString()")}} será llamado y devolverá el valor resultante.

+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES1')}}{{Spec2('ES1')}}Definición inicial. Implementado en 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')}} 
{{SpecName('ESDraft', '#sec-array.prototype.tostring', 'Array.prototype.toString')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ +
+

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

+
> + +

Vea también

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

El método unshift() agrega uno o más elementos al inicio del array, y devuelve la nueva longitud del array.

+ +

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

+ +

Sintaxis

+ +
arr.unshift(elemento1[, ...[, elementoN]])
+ +

Parámetros

+ +
+
elementoN
+
Elementos a agregar al inicio del array.
+
+ +

Devuelve

+ +

La nueva propiedad {{jsxref("Array.length", "length")}} del objeto sobre el cual el método fue llamado.

+ +

Descripción

+ +

El método unshift inserta los valores proporcionados al inicio de un objeto del tipo array.

+ +

unshift es intencionalmente genérico; este método puede ser {{jsxref("Function.call", "called", "", 1)}} o {{jsxref("Function.apply", "applied", "", 1)}} a objetos similares a arrays. Objetos que no contengan una propiedad length reflejando una serie de propiedades numéricas consecutivas, comenzada a partir del cero, pueden no comportarse de una manera comprensible.

+ +

Ejemplos

+ +
var arr = [1, 2];
+
+arr.unshift(0); // resultado de la llamada es 3, la nueva longitud del array
+// arr es [0, 1, 2]
+
+arr.unshift(-2, -1); // = 5
+// arr es [-2, -1, 0, 1, 2]
+
+arr.unshift([-3]);
+// arr es [[-3], -2, -1, 0, 1, 2]
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónStatusComentario
{{SpecName('ES3')}}{{Spec2('ES3')}}Initial definition. Implemented in 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')}} 
{{SpecName('ESDraft', '#sec-array.prototype.unshift', 'Array.prototype.unshift')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad en navegadores

+ +
+ + +

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

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/array/values/index.html b/files/es/web/javascript/reference/global_objects/array/values/index.html new file mode 100644 index 0000000000..dbc76e8634 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/values/index.html @@ -0,0 +1,82 @@ +--- +title: Array.prototype.values() +slug: Web/JavaScript/Referencia/Objetos_globales/Array/values +tags: + - Array + - ECMAScript 2015 + - Iterador + - JavaScript + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/values +--- +
{{JSRef}}
+ +

El método values() devuelve un nuevo objeto Array Iterator que contiene los valores para cada índice del array.

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

Sintaxis

+ +
arr.values()
+
+ +

Valor devuelto

+ +

Un nuevo objeto {{jsxref("Array")}} iterator.

+ +

Ejemplos

+ +

Iteración usando un bucle for...of

+ +
var arr = ['w', 'y', 'k', 'o', 'p'];
+var iterador = arr.values();
+
+for (let letra of iterador) {
+  console.log(letra);
+}
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES2015', '#sec-array.prototype.values', 'Array.prototype.values')}}{{Spec2('ES2015')}}Definición inicial.
{{SpecName('ESDraft', '#sec-array.prototype.values', 'Array.prototype.values')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

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

Vea también

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