From 266e96fd85c4670137c4876862ec1b0e8af1f842 Mon Sep 17 00:00:00 2001 From: Alexander Date: Wed, 28 Sep 2022 11:50:06 -0500 Subject: [PATCH] Convert /web/javascript/reference/global_objects/array folder to Markdown (es) (#8169) * Convert /web/javascript/reference/global_objects/array folder to Markdown (es) * Apply suggestions from code review Authored by: Queen Vinyl Da.i'gyu-Kazotetsu Co-authored-by: GrayWolf --- .../array/@@iterator/index.html | 90 ---- .../global_objects/array/@@iterator/index.md | 71 +++ .../global_objects/array/@@species/index.html | 77 --- .../global_objects/array/@@species/index.md | 59 +++ .../array/@@unscopables/index.html | 79 --- .../array/@@unscopables/index.md | 58 +++ .../global_objects/array/entries/index.html | 87 ---- .../global_objects/array/entries/index.md | 62 +++ .../global_objects/array/fill/index.html | 146 ------ .../global_objects/array/fill/index.md | 127 +++++ .../global_objects/array/find/index.html | 234 --------- .../global_objects/array/find/index.md | 216 +++++++++ .../global_objects/array/findindex/index.html | 188 -------- .../global_objects/array/findindex/index.md | 165 +++++++ .../global_objects/array/from/index.html | 243 ---------- .../global_objects/array/from/index.md | 229 +++++++++ .../global_objects/array/includes/index.html | 182 ------- .../global_objects/array/includes/index.md | 161 +++++++ .../reference/global_objects/array/index.html | 450 ------------------ .../reference/global_objects/array/index.md | 423 ++++++++++++++++ .../global_objects/array/indexof/index.html | 249 ---------- .../global_objects/array/indexof/index.md | 227 +++++++++ .../global_objects/array/isarray/index.html | 129 ----- .../global_objects/array/isarray/index.md | 110 +++++ .../global_objects/array/join/index.html | 111 ----- .../global_objects/array/join/index.md | 83 ++++ .../global_objects/array/keys/index.html | 85 ---- .../global_objects/array/keys/index.md | 68 +++ .../array/lastindexof/index.html | 165 ------- .../global_objects/array/lastindexof/index.md | 141 ++++++ .../global_objects/array/length/index.html | 144 ------ .../global_objects/array/length/index.md | 121 +++++ .../global_objects/array/of/index.html | 98 ---- .../global_objects/array/of/index.md | 77 +++ .../global_objects/array/pop/index.html | 95 ---- .../global_objects/array/pop/index.md | 70 +++ .../global_objects/array/push/index.html | 141 ------ .../global_objects/array/push/index.md | 113 +++++ .../global_objects/array/reduce/index.html | 216 --------- .../global_objects/array/reduce/index.md | 194 ++++++++ .../array/reduceright/index.html | 167 ------- .../global_objects/array/reduceright/index.md | 168 +++++++ .../global_objects/array/reverse/index.html | 89 ---- .../global_objects/array/reverse/index.md | 64 +++ .../global_objects/array/shift/index.html | 77 --- .../global_objects/array/shift/index.md | 58 +++ .../global_objects/array/some/index.html | 205 -------- .../global_objects/array/some/index.md | 181 +++++++ .../global_objects/array/sort/index.html | 254 ---------- .../global_objects/array/sort/index.md | 243 ++++++++++ .../array/tolocalestring/index.html | 178 ------- .../array/tolocalestring/index.md | 154 ++++++ .../global_objects/array/tostring/index.html | 79 --- .../global_objects/array/tostring/index.md | 54 +++ .../global_objects/array/unshift/index.html | 101 ---- .../global_objects/array/unshift/index.md | 71 +++ .../global_objects/array/values/index.html | 83 ---- .../global_objects/array/values/index.md | 67 +++ 58 files changed, 3835 insertions(+), 4442 deletions(-) delete mode 100644 files/es/web/javascript/reference/global_objects/array/@@iterator/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/@@iterator/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/@@species/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/@@species/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/@@unscopables/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/@@unscopables/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/entries/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/entries/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/fill/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/fill/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/find/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/find/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/findindex/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/findindex/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/from/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/from/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/includes/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/includes/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/indexof/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/indexof/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/isarray/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/isarray/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/join/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/join/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/keys/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/keys/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/lastindexof/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/lastindexof/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/length/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/length/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/of/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/of/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/pop/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/pop/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/push/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/push/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/reduce/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/reduce/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/reduceright/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/reduceright/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/reverse/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/reverse/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/shift/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/shift/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/some/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/some/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/sort/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/sort/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/tolocalestring/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/tolocalestring/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/tostring/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/tostring/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/unshift/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/unshift/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/array/values/index.html create mode 100644 files/es/web/javascript/reference/global_objects/array/values/index.md 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 deleted file mode 100644 index 29fe137a593b30..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/@@iterator/index.html +++ /dev/null @@ -1,90 +0,0 @@ ---- -title: Array.prototype[@@iterator]() -slug: Web/JavaScript/Reference/Global_Objects/Array/@@iterator -tags: - - Array - - ECMAScript 2015 - - Iterator - - JavaScript - - Prototipo - - Referencia - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@iterator -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("Array.prototype.keys()")}}
    • -
  • {{jsxref("Array.prototype.entries()")}}
    • -
  • {{jsxref("Array.prototype.forEach()")}}
    • -
  • {{jsxref("Array.prototype.every()")}}
    • -
  • {{jsxref("Array.prototype.some()")}}
    • -
  • {{jsxref("Array.prototype.values()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/@@iterator/index.md b/files/es/web/javascript/reference/global_objects/array/@@iterator/index.md new file mode 100644 index 00000000000000..85c675bda25596 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/@@iterator/index.md @@ -0,0 +1,71 @@ +--- +title: Array.prototype[@@iterator]() +slug: Web/JavaScript/Reference/Global_Objects/Array/@@iterator +tags: + - Array + - ECMAScript 2015 + - Iterator + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@iterator +original_slug: Web/JavaScript/Referencia/Objetos_globales/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` + +```js +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 + +```js +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ón | Estado | Comentario | +| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- | +| {{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 + +- {{jsxref("Array.prototype.keys()")}} +- {{jsxref("Array.prototype.entries()")}} +- {{jsxref("Array.prototype.forEach()")}} +- {{jsxref("Array.prototype.every()")}} +- {{jsxref("Array.prototype.some()")}} +- {{jsxref("Array.prototype.values()")}} 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 deleted file mode 100644 index 64d64a517370fa..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/@@species/index.html +++ /dev/null @@ -1,77 +0,0 @@ ---- -title: get Array[@@species] -slug: Web/JavaScript/Reference/Global_Objects/Array/@@species -tags: - - Array - - JavaScript - - Prototipo - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@species -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("Array")}}
    • -
  • {{jsxref("Symbol.species")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/@@species/index.md b/files/es/web/javascript/reference/global_objects/array/@@species/index.md new file mode 100644 index 00000000000000..2c8a78740351f6 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/@@species/index.md @@ -0,0 +1,59 @@ +--- +title: get Array[@@species] +slug: Web/JavaScript/Reference/Global_Objects/Array/@@species +tags: + - Array + - JavaScript + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@species +original_slug: Web/JavaScript/Referencia/Objetos_globales/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`: + +```js +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: + +```js +class MyArray extends Array { + // Overwrite MyArray species to the parent Array constructor + static get [Symbol.species]() { return Array; } +} +``` + +## Especificaciones + +| Especificación | Estado | Comentario | +| -------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------- | +| {{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 + +- {{jsxref("Array")}} +- {{jsxref("Symbol.species")}} 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 deleted file mode 100644 index d838049fdfcfef..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/@@unscopables/index.html +++ /dev/null @@ -1,79 +0,0 @@ ---- -title: Array.prototype[@@unscopables] -slug: Web/JavaScript/Reference/Global_Objects/Array/@@unscopables -tags: - - Array - - JavaScript - - Matriz - - Propiedad - - Prototipo -translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@unscopables -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("Symbol.unscopables")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/@@unscopables/index.md b/files/es/web/javascript/reference/global_objects/array/@@unscopables/index.md new file mode 100644 index 00000000000000..350a396411d341 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/@@unscopables/index.md @@ -0,0 +1,58 @@ +--- +title: Array.prototype[@@unscopables] +slug: Web/JavaScript/Reference/Global_Objects/Array/@@unscopables +tags: + - Array + - JavaScript + - Matriz + - Propiedad + - Prototipo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@unscopables +original_slug: Web/JavaScript/Referencia/Objetos_globales/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`](/es/docs/Web/JavaScript/Reference/Statements/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`. + +```js +var keys = []; + +with (Array.prototype) { + keys.push('something'); +} + +Object.keys(Array.prototype[Symbol.unscopables]); +// ["copyWithin", "entries", "fill", "find", "findIndex", +// "includes", "keys", "values"] +``` + +## Especificaciones + +| Especificación | Estado | Comentario | +| -------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------- | +| {{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 + +- {{jsxref("Symbol.unscopables")}} 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 deleted file mode 100644 index 2d7878f2b2ad0b..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/entries/index.html +++ /dev/null @@ -1,87 +0,0 @@ ---- -title: Array.prototype.entries() -slug: Web/JavaScript/Reference/Global_Objects/Array/entries -tags: - - Array - - ECMAScript 2015 - - Iterador - - Iterator - - JavaScript - - Prototipo - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/Array/entries -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("Array.prototype.keys()")}}
    • -
  • {{jsxref("Array.prototype.values()")}}
    • -
  • {{jsxref("Array.prototype.forEach()")}}
    • -
  • {{jsxref("Array.prototype.every()")}}
    • -
  • {{jsxref("Array.prototype.some()")}}
    • -
  • for...of
    • -
  • Protocolos de iteración
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/entries/index.md b/files/es/web/javascript/reference/global_objects/array/entries/index.md new file mode 100644 index 00000000000000..1f4bc53658f067 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/entries/index.md @@ -0,0 +1,62 @@ +--- +title: Array.prototype.entries() +slug: Web/JavaScript/Reference/Global_Objects/Array/entries +tags: + - Array + - ECMAScript 2015 + - Iterador + - Iterator + - JavaScript + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/entries +original_slug: Web/JavaScript/Referencia/Objetos_globales/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](/es/docs/Web/JavaScript/Reference/Statements/for...of) + +```js +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ón | Estado | Comentarios | +| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ------------------- | +| {{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 + +- {{jsxref("Array.prototype.keys()")}} +- {{jsxref("Array.prototype.values()")}} +- {{jsxref("Array.prototype.forEach()")}} +- {{jsxref("Array.prototype.every()")}} +- {{jsxref("Array.prototype.some()")}} +- [for...of](/es/docs/Web/JavaScript/Reference/Statements/for...of) +- [Protocolos de iteración](/es/docs/Web/JavaScript/Reference/Iteration_protocols) 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 deleted file mode 100644 index 7b57f7209e57c4..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/fill/index.html +++ /dev/null @@ -1,146 +0,0 @@ ---- -title: Array.prototype.fill() -slug: Web/JavaScript/Reference/Global_Objects/Array/fill -tags: - - Array - - ECMAScript 2015 - - JavaScript - - Prototipo - - metodo - - polyfill -translation_of: Web/JavaScript/Reference/Global_Objects/Array/fill -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • Si start es negativo, se interpreta como array.length + start.
    • -
  • Si end es negativo, se interpreta como array.length + end.
    • -
  • fill es genérico de forma intencional: no requiere que su valor this sea un objeto Array.
    • -
  • fill es un método mutador: modifica el arreglo sobre el que se invoca; no devuelve una copia de éste.
    • -
  • Si el primer parámetro es un objeto, copia su referencia y rellena el arreglo con referencias a dicho objeto.
    • -
- -

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

- -
    -
  • {{jsxref("Array")}}
    • -
  • {{jsxref("TypedArray.prototype.fill()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/fill/index.md b/files/es/web/javascript/reference/global_objects/array/fill/index.md new file mode 100644 index 00000000000000..87b044de8cc4a3 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/fill/index.md @@ -0,0 +1,127 @@ +--- +title: Array.prototype.fill() +slug: Web/JavaScript/Reference/Global_Objects/Array/fill +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Prototipo + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/fill +original_slug: Web/JavaScript/Referencia/Objetos_globales/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 + +- Si `start` es negativo, se interpreta como `array.length + start`. +- Si `end` es negativo, se interpreta como `array.length + end`. +- `fill` es genérico de forma intencional: no requiere que su valor `this` sea un objeto `Array`. +- `fill` es un método mutador: modifica el arreglo sobre el que se invoca; no devuelve una copia de éste. +- Si el primer parámetro es un objeto, copia su referencia y rellena el arreglo con referencias a dicho objeto. + +## Ejemplos + +```js +[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 + +```js +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ón | Estado | Comentario | +| ---------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------- | +| {{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 + +- {{jsxref("Array")}} +- {{jsxref("TypedArray.prototype.fill()")}} 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 deleted file mode 100644 index 063f36dc9d389c..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/find/index.html +++ /dev/null @@ -1,234 +0,0 @@ ---- -title: Array.prototype.find() -slug: Web/JavaScript/Reference/Global_Objects/Array/find -tags: - - Array - - ECMAScript 2015 - - JavaScript - - Prototipo - - Referencia - - metodo - - polyfill -translation_of: Web/JavaScript/Reference/Global_Objects/Array/find -original_slug: Web/JavaScript/Referencia/Objetos_globales/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")}}
- - - -
    -
  • Si necesitas el índice del elemento encontrado en el array, utiliza {{jsxref("Array.findIndex", "findIndex()")}}.
    • -
  • Si necesitas encontrar el índice de un elemento, {{jsxref("Array.prototype.indexOf()")}}. (Es similar a {{jsxref("Array.findIndex", "findIndex()")}}, pero comprueba la igualdad de cada elemento con el valor en lugar de usar una función de prueba.)
    • -
  • Si necesitas encontrar si un valor existe en un array, utiliza {{jsxref("Array.prototype.includes()")}}.
    • -
  • Si necesitas encontrar si algún elemento cumple la función de prueba proporcionada, usa {{jsxref("Array.prototype.some()")}}.
    • -
- -

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:

- -
    -
  • callback no visitará ningún elemento añadido al array después de que comience la llamada a find.
    • -
  • Si un elemento existente no visitado del array es modificado por callback, su valor que se pasa al callback que lo visita será el valor en el momento en que find visita ese índice del elemento.
    • -
  • Los elementos que sean {{jsxref("delete", "deleted")}} (eliminados) aún se visitan.
    • -
- -

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

- -
    -
  • {{jsxref("Array.prototype.findIndex()")}} – encuentra y devuelve un índice
    • -
  • {{jsxref("Array.prototype.includes()")}} – comprueba que un valor existe en el array
    • -
  • {{jsxref("Array.prototype.filter()")}} – elimina todos los elementos que no coincidan
    • -
  • {{jsxref("Array.prototype.every()")}} – comprueba todos los elementos
    • -
  • {{jsxref("Array.prototype.some()")}} – comprueba hasta que un elemento coincide
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/find/index.md b/files/es/web/javascript/reference/global_objects/array/find/index.md new file mode 100644 index 00000000000000..1253f25d8158e4 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/find/index.md @@ -0,0 +1,216 @@ +--- +title: Array.prototype.find() +slug: Web/JavaScript/Reference/Global_Objects/Array/find +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Prototipo + - Referencia + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/find +original_slug: Web/JavaScript/Referencia/Objetos_globales/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")}} + +- Si necesitas el **índice** del elemento encontrado en el array, utiliza {{jsxref("Array.findIndex", "findIndex()")}}. +- Si necesitas encontrar el **índice de un elemento**, {{jsxref("Array.prototype.indexOf()")}}. (Es similar a {{jsxref("Array.findIndex", "findIndex()")}}, pero comprueba la igualdad de cada elemento con el valor en lugar de usar una función de prueba.) +- Si necesitas encontrar si un valor **existe** en un array, utiliza {{jsxref("Array.prototype.includes()")}}. +- Si necesitas encontrar si algún elemento cumple la función de prueba proporcionada, usa {{jsxref("Array.prototype.some()")}}. + +## 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`](/es/docs/Web/JavaScript/Referencia/Operadores/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](/es/docs/Glossary/Truthy). 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: + +- `callback` no visitará ningún elemento añadido al array después de que comience la llamada a `find`. +- Si un elemento existente no visitado del array es modificado por `callback`, su valor que se pasa al `callback` que lo visita será el valor en el momento en que `find` visita ese índice del elemento. +- Los elementos que sean {{jsxref("delete", "deleted")}} (eliminados) aún se visitan. + +## Ejemplos + +### Encontrar un objeto en un array por una de sus propiedades + +```js +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 + +```js +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). + +```js +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. + +```js +// 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`: + +```js +// 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`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/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 + +- {{jsxref("Array.prototype.findIndex()")}} – encuentra y devuelve un índice +- {{jsxref("Array.prototype.includes()")}} – comprueba que un valor existe en el array +- {{jsxref("Array.prototype.filter()")}} – elimina todos los elementos que no coincidan +- {{jsxref("Array.prototype.every()")}} – comprueba todos los elementos +- {{jsxref("Array.prototype.some()")}} – comprueba hasta que un elemento coincide 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 deleted file mode 100644 index bcdb7925e4edc6..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/findindex/index.html +++ /dev/null @@ -1,188 +0,0 @@ ---- -title: Array.prototype.findIndex() -slug: Web/JavaScript/Reference/Global_Objects/Array/findIndex -tags: - - Array - - ECMAScript 2015 - - JavaScript - - Protitipo - - Referencia - - metodo - - polyfill -translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("Array.prototype.find()")}}
    • -
  • {{jsxref("Array.prototype.indexOf()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/findindex/index.md b/files/es/web/javascript/reference/global_objects/array/findindex/index.md new file mode 100644 index 00000000000000..9e0f56614ce839 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/findindex/index.md @@ -0,0 +1,165 @@ +--- +title: Array.prototype.findIndex() +slug: Web/JavaScript/Reference/Global_Objects/Array/findIndex +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Protitipo + - Referencia + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex +original_slug: Web/JavaScript/Referencia/Objetos_globales/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](/es/docs/Glossary/Type_Conversion) 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`. + +> **Nota:** **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. El índice del elemento +3. El Array que será recorrido. + +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](/es/docs/Web/JavaScript/Referencia/Operadores/delete) 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). + +```js +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. + +```js +const fruits = ["apple", "banana", "cantaloupe", "blueberries", "grapefruit"]; + +const index = fruits.findIndex(fruit => fruit === "blueberries"); + +console.log(index); // 3 +console.log(fruits[index]); // blueberries +``` + +## Polyfill + +```js +// 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/docs/Web/JavaScript/Referencia/Objetos_globales/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 + +- {{jsxref("Array.prototype.find()")}} +- {{jsxref("Array.prototype.indexOf()")}} 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 deleted file mode 100644 index a1b7a7257cdf9a..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/from/index.html +++ /dev/null @@ -1,243 +0,0 @@ ---- -title: Array.from() -slug: Web/JavaScript/Reference/Global_Objects/Array/from -tags: - - ECMAScript 2015 - - JavaScript - - Referencia - - Vector - - metodo - - polyfill -translation_of: Web/JavaScript/Reference/Global_Objects/Array/from -original_slug: Web/JavaScript/Referencia/Objetos_globales/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:

- -
    -
  • Objetos array-like (objetos con propiedad length o elementos indexados).
    • -
  • Objetos iterables (objetos de los cuales se pueden obtener sus elementos como {{jsxref("Map")}} y {{jsxref("Set")}}).
    • -
- -

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

- -
    -
  • {{jsxref("Array")}}
    • -
  • {{jsxref("Array.prototype.map()")}}
    • -
  • {{jsxref("TypedArray.from()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/from/index.md b/files/es/web/javascript/reference/global_objects/array/from/index.md new file mode 100644 index 00000000000000..75db1ed2ff63c7 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/from/index.md @@ -0,0 +1,229 @@ +--- +title: Array.from() +slug: Web/JavaScript/Reference/Global_Objects/Array/from +tags: + - ECMAScript 2015 + - JavaScript + - Referencia + - Vector + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/from +original_slug: Web/JavaScript/Referencia/Objetos_globales/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: + +- Objetos array-like (objetos con propiedad `length` o elementos indexados). +- [Objetos iterables](/es/docs/Web/JavaScript/Referencia/Iteration_protocols) (objetos de los cuales se pueden obtener sus elementos como {{jsxref("Map")}} y {{jsxref("Set")}}). + +`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](/es/docs/Web/JavaScript/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` + +```js +Array.from('foo'); +// [ "f", "o", "o" ] +``` + +### Array desde un `Set` + +```js +const set = new Set(['foo', 'bar', 'baz', 'foo']); +Array.from(set); +// [ "foo", "bar", "baz" ] +``` + +### Array desde un `Map` + +```js +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) + +```js +function f() { + return Array.from(arguments); +} + +f(1, 2, 3); + +// [ 1, 2, 3 ] +``` + +### Usando una función de flecha y `Array.from` + +```js +// 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) + +```js +// 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. + +```js +// 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ón | Estado | Comentario | +| ---------------------------------------------------------------------------- | ---------------------------- | ------------------- | +| {{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 + +- {{jsxref("Array")}} +- {{jsxref("Array.prototype.map()")}} +- {{jsxref("TypedArray.from()")}} 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 deleted file mode 100644 index bf8776cde6bf01..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/includes/index.html +++ /dev/null @@ -1,182 +0,0 @@ ---- -title: Array.prototype.includes() -slug: Web/JavaScript/Reference/Global_Objects/Array/includes -tags: - - Array - - JavaScript - - Prototipo - - Referencia - - metodo - - polyfill -translation_of: Web/JavaScript/Reference/Global_Objects/Array/includes -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("TypedArray.prototype.includes()")}}
    • -
  • {{jsxref("String.prototype.includes()")}}
    • -
  • {{jsxref("Array.prototype.indexOf()")}}
    • -
  • {{jsxref("Array.prototype.find()")}}
    • -
  • {{jsxref("Array.prototype.findIndex()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/includes/index.md b/files/es/web/javascript/reference/global_objects/array/includes/index.md new file mode 100644 index 00000000000000..4d2bddfb45e6fd --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/includes/index.md @@ -0,0 +1,161 @@ +--- +title: Array.prototype.includes() +slug: Web/JavaScript/Reference/Global_Objects/Array/includes +tags: + - Array + - JavaScript + - Prototipo + - Referencia + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/includes +original_slug: Web/JavaScript/Referencia/Objetos_globales/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. + +> **Nota:** Técnicamente hablando, `include()` usa el algoritmo [`sameValueZero`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness#Same-value-zero_equality) para determinar si se encuentra el elemento dado + +## Ejemplos + +```js +[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. + +```js +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. + +```js +// 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. + +```js +(function() { + console.log([].includes.call(arguments, 'a')); // true + console.log([].includes.call(arguments, 'd')); // false +})('a','b','c'); +``` + +## Polyfill + +```js +// 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/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty), es mejor no rellenar los métodos `Array.prototype`, ya que no puede hacerlos no enumerables. + +## Especificaciones + +| Especificación | Estado | Comentarios | +| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------- | +| {{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 + +- {{jsxref("TypedArray.prototype.includes()")}} +- {{jsxref("String.prototype.includes()")}} +- {{jsxref("Array.prototype.indexOf()")}} +- {{jsxref("Array.prototype.find()")}} +- {{jsxref("Array.prototype.findIndex()")}} diff --git a/files/es/web/javascript/reference/global_objects/array/index.html b/files/es/web/javascript/reference/global_objects/array/index.html deleted file mode 100644 index 384e909248cf00..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/index.html +++ /dev/null @@ -1,450 +0,0 @@ ---- -title: Array -slug: Web/JavaScript/Reference/Global_Objects/Array -tags: - - Array - - JavaScript - - Matriz unidimensional - - Referencia - - Vector -translation_of: Web/JavaScript/Reference/Global_Objects/Array -original_slug: Web/JavaScript/Referencia/Objetos_globales/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/index.md b/files/es/web/javascript/reference/global_objects/array/index.md new file mode 100644 index 00000000000000..d73f4cb8c47f4c --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/index.md @@ -0,0 +1,423 @@ +--- +title: Array +slug: Web/JavaScript/Reference/Global_Objects/Array +tags: + - Array + - JavaScript + - Matriz unidimensional + - Referencia + - Vector +translation_of: Web/JavaScript/Reference/Global_Objects/Array +original_slug: Web/JavaScript/Referencia/Objetos_globales/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** + +```js +let frutas = ["Manzana", "Banana"] + +console.log(frutas.length) +// 2 +``` + +**Acceder a un elemento de Array mediante su índice** + +```js +let primero = frutas[0] +// Manzana + +let ultimo = frutas[frutas.length - 1] +// Banana +``` + +**Recorrer un Array** + +```js +frutas.forEach(function(elemento, indice, array) { + console.log(elemento, indice); +}) +// Manzana 0 +// Banana 1 +``` + +**Añadir un elemento al final de un Array** + +```js +let nuevaLongitud = frutas.push('Naranja') // Añade "Naranja" al final +// ["Manzana", "Banana", "Naranja"] +``` + +**Eliminar el último elemento de un Array** + +```js +let ultimo = frutas.pop() // Elimina "Naranja" del final +// ["Manzana", "Banana"] +``` + +**Añadir un elemento al principio de un Array** + +```js +let nuevaLongitud = frutas.unshift('Fresa') // Añade "Fresa" al inicio +// ["Fresa" ,"Manzana", "Banana"] +``` + +**Eliminar el primer elemento de un Array** + +```js +let primero = frutas.shift() // Elimina "Fresa" del inicio +// ["Manzana", "Banana"] +``` + +**Encontrar el índice de un elemento del Array** + +```js +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". + +```js +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. + +```js +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** + +```js +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`. + +```js +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: + +```js +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. + +```js +let decadas = [1950, 1960, 1970, 1980, 1990, 2000, 2010] +console.log(decadas.0) // error de sintaxis +console.log(decadas[0]) // funciona correctamente +``` + +```js +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: + +```js +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. + +```js +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: + +```js +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`: + +```js +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: + +```js +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`](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/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: + +```js +// 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/Elemento | Descripción | Ejemplo | +| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------- | +| `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()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array)** + - : Crea un nuevo objeto `Array`. + +## Propiedades estáticas + +- [`get Array[@@species]`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/@@species) + - : La función del constructor se utiliza para crear objetos derivados. + +## Métodos estáticos + +- [`Array.from()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/from) + - : Crea una nueva instancia de `Array` a partir de `similarAUnArray`, un objeto iterable o parecido a un _array._ +- [`Array.isArray()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/isArray) + - : Devuelve `true` si `valor` es un _array_, y `false` en caso contrario. +- [`Array.of()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/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`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/length) + - : Indica el número de elementos de un _array_. +- [`Array.prototype[@@unscopables]`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/@@unscopables) + - : Símbolo que contiene todos los nombres de las propiedades que se excluyen de un ámbito de enlace [`with`](/es/docs/Web/JavaScript/Referencia/Sentencias/with). + +## Métodos de instancia + +- [`Array.prototype.concat()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/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()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/copyWithin) + - : Copia una secuencia de elementos de un _array_ dentro del propio _array_. +- [`Array.prototype.entries()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/entries) + - : Devuelve un nuevo objeto `Array Iterator` que contiene los pares clave/valor para cada índice del _array_. +- [`Array.prototype.every()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/every) + - : Devuelve `true` si todos los elementos del _array_ cumplen el predicado que recibe como parámetro. +- [`Array.prototype.fill()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/fill) + - : Asigna un _`valor`_ estático a todos los elementos del _array_ entre las posiciones `inicio` y `fin`. +- [`Array.prototype.filter()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/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()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/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()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/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()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/forEach) + - : Llama a la función pasada como parámetro para todos los elementos del _array._ +- [`Array.prototype.includes()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/includes) + - : Determina si el _array_ contiene el `valorBuscado` y devuelve `true` o `false` según sea el caso. +- [`Array.prototype.indexOf()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/indexOf) + - : Devuelve el índice del primer elemento del _array_ que sea igual a `elementoBuscado`, o `-1` si no existe. +- [`Array.prototype.join()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/join) + - : Concatena en un string todos los elementos de un _array._ +- [`Array.prototype.keys()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/keys) + - : Devuelve un nuevo `Array Iterator` que contiene las claves de cada índice del _array._ +- [`Array.prototype.lastIndexOf()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/lastIndexOf) + - : Devuelve el índice del último elemento del _array_ que sea igual a `elementoBuscado`, o `-1` si no existe. +- [`Array.prototype.map()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/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()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/pop) + - : Elimina el último elemento de un _array_, y devuelve dicho elemento. +- [`Array.prototype.push()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/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()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/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()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/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()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/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()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/shift) + - : Elimina el primer elemento de un _array_, y devuelve dicho elemento. +- [`Array.prototype.slice()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/slice) + - : Extrae una porción del _array_ sobre el que se llama y devuelve un nuevo _array_. +- [`Array.prototype.some()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/some) + - : Devuelve `true` si al menos un elemento del _array_ cumple con el predicado que se pasa como parámetro. +- [`Array.prototype.sort()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/sort) + - : Ordena los elementos de un _array_, modificando éste, y devuelve el array ordenado. +- [`Array.prototype.splice()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/splice) + - : Añade, borra o modifica elementos de un _array_. +- [`Array.prototype.toLocaleString()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/toLocaleString) + - : Devuelve un string adaptado a la configuración regional que representa el _array_ y sus elementos. Redefine el método [`Object.prototype.toLocaleString()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Object/toLocaleString). +- [`Array.prototype.toString()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/toString) + - : Devuelve un string que representa el _array_ y sus elementos. Redefine el método [`Object.prototype.toString()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Object/toString). +- [`Array.prototype.unshift()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/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()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/values) + - : Devuelve un nuevo objeto `Array Iterator` que contiene los valores para cada índice del _array_. +- [`Array.prototype[@@iterator]()`](/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/@@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. + +```js +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ón | Publicación inicial | +| ------------------------------------------------------------------------ | ------------------- | +| {{SpecName('ESDraft', '#sec-array-objects', 'Array')}} | ECMAScript 1 | + +## Compatibilidad con navegadores + +{{Compat("javascript.builtins.Array")}} + +## Ver también + +- En la Guía de JavaScript: + + - ["Propiedades indexadas de un objeto"](/es/docs/Web/JavaScript/Guide/Working_with_Objects#Indexing_object_properties) + - ["Colecciones con índice: objeto Array"](/es/docs/Web/JavaScript/Guide/Indexed_collections#Array_object) + +- [Arrays tipados](/es/docs/JavaScript_typed_arrays) 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 deleted file mode 100644 index fbbb4366409bb6..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/indexof/index.html +++ /dev/null @@ -1,249 +0,0 @@ ---- -title: Array.prototype.indexOf() -slug: Web/JavaScript/Reference/Global_Objects/Array/indexOf -tags: - - Array - - JavaScript - - Method - - Prototype - - Referencia - - polyfill -translation_of: Web/JavaScript/Reference/Global_Objects/Array/indexOf -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • Comenzando con Firefox 47 {{geckoRelease(47)}}, este método ya no devolverá -0. Por ejemplo, [0] .indexOf (0, -0) siempre devolverá +0 ({{bug(1242043)}}).
    • -
- -
- -

Ver también

- -
    -
  • {{jsxref("Array.prototype.lastIndexOf()")}}
    • -
  • {{jsxref("TypedArray.prototype.indexOf()")}}
    • -
  • {{jsxref("String.prototype.indexOf()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/indexof/index.md b/files/es/web/javascript/reference/global_objects/array/indexof/index.md new file mode 100644 index 00000000000000..c443587708b529 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/indexof/index.md @@ -0,0 +1,227 @@ +--- +title: Array.prototype.indexOf() +slug: Web/JavaScript/Reference/Global_Objects/Array/indexOf +tags: + - Array + - JavaScript + - Method + - Prototype + - Referencia + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/indexOf +original_slug: Web/JavaScript/Referencia/Objetos_globales/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](/es/docs/Web/JavaScript/Referencia/Operadores/Comparison_Operators#Using_the_Equality_Operators "JavaScript/Reference/Operators/Comparison_Operators#Using_the_Equality_Operators") (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 + +```js +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 + +```js +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 + +```js +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. + +```js +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. + +```js +// 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ón | Estado | Comentario | +| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | --------------------------------------------------- | +| {{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 + +- Comenzando con Firefox 47 {{geckoRelease(47)}}, este método ya no devolverá `-0`. Por ejemplo, `[0] .indexOf (0, -0)` siempre devolverá `+0` ({{bug(1242043)}}). + +## Ver también + +- {{jsxref("Array.prototype.lastIndexOf()")}} +- {{jsxref("TypedArray.prototype.indexOf()")}} +- {{jsxref("String.prototype.indexOf()")}} 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 deleted file mode 100644 index b977753b13d933..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/isarray/index.html +++ /dev/null @@ -1,129 +0,0 @@ ---- -title: Array.isArray() -slug: Web/JavaScript/Reference/Global_Objects/Array/isArray -tags: - - Array - - ECMAScript5 - - JavaScript - - Referencia - - metodo - - polyfill -translation_of: Web/JavaScript/Reference/Global_Objects/Array/isArray -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("Array")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/isarray/index.md b/files/es/web/javascript/reference/global_objects/array/isarray/index.md new file mode 100644 index 00000000000000..de415d58581d72 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/isarray/index.md @@ -0,0 +1,110 @@ +--- +title: Array.isArray() +slug: Web/JavaScript/Reference/Global_Objects/Array/isArray +tags: + - Array + - ECMAScript5 + - JavaScript + - Referencia + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/isArray +original_slug: Web/JavaScript/Referencia/Objetos_globales/Array/isArray +--- +{{JSRef}} + +El método **`Array.isArray()`** determina si el valor pasado es un {{jsxref("Array")}}. + +```js +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”](http://web.mit.edu/jwalden/www/isArray.html) para más detalles. + +## Ejemplos + +```js +// 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`. + +```js +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. + +```js +if (!Array.isArray) { + Array.isArray = function(arg) { + return Object.prototype.toString.call(arg) === '[object Array]'; + }; +} +``` + +## Especificaciones + +| Especificación | Estado | Comentario | +| ------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- | +| {{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 + +- {{jsxref("Array")}} 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 deleted file mode 100644 index 1274b28407717f..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/join/index.html +++ /dev/null @@ -1,111 +0,0 @@ ---- -title: Array.prototype.join() -slug: Web/JavaScript/Reference/Global_Objects/Array/join -tags: - - Array - - JavaScript - - Matriz - - Prototipo - - Referencia - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/Array/join -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("String.prototype.split()")}}
    • -
  • {{jsxref("Array.prototype.toString()")}}
    • -
  • {{jsxref("TypedArray.prototype.join()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/join/index.md b/files/es/web/javascript/reference/global_objects/array/join/index.md new file mode 100644 index 00000000000000..993dbd48562321 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/join/index.md @@ -0,0 +1,83 @@ +--- +title: Array.prototype.join() +slug: Web/JavaScript/Reference/Global_Objects/Array/join +tags: + - Array + - JavaScript + - Matriz + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/join +original_slug: Web/JavaScript/Referencia/Objetos_globales/Array/join +--- +{{JSRef}} + +El método **`join()`** une todos los elementos de una matriz (o un [objeto similar a una matriz](/es/docs/Web/JavaScript/Guide/Indexed_collections#Working_with_array-like_objects)) 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. + +> **Advertencia:** 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. + +```js +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`](/es/docs/Web/JavaScript/Reference/Functions/arguments)), llamando a {{jsxref("Function.prototype.call")}} en `Array.prototype.join`. + +```js +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ón | Estado | Comentario | +| ---------------------------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------------- | +| ECMAScript 1st Edition | Estándar | Definició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 + +- {{jsxref("String.prototype.split()")}} +- {{jsxref("Array.prototype.toString()")}} +- {{jsxref("TypedArray.prototype.join()")}} 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 deleted file mode 100644 index 21e0f96d1b4aa0..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/keys/index.html +++ /dev/null @@ -1,85 +0,0 @@ ---- -title: Array.prototype.keys() -slug: Web/JavaScript/Reference/Global_Objects/Array/keys -tags: - - Array - - ECMAScript 2015 - - Iterator - - JavaScript - - Matriz - - Prototipo - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/Array/keys -original_slug: Web/JavaScript/Referencia/Objetos_globales/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/keys/index.md b/files/es/web/javascript/reference/global_objects/array/keys/index.md new file mode 100644 index 00000000000000..e8731f0fe09d90 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/keys/index.md @@ -0,0 +1,68 @@ +--- +title: Array.prototype.keys() +slug: Web/JavaScript/Reference/Global_Objects/Array/keys +tags: + - Array + - ECMAScript 2015 + - Iterator + - JavaScript + - Matriz + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/keys +original_slug: Web/JavaScript/Referencia/Objetos_globales/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 + +```js +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 + +```js +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ón | Estado | Comentario | +| ---------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------- | +| {{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 + +- {{jsxref("Array.prototype.values()")}} +- {{jsxref("Array.prototype.entries()")}} +- [Protocolos de iteración](/es/docs/Web/JavaScript/Reference/Iteration_protocols) 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 deleted file mode 100644 index 0375ef786a88c9..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/lastindexof/index.html +++ /dev/null @@ -1,165 +0,0 @@ ---- -title: Array.prototype.lastIndexOf() -slug: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf -tags: - - Array - - Arreglo - - ECMAScript 5 - - JavaScript - - Matriz - - Prototipo - - metodo - - polyfill -translation_of: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • Desde Firefox 47 {{geckoRelease(47)}}, el método ya no devolverá -0. Por ejemplo, [0].lastIndexOf(0, -0) siempre devolverá +0 ({{bug(1242043)}}).
    • -
- -

Ver también

- -
    -
  • {{jsxref("Array.prototype.indexOf()")}}
    • -
  • {{jsxref("TypedArray.prototype.lastIndexOf()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/lastindexof/index.md b/files/es/web/javascript/reference/global_objects/array/lastindexof/index.md new file mode 100644 index 00000000000000..656fca78fc570f --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/lastindexof/index.md @@ -0,0 +1,141 @@ +--- +title: Array.prototype.lastIndexOf() +slug: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf +tags: + - Array + - Arreglo + - ECMAScript 5 + - JavaScript + - Matriz + - Prototipo + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf +original_slug: Web/JavaScript/Referencia/Objetos_globales/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](/es/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Using_the_Equality_Operators) (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. + +```js +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. + +```js +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. + +```js +// 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ón | Estado | Comentario | +| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | --------------------------------------------------- | +| {{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 + +- Desde Firefox 47 {{geckoRelease(47)}}, el método ya no devolverá `-0`. Por ejemplo, `[0].lastIndexOf(0, -0)` siempre devolverá `+0` ({{bug(1242043)}}). + +## Ver también + +- {{jsxref("Array.prototype.indexOf()")}} +- {{jsxref("TypedArray.prototype.lastIndexOf()")}} 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 deleted file mode 100644 index a7951ab8f9d3d9..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/length/index.html +++ /dev/null @@ -1,144 +0,0 @@ ---- -title: Array.prototype.length -slug: Web/JavaScript/Reference/Global_Objects/Array/length -tags: - - Array - - JavaScript - - Propiedad - - Referencia - - Vector -translation_of: Web/JavaScript/Reference/Global_Objects/Array/length -original_slug: Web/JavaScript/Referencia/Objetos_globales/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)}}

- -
    -
  • Sobrescribir: si este atributo se establece en false, el valor de la propiedad no se puede cambiar.
    • -
  • Configurable: si este atributo se establece en false, cualquier intento de eliminar la propiedad o cambiar sus atributos (Sobrescribir, Configurable o Numerable) fallará.
    • -
  • Numerable: si este atributo se establece en true, la propiedad se repetirá durante los bucles for o for..in.
    • -
- -

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

- -
    -
  • {{jsxref("Array")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/length/index.md b/files/es/web/javascript/reference/global_objects/array/length/index.md new file mode 100644 index 00000000000000..b231103828ffba --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/length/index.md @@ -0,0 +1,121 @@ +--- +title: Array.prototype.length +slug: Web/JavaScript/Reference/Global_Objects/Array/length +tags: + - Array + - JavaScript + - Propiedad + - Referencia + - Vector +translation_of: Web/JavaScript/Reference/Global_Objects/Array/length +original_slug: Web/JavaScript/Referencia/Objetos_globales/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). + +```js +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`. + +```js +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](/es/docs/Web/JavaScript/Reference/Global_Objects/Array#Relationship_between_length_and_numerical_properties "Relationship between length and numerical properties"). + +{{js_property_attributes(1, 0, 0)}} + +- `Sobrescribir`: si este atributo se establece en `false`, el valor de la propiedad no se puede cambiar. +- `Configurable`: si este atributo se establece en `false`, cualquier intento de eliminar la propiedad o cambiar sus atributos (`Sobrescribir`, `Configurable `o `Numerable`) fallará. +- `Numerable`: si este atributo se establece en `true`, la propiedad se repetirá durante los bucles [for](/es/docs/Web/JavaScript/Reference/Statements/for) o [for..in](/es/docs/Web/JavaScript/Reference/Statements/for...in). + +## 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. + +```js +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`. + +```js +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ón | Estado | Comentario | +| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------- | +| ECMAScript 1ra Edición. | Estándar | Definició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 + +- {{jsxref("Array")}} 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 deleted file mode 100644 index 60e2581049c087..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/of/index.html +++ /dev/null @@ -1,98 +0,0 @@ ---- -title: Array.of() -slug: Web/JavaScript/Reference/Global_Objects/Array/of -tags: - - Array - - ECMAScript 2015 - - JavaScript - - metodo - - polyfill -translation_of: Web/JavaScript/Reference/Global_Objects/Array/of -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("Array")}}
    • -
  • {{jsxref("Array.from()")}}
    • -
  • {{jsxref("TypedArray.of()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/of/index.md b/files/es/web/javascript/reference/global_objects/array/of/index.md new file mode 100644 index 00000000000000..9fb4530d1fb373 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/of/index.md @@ -0,0 +1,77 @@ +--- +title: Array.of() +slug: Web/JavaScript/Reference/Global_Objects/Array/of +tags: + - Array + - ECMAScript 2015 + - JavaScript + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/of +original_slug: Web/JavaScript/Referencia/Objetos_globales/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`). + +```js +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](https://gist.github.com/rwaldron/1074126) y [`Array.of` polyfill](https://gist.github.com/rwaldron/3186576). + +## Ejemplos + +```js +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. + +```js +if (!Array.of) { + Array.of = function() { + return Array.prototype.slice.call(arguments); + }; +} +``` + +## Especificaciones + +| Especificación | Estado | Comentario | +| -------------------------------------------------------------------- | ---------------------------- | ------------------- | +| {{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 + +- {{jsxref("Array")}} +- {{jsxref("Array.from()")}} +- {{jsxref("TypedArray.of()")}} 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 deleted file mode 100644 index ddea71c1c1604d..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/pop/index.html +++ /dev/null @@ -1,95 +0,0 @@ ---- -title: Array.prototype.pop() -slug: Web/JavaScript/Reference/Global_Objects/Array/pop -tags: - - Array - - JavaScript - - Prototipo - - Referencia - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/Array/pop -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("Array.prototype.push()")}}
    • -
  • {{jsxref("Array.prototype.shift()")}}
    • -
  • {{jsxref("Array.prototype.unshift()")}}
    • -
  • {{jsxref("Array.prototype.concat()")}}
    • -
  • {{jsxref("Array.prototype.splice()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/pop/index.md b/files/es/web/javascript/reference/global_objects/array/pop/index.md new file mode 100644 index 00000000000000..18c9739f65c0d8 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/pop/index.md @@ -0,0 +1,70 @@ +--- +title: Array.prototype.pop() +slug: Web/JavaScript/Reference/Global_Objects/Array/pop +tags: + - Array + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/pop +original_slug: Web/JavaScript/Referencia/Objetos_globales/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. + +```js +var myFish = ['angel', 'clown', 'mandarin', 'sturgeon']; + +var popped = myFish.pop(); + +console.log(myFish); // ['angel', 'clown', 'mandarin' ] + +console.log(popped); // 'sturgeon' +``` + +## Especificaciones + +| Especificación | Estado | Comentario | +| ---------------------------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------------- | +| {{SpecName('ES3')}} | Estándar | Definició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 + +- {{jsxref("Array.prototype.push()")}} +- {{jsxref("Array.prototype.shift()")}} +- {{jsxref("Array.prototype.unshift()")}} +- {{jsxref("Array.prototype.concat()")}} +- {{jsxref("Array.prototype.splice()")}} 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 deleted file mode 100644 index 52706ba2a60492..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/push/index.html +++ /dev/null @@ -1,141 +0,0 @@ ---- -title: Array.prototype.push() -slug: Web/JavaScript/Reference/Global_Objects/Array/push -tags: - - Array - - JavaScript - - Prototipo - - Referencia - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/Array/push -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("Array.prototype.pop()")}}
    • -
  • {{jsxref("Array.prototype.shift()")}}
    • -
  • {{jsxref("Array.prototype.unshift()")}}
    • -
  • {{jsxref("Array.prototype.concat()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/push/index.md b/files/es/web/javascript/reference/global_objects/array/push/index.md new file mode 100644 index 00000000000000..6c281be8c6c6cf --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/push/index.md @@ -0,0 +1,113 @@ +--- +title: Array.prototype.push() +slug: Web/JavaScript/Reference/Global_Objects/Array/push +tags: + - Array + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/push +original_slug: Web/JavaScript/Referencia/Objetos_globales/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". + +```js +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. + +```js +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. + +```js +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ón | Estado | Comentario | +| ---------------------------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------------- | +| {{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 + +- {{jsxref("Array.prototype.pop()")}} +- {{jsxref("Array.prototype.shift()")}} +- {{jsxref("Array.prototype.unshift()")}} +- {{jsxref("Array.prototype.concat()")}} 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 deleted file mode 100644 index cec4b377c86cc3..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/reduce/index.html +++ /dev/null @@ -1,216 +0,0 @@ ---- -title: Array.prototype.reduce() -slug: Web/JavaScript/Reference/Global_Objects/Array/Reduce -tags: - - Array - - ECMAScript 5 - - JavaScript - - Prototype - - Reduce - - Referencia - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce -original_slug: Web/JavaScript/Referencia/Objetos_globales/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:

- -
    -
  • valorAnterior
    • -
  • valorActual
    • -
  • indiceActual
    • -
  • array
    • -
- -

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

- -
    -
  • {{jsxref("Array.prototype.reduceRight()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/reduce/index.md b/files/es/web/javascript/reference/global_objects/array/reduce/index.md new file mode 100644 index 00000000000000..e30f9a8c53672f --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/reduce/index.md @@ -0,0 +1,194 @@ +--- +title: Array.prototype.reduce() +slug: Web/JavaScript/Reference/Global_Objects/Array/Reduce +tags: + - Array + - ECMAScript 5 + - JavaScript + - Prototype + - Reduce + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce +original_slug: Web/JavaScript/Referencia/Objetos_globales/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. Valor Actual (`cur`) +3. Índice Actual (_`idx`_) +4. Array (_`src`_) + +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: + +- `valorAnterior` +- `valorActual` +- `indiceActual` +- `array` + +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`: + +```js +[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: + +```js +[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 + +> **Nota:** **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. + +```js +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` + +```js +var total = [0, 1, 2, 3].reduce(function(a, b){ return a + b; }); +// total == 6 +``` + +### Ejemplo: Integrar un `array` a partir de varios `arrays` + +```js +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 + +- {{jsxref("Array.prototype.reduceRight()")}} 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 deleted file mode 100644 index 80319eff4efae3..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/reduceright/index.html +++ /dev/null @@ -1,167 +0,0 @@ ---- -title: Array.prototype.reduceRight() -slug: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight -tags: - - Array - - ECMAScript5 - - JavaScript - - JavaScript 1.8 - - Method - - Prototype -translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("Array.prototype.reduce()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/reduceright/index.md b/files/es/web/javascript/reference/global_objects/array/reduceright/index.md new file mode 100644 index 00000000000000..85a0cc1ca24d7f --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/reduceright/index.md @@ -0,0 +1,168 @@ +--- +title: Array.prototype.reduceRight() +slug: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight +tags: + - Array + - ECMAScript5 + - JavaScript + - JavaScript 1.8 + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight +original_slug: Web/JavaScript/Referencia/Objetos_globales/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: + +```js +.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: + +```js +[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: + +```js +[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. + +```js +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 + +```js +var total = [0, 1, 2, 3].reduceRight(function(a, b) { return a + b; }); +// total == 6 +``` + +### Ejemplo: Integrar un array a partir de varios arrays + +```js +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 + +- {{jsxref("Array.prototype.reduce()")}} 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 deleted file mode 100644 index 0705d7c2955dff..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/reverse/index.html +++ /dev/null @@ -1,89 +0,0 @@ ---- -title: Array.prototype.reverse() -slug: Web/JavaScript/Reference/Global_Objects/Array/reverse -tags: - - Array - - JavaScript - - Prototipo - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/Array/reverse -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

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

- -
    -
  • {{jsxref("Array.prototype.join()")}}
    • -
  • {{jsxref("Array.prototype.sort()")}}
    • -
  • {{jsxref("TypedArray.prototype.reverse()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/reverse/index.md b/files/es/web/javascript/reference/global_objects/array/reverse/index.md new file mode 100644 index 00000000000000..77d19fc562a6e7 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/reverse/index.md @@ -0,0 +1,64 @@ +--- +title: Array.prototype.reverse() +slug: Web/JavaScript/Reference/Global_Objects/Array/reverse +tags: + - Array + - JavaScript + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/reverse +original_slug: Web/JavaScript/Referencia/Objetos_globales/Array/reverse +--- +{{JSRef}} + +El método **`reverse()`** invierte el orden de los elementos de un array _[in place](https://en.wikipedia.org/wiki/In-place_algorithm)_. El primer elemento pasa a ser el último y el último pasa a ser el primero. + +{{EmbedInteractiveExample("pages/js/array-reverse.html")}} + +## Sintaxis + + 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. + +```js +const a = [1, 2, 3]; + +console.log(a); // [1, 2, 3] + +a.reverse(); + +console.log(a); // [3, 2, 1] +``` + +## Especificaciones + +| Especificación | Estado | Comentario | +| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | --------------------------------------------------- | +| {{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')}} | | + +## Compatibilidad en navegadores + +{{Compat("javascript.builtins.Array.reverse")}} + +## Ver también + +- {{jsxref("Array.prototype.join()")}} +- {{jsxref("Array.prototype.sort()")}} +- {{jsxref("TypedArray.prototype.reverse()")}} 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 deleted file mode 100644 index fa4edcdcef8ea4..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/shift/index.html +++ /dev/null @@ -1,77 +0,0 @@ ---- -title: Array.prototype.shift() -slug: Web/JavaScript/Reference/Global_Objects/Array/shift -translation_of: Web/JavaScript/Reference/Global_Objects/Array/shift -original_slug: Web/JavaScript/Referencia/Objetos_globales/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')}}
- - - -{{Compat("javascript.builtins.Array.shift")}} - -

Ver también

- -
    -
  • {{jsxref("Array.prototype.push()")}}
    • -
  • {{jsxref("Array.prototype.pop()")}}
    • -
  • {{jsxref("Array.prototype.unshift()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/shift/index.md b/files/es/web/javascript/reference/global_objects/array/shift/index.md new file mode 100644 index 00000000000000..e46912b0d0e5fa --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/shift/index.md @@ -0,0 +1,58 @@ +--- +title: Array.prototype.shift() +slug: Web/JavaScript/Reference/Global_Objects/Array/shift +translation_of: Web/JavaScript/Reference/Global_Objects/Array/shift +original_slug: Web/JavaScript/Referencia/Objetos_globales/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: + +```js +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 + +| Specification | Status | Comment | +| ---------------------------------------------------------------------------------------------------- | ------------------------ | --------------------------------------------------- | +| {{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')}} | | + +## Navegadores compatibles + +{{Compat("javascript.builtins.Array.shift")}} + +## Ver también + +- {{jsxref("Array.prototype.push()")}} +- {{jsxref("Array.prototype.pop()")}} +- {{jsxref("Array.prototype.unshift()")}} 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 deleted file mode 100644 index 840e8831d0bee8..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/some/index.html +++ /dev/null @@ -1,205 +0,0 @@ ---- -title: Array.prototype.some() -slug: Web/JavaScript/Reference/Global_Objects/Array/some -tags: - - Array - - ECMAScript5 - - JavaScript - - Prototipo - - Referencia - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/Array/some -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("Array.prototype.forEach()")}}
    • -
  • {{jsxref("Array.prototype.every()")}}
    • -
  • {{jsxref("Array.prototype.find()")}}
    • -
  • {{jsxref("TypedArray.prototype.some()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/some/index.md b/files/es/web/javascript/reference/global_objects/array/some/index.md new file mode 100644 index 00000000000000..57a60e55c21952 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/some/index.md @@ -0,0 +1,181 @@ +--- +title: Array.prototype.some() +slug: Web/JavaScript/Reference/Global_Objects/Array/some +tags: + - Array + - ECMAScript5 + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/some +original_slug: Web/JavaScript/Referencia/Objetos_globales/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](/es/docs/Web/JavaScript/Reference/Operators/this). + +`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. + +```js +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)](/es/docs/Web/JavaScript/Reference/Functions/Arrow_functions) brindan una sintáxis más corta para el mismo test. + +```js +[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: + +```js +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 + +```js +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 + +```js +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()")}}. + +```js +// 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ón | Estado | Comentario | +| ---------------------------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------------- | +| {{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 + +- {{jsxref("Array.prototype.forEach()")}} +- {{jsxref("Array.prototype.every()")}} +- {{jsxref("Array.prototype.find()")}} +- {{jsxref("TypedArray.prototype.some()")}} 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 deleted file mode 100644 index ba537f22cd218f..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/sort/index.html +++ /dev/null @@ -1,254 +0,0 @@ ---- -title: Array.prototype.sort() -slug: Web/JavaScript/Reference/Global_Objects/Array/sort -tags: - - Array - - JavaScript - - Método(2) - - Prototipo -translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort -original_slug: Web/JavaScript/Referencia/Objetos_globales/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:

- -
    -
  • Si compareFunction(a, b) es menor que 0, se sitúa a en un indice menor que b. Es decir, a viene primero.
    • -
  • Si compareFunction(a, b) retorna 0, se deja a y b sin cambios entre ellos, pero ordenados con respecto a todos los elementos diferentes. Nota: el estandar ECMAscript no garantiza este comportamiento, por esto no todos los navegadores (p.ej. Mozilla en versiones que datan hasta el 2003) respetan esto.
    • -
  • Si compareFunction(a, b) es mayor que 0, se sitúa b en un indice menor que a.
    • -
  • compareFunction(a, b) siempre debe retornar el mismo valor dado un par especifico de elementos a y b como sus argumentos. Si se retornan resultados inconsistentes entonces el orden de ordenamiento es indefinido.
    • -
- -

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

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

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

- -
    -
  • {{jsxref("Array.prototype.reverse()")}}
    • -
  • {{jsxref("String.prototype.localeCompare()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/sort/index.md b/files/es/web/javascript/reference/global_objects/array/sort/index.md new file mode 100644 index 00000000000000..d89ee3abcebb39 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/sort/index.md @@ -0,0 +1,243 @@ +--- +title: Array.prototype.sort() +slug: Web/JavaScript/Reference/Global_Objects/Array/sort +tags: + - Array + - JavaScript + - Método(2) + - Prototipo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort +original_slug: Web/JavaScript/Referencia/Objetos_globales/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](https://en.wikipedia.org/wiki/Sorting_algorithm#Stability). El modo de ordenación por defecto responde a la posición del valor del string de acuerdo a su valor [Unicode](https://es.wikipedia.org/wiki/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](/es/docs/Web/JavaScript/Guide/Values,_variables,_and_literals#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". + +```js +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: + +- Si `compareFunction(a, b)` es menor que 0, se sitúa `a` en un indice menor que `b`. Es decir, `a` viene primero. +- Si `compareFunction(a, b)` retorna 0, se deja `a` y `b` sin cambios entre ellos, pero ordenados con respecto a todos los elementos diferentes. Nota: el estandar ECMAscript no garantiza este comportamiento, por esto no todos los navegadores (p.ej. Mozilla en versiones que datan hasta el 2003) respetan esto. +- Si `compareFunction(a, b)` es mayor que 0, se sitúa `b` en un indice menor que `a`. +- `compareFunction(a, b)` siempre debe retornar el mismo valor dado un par especifico de elementos a y b como sus argumentos. Si se retornan resultados inconsistentes entonces el orden de ordenamiento es indefinido. + +Entonces, la función de comparación tiene la siguiente forma: + +```js +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: + +```js +function compareNumbers(a, b) { + return a - b; +} +``` + +El metodo `sort` puede ser usado convenientemente con {{jsxref("Operators/function", "function expressions", "", 1)}} (y [closures](/es/docs/Web/JavaScript/Guide/Closures)): + +```js +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. + +```js +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: + +```js +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: + +```js +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: + +```js +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: + +```js +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](/es/docs/Web/JavaScript/Referencia/Funciones/Arrow_functions): + +```js +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/docs/Web/JavaScript/Referencia/Objetos_globales/Array/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. + +```js +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. + +```js +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](/es/docs/Web/JavaScript/Reference/Global_Objects/Array/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. + +```js +// 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ón | Estado | Comentario | +| ------------------------------------------------------------------------------------------------ | ------------------------ | ------------------- | +| ECMAScript 1st Edition | Standard | Definicióñ 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 + +{{Compat("javascript.builtins.Array.sort")}} + +## 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 y envíanos un pull request. + +## Ver también + +- {{jsxref("Array.prototype.reverse()")}} +- {{jsxref("String.prototype.localeCompare()")}} 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 deleted file mode 100644 index 8044eaf9c70c87..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/tolocalestring/index.html +++ /dev/null @@ -1,178 +0,0 @@ ---- -title: Array.prototype.toLocaleString() -slug: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString -translation_of: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString -original_slug: Web/JavaScript/Referencia/Objetos_globales/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.

- -
    -
  • Object: {{jsxref("Object.prototype.toLocaleString()")}}
    • -
  • Number: {{jsxref("Number.prototype.toLocaleString()")}}
    • -
  • Date: {{jsxref("Date.prototype.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

- -
    -
  • {{jsxref("Array.prototype.toString()")}}
    • -
  • {{jsxref("Intl")}}
    • -
  • {{jsxref("Object.prototype.toLocaleString()")}}
    • -
  • {{jsxref("Number.prototype.toLocaleString()")}}
    • -
  • {{jsxref("Date.prototype.toLocaleString()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/tolocalestring/index.md b/files/es/web/javascript/reference/global_objects/array/tolocalestring/index.md new file mode 100644 index 00000000000000..829f18e806c308 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/tolocalestring/index.md @@ -0,0 +1,154 @@ +--- +title: Array.prototype.toLocaleString() +slug: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString +original_slug: Web/JavaScript/Referencia/Objetos_globales/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`. + +- `Object`: {{jsxref("Object.prototype.toLocaleString()")}} +- `Number`: {{jsxref("Number.prototype.toLocaleString()")}} +- `Date`: {{jsxref("Date.prototype.toLocaleString()")}} + +Siempre mostrar la moneda para los strings y números en el array `precios`: + +```js +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 + +```js +// 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`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty), es mejor no utilizar los métodos `Array.prototype`, ya que no se pueden hacer no-enumerables. + +## Especificaciones + +| Especificación | Estado | Comentario | +| ---------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ------------------------------------------------------- | +| {{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 + +- {{jsxref("Array.prototype.toString()")}} +- {{jsxref("Intl")}} +- {{jsxref("Object.prototype.toLocaleString()")}} +- {{jsxref("Number.prototype.toLocaleString()")}} +- {{jsxref("Date.prototype.toLocaleString()")}} 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 deleted file mode 100644 index 82cc122e0ed8d0..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/tostring/index.html +++ /dev/null @@ -1,79 +0,0 @@ ---- -title: Array.prototype.toString() -slug: Web/JavaScript/Reference/Global_Objects/Array/toString -tags: - - Array - - JavaScript - - Prototipo - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/Array/toString -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("Array.prototype.join()")}}
    • -
  • {{jsxref("Object.prototype.toSource()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/tostring/index.md b/files/es/web/javascript/reference/global_objects/array/tostring/index.md new file mode 100644 index 00000000000000..95c95698db62de --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/tostring/index.md @@ -0,0 +1,54 @@ +--- +title: Array.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Array/toString +tags: + - Array + - JavaScript + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toString +original_slug: Web/JavaScript/Referencia/Objetos_globales/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ón | Estado | Comentario | +| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------------- | +| {{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 + +- {{jsxref("Array.prototype.join()")}} +- {{jsxref("Object.prototype.toSource()")}} 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 deleted file mode 100644 index f25a432613135f..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/unshift/index.html +++ /dev/null @@ -1,101 +0,0 @@ ---- -title: Array.prototype.unshift() -slug: Web/JavaScript/Reference/Global_Objects/Array/unshift -tags: - - Array - - JavaScript - - Prototipo - - Referencia - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/Array/unshift -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("Array.prototype.push()")}}
    • -
  • {{jsxref("Array.prototype.pop()")}}
    • -
  • {{jsxref("Array.prototype.shift()")}}
    • -
  • {{jsxref("Array.prototype.concat()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/unshift/index.md b/files/es/web/javascript/reference/global_objects/array/unshift/index.md new file mode 100644 index 00000000000000..a3ea5d2d588a28 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/unshift/index.md @@ -0,0 +1,71 @@ +--- +title: Array.prototype.unshift() +slug: Web/JavaScript/Reference/Global_Objects/Array/unshift +tags: + - Array + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/unshift +original_slug: Web/JavaScript/Referencia/Objetos_globales/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 + +```js +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ón | Status | Comentario | +| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------------------------- | +| {{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 + +- {{jsxref("Array.prototype.push()")}} +- {{jsxref("Array.prototype.pop()")}} +- {{jsxref("Array.prototype.shift()")}} +- {{jsxref("Array.prototype.concat()")}} 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 deleted file mode 100644 index a0cd08b90afc56..00000000000000 --- a/files/es/web/javascript/reference/global_objects/array/values/index.html +++ /dev/null @@ -1,83 +0,0 @@ ---- -title: Array.prototype.values() -slug: Web/JavaScript/Reference/Global_Objects/Array/values -tags: - - Array - - ECMAScript 2015 - - Iterador - - JavaScript - - Prototipo - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/Array/values -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("Array.prototype.keys()")}}
    • -
  • {{jsxref("Array.prototype.entries()")}}
    • -
  • {{jsxref("Array.prototype.forEach()")}}
    • -
  • {{jsxref("Array.prototype.every()")}}
    • -
  • {{jsxref("Array.prototype.some()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/array/values/index.md b/files/es/web/javascript/reference/global_objects/array/values/index.md new file mode 100644 index 00000000000000..b93128ef828633 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/array/values/index.md @@ -0,0 +1,67 @@ +--- +title: Array.prototype.values() +slug: Web/JavaScript/Reference/Global_Objects/Array/values +tags: + - Array + - ECMAScript 2015 + - Iterador + - JavaScript + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/values +original_slug: Web/JavaScript/Referencia/Objetos_globales/Array/values +--- +{{JSRef}} + +El método **`values()`** devuelve un nuevo objeto **`Array Iterator`** que contiene los valores para cada índice del array. + +```js +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` + +```js +var arr = ['w', 'y', 'k', 'o', 'p']; +var iterador = arr.values(); + +for (let letra of iterador) { + console.log(letra); +} +``` + +## Especificaciones + +| Especificación | Estado | Comentario | +| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ------------------- | +| {{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 + +- {{jsxref("Array.prototype.keys()")}} +- {{jsxref("Array.prototype.entries()")}} +- {{jsxref("Array.prototype.forEach()")}} +- {{jsxref("Array.prototype.every()")}} +- {{jsxref("Array.prototype.some()")}}