recursal/MDN huggingface dataset:
Symbol.matchAll
===============

El símbolo conocido como **`Symbol.matchAll`** devuelve un iterador, que devuelve las coincidencias de la expresión regular con una cadena. Esta función es llamada por el método `String.prototype.matchAll()`.

Pruébalo
--------

Descripción
-----------

Este Symbol se utiliza para `String.prototype.matchAll()` y específicamente en `RegExp.prototype[@@matchAll]()` (en-US). Los dos ejemplos siguientes devuelven el mismo resultado:


```js
"abc".matchAll(/a/);

/a/[Symbol.matchAll]("abc");
```


Este método existe para personalizar el comportamiento de las coincidencias dentro de las subclases `RegExp`.

| Atributos de la propiedad `Symbol.matchAll` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | No |

Ejemplos
--------

### Usando Symbol.matchAll


```js
const str = "2016-01-02|2019-03-07";

const numbers = {
  \*[Symbol.matchAll](str) {
    for (const n of str.matchAll(/[0-9]+/g)) yield n[0];
  },
};

console.log(Array.from(str.matchAll(numbers)));
// Array ["2016", "01", "02", "2019", "03", "07"]
```


Ver `String.prototype.matchAll()` y `RegExp.prototype[@@matchAll]()` (en-US) para más ejemplos.

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.matchall |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Véase también
-------------

* Polyfill de `Symbol.matchAll` en `core-js`
* `String.prototype.matchAll()`
* `RegExp.prototype[@@matchAll]()` (en-US)
Symbol.prototype.valueOf()
==========================

El método **`valueOf()`** devuelve el valor primitivo de un objeto Symbol.

Sintaxis
--------


```js
valueOf();
```

### Valor de retorno

El valor primitivo del objeto `Symbol` especificado.

Descripción
-----------

El método `valueOf()` de `Symbol` devuelve el valor primitivo de un objeto Symbol como un tipo de datos Symbol.

JavaScript llama al método `valueOf()` para convertir un objeto en un valor primitivo. Rara vez es necesario invocar el método `valueOf()`; JavaScript lo invoca automáticamente cuando encuentra un objeto del que se espera un valor primitivo.

Ejemplos
--------

### Usando valueOf()


```js
const sym = Symbol("example");
sym === sym.valueOf(); // true
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.prototype.valueof |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Véase también
-------------

* `Object.prototype.valueOf()`
Array.prototype.fill()
======================

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.

Pruébalo
--------

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

Índice inicial, por defecto 0.

`end` Opcional

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.fill |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Array`
* `TypedArray.prototype.fill()` (en-US)
Array.prototype.join()
======================

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.

Pruébalo
--------

Sintaxis
--------
```

arr.join([separator])
```

### Parámetros

`separador` Opcional

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`), llamando a `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
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.join |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `String.prototype.split()`
* `Array.prototype.toString()`
* `TypedArray.prototype.join()` (en-US)
Array.prototype.toString()
==========================

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

Pruébalo
--------

Sintaxis
--------
```

arr.toString()
```

### Valor devuelto

Una cadena de caracteres representando los elementos del array.

Descripción
-----------

El objeto `Array` sustituye al método `toString` de `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.

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.tostring |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Vea también
-----------

* `Array.prototype.join()`
* `Object.prototype.toSource()`
Array.prototype.entries()
=========================

El método **`entries()`** retorna un nuevo objeto **`Array Iterator`** que contiene los pares clave/valor para cada índice de la matriz.Pruébalo
--------

Sintaxis
--------
```

arr.entries()
```

### Valor de retorno

Un nuevo objeto iterador `Array`.

Ejemplos
--------

### Usando un bucle 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
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.entries |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Array.prototype.keys()`
* `Array.prototype.values()`
* `Array.prototype.forEach()`
* `Array.prototype.every()`
* `Array.prototype.some()`
* for...of
* Protocolos de iteración
Array.isArray()
===============

El método **`Array.isArray()`** determina si el valor pasado es un `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 `Array`; en caso contrario, `false`.

Descripción
-----------

Si el objeto es un `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
--------


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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.isarray |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Vea también
-----------

* `Array`
Array.prototype.flatMap()
=========================

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since January 2020.

* Learn more
* See full compatibility
* Report feedback
**Experimental:** **Esta es una tecnología experimental**  
Comprueba la Tabla de compabilidad de navegadores cuidadosamente antes de usarla en producción.

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

Pruébalo
--------

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.

Sintaxis
--------
```

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

### Parámetros

`callback`

Función que produce un elemento de la nueva matriz, tomando tres argumentos:

`currentValue`

El elemento actual que se procesa en la matriz.

`index`Opcional

El índice del elemento actual que se procesa en la matriz.

`array`Opcional

La matriz `map` fue llamada.


`thisArg`Opcional

Valor para usar como `this` al ejecutar `callback`.

### Valor de retorno

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

Descripción
-----------

Ver `Array.prototype.map()` para una descripción detallada de la función de devolución de llamada. El método `flatMap` es idéntico a `map` seguido de una llamada a `flatten` (en-US) de profundidad 1.

Ejemplos
--------

### `map` y `flatMap`


```js
var arr1 = [1, 2, 3, 4];

arr1.map((x) => [x \* 2]);
// [[2], [4], [6], [8]]

arr1.flatMap((x) => [x \* 2]);
// [2, 4, 6, 8]

// solo un nivel es aplanado
arr1.flatMap((x) => [[x \* 2]]);
// [[2], [4], [6], [8]]
```


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

Alternativa
-----------

### `reduce` y `concat`


```js
var arr1 = [1, 2, 3, 4];

arr1.flatMap((x) => [x \* 2]);
// es equivalente a
arr1.reduce((acc, x) => acc.concat([x \* 2]), []);
// [2, 4, 6, 8]
```


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

Polyfill
--------

Este polyfill necesita Array.prototype.flat polyfill


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

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.flatmap |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Array.prototype.flatten()` (en-US)
* `Array.prototype.map()`
* `Array.prototype.reduce()`
* `Array.prototype.concat()`
Array.prototype[@@unscopables]
==============================

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` (en-US).

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 `Symbol.unscopables` para saber cómo configurar `unscopables` para sus propios objetos.

| Atributos de la propiedad `Array.prototype[@@unscopables]` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | Sí |

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype-@@unscopables |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Symbol.unscopables`
Array.prototype.keys()
======================

El método **`keys()`** devuelve un nuevo objeto **Array Iterator** que contiene las claves para cada indice en el arreglo.

Pruébalo
--------

Sintaxis
--------


```js
keys()
```

### Valor de retorno

Un nuevo objeto iterador `Array`.

Descripción
-----------

Cuando es usado en arreglos dispersos, el método `keys()` itera las ranuras vacias como si tuvieran el valor `undefined`

El método `keys()` es generico. Este solo espera el valor de `this` que tenga un propiedad `length` y propiedades con claves enteras.

Ejemplos
--------

### Usando keys() en arreglos dispersos

A diferencia de `Object.keys()`, el cual únicamente incluye las claves que realmente existen en el arreglo, el iterador `keys()` no ignora los huecos que representan las propiedades faltantes.


```js
const arr = ["a", , "c"];
const sparseKeys = Object.keys(arr);
const denseKeys = [...arr.keys()];
console.log(sparseKeys); // ['0', '2']
console.log(denseKeys); // [0, 1, 2]
```

### Llamando keys() en un objeto que no es un arreglo

El método `keys()` lee la propiedad `length` de `this` y luego produce todos los indices entre 0 y `length - 1`. Realmente no ocurre ningún acceso al índice.


```js
const arrayLike = {
  length: 3,
};
for (const entry of Array.prototype.keys.call(arrayLike)) {
  console.log(entry);
}
// 0
// 1
// 2
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.keys |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Véase también
-------------

* Polyfill de `Array.prototype.keys` en `core-js`
* `Array.prototype.values()`
* `Array.prototype.entries()`
* Protocolos de iteración
Array() constructor
===================

El constructor **`Array()`** se utiliza para crear objetos `Array`.

Sintaxis
--------


```js
new Array(element0, element1, /\* … ,\*/ elementN)
new Array(arrayLength)
Array(element0, element1, /\* … ,\*/ elementN)
Array(arrayLength)
```


**Nota:** `Array()` puede ser llamado con o sin `new`. Ambos crean una nueva instancia de `Array`.

### Parámetros

`elementN`

Un array de JavaScript se inicializa con los elementos dados, excepto en el caso donde se pase un solo argumento al constructor de `Array` y ese argumento sea un número (véase el parámetro `arrayLength` más abajo). Tenga en cuenta que este caso especial sólo se aplica a los arrays de JavaScript creadas con el constructor `Array`, no a los arrays literales, creadas con la sintaxis de corchetes.

`arrayLength`

Si el único argumento pasado al constructor de `Array` es un número entero entre 0 y 2^32 - 1 (incluido), éste devuelve un nuevo array de JavaScript con su propiedad de `length` establecida a ese número (**Nota:** esto implica un array de ranuras vacías de `arrayLength`, no ranuras con valores reales `undefined` — ver sparse arrays).

### Exceptions

`RangeError`

Se lanza si sólo hay un argumento (`arrayLength`) y su valor no está entre 0 y 2^32 - 1 (incluido).

Ejemplos
--------

### Notación literal de array

Los arrays pueden ser creados usando la notación literal:


```js
const fruits = ["Apple", "Banana"];
console.log(fruits.length); // 2
console.log(fruits[0]); // "Apple"
```

### Constructor de array con un solo parámetro

Los arrays pueden ser creados usando un constructor con un solo parámetro numérico. Un array con su propiedad `length` establecida a ese número y los elementos del array son ranuras vacías.


```js
const fruits = new Array(2);
console.log(fruits.length); // 2
console.log(fruits[0]); // undefined
```

### Constructor de array con múltiples parámetros

Si se pasa más de un argumento al constructor, se crea un nuevo `Array` con los elementos dados.


```js
const fruits = new Array("Apple", "Banana");
console.log(fruits.length); // 2
console.log(fruits[0]); // "Apple"
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array-constructor |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Véase también
-------------

* Clase `Array`
Array.of()
==========

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


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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.of |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Array`
* `Array.from()`
* `TypedArray.of()` (en-US)