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

El **`Symbol.toPrimitive`** es un símbolo que especifica una propiedad con valor de función que se llama para convertir un objeto en un valor primitivo correspondiente.

Pruébalo
--------

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

Con la ayuda de la propiedad `Symbol.toPrimitive` (utilizada como valor de la función), se puede convertir un objeto en un valor primitivo. La función se llama con un argumento de cadena `hint`, que especifica el tipo preferido del valor primitivo resultante. El argumento `hint` puede ser uno de los siguientes: "`number`", "`string`" y "`default`".

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

Ejemplos
--------

### Modificar los valores primitivos convertidos desde un objeto

El siguiente ejemplo describe cómo la propiedad `Symbol.toPrimitive` puede modificar el valor primitivo convertido desde un objeto.


```js
// Un objeto sin la propiedad Symbol.toPrimitive.
const obj1 = {};
console.log(+obj1); // NaN
console.log(`${obj1}`); // "[object Object]"
console.log(obj1 + ""); // "[object Object]"

// Un objeto con la propiedad Symbol.toPrimitive.
const obj2 = {
  [Symbol.toPrimitive](hint) {
    if (hint === "number") {
      return 10;
    }
    if (hint === "string") {
      return "hello";
    }
    return true;
  },
};
console.log(+obj2); // 10 — hint es "number"
console.log(`${obj2}`); // "hello" — hint es "string"
console.log(obj2 + ""); // "true" — hint es "default"
```

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

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

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

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

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

* `Date.prototype[@@toPrimitive]` (en-US)
* `Symbol.prototype[@@toPrimitive]`
* `Object.prototype.toString()`
* `Object.prototype.valueOf()`
Symbol() constructor
====================

El constructor `Symbol()` devuelve un valor de tipo **symbol**, pero está incompleto como constructor porque no soporta la sintaxis "`new Symbol()`" y no está pensado para ser heredado. Puede utilizarse como valor de una cláusula `extends` de una definición de `class`, pero una llamada a `super` provocará una excepción.

Pruébalo
--------

Sintaxis
--------


```js
Symbol();
Symbol(description);
```

### Parámetros

`description` Opcional

Una cadena. Una descripción del símbolo que puede utilizarse para la depuración pero no para acceder al símbolo en sí.

Ejemplos
--------

### Crear símbolos

Para crear un nuevo símbolo primitivo, se escribe `Symbol()` con una cadena opcional como descripción:


```js
let sym1 = Symbol();
let sym2 = Symbol("foo");
let sym3 = Symbol("foo");
```


El código anterior crea tres nuevos símbolos. Tenga en cuenta que `Symbol("foo")` no coacciona la cadena `"foo"` en un símbolo. Cada vez crea un nuevo símbolo:


```js
Symbol("foo") === Symbol("foo"); // false
```

### new Symbol()

La siguiente sintaxis con el operador `new` lanzará un `TypeError`:


```js
let sym = new Symbol(); // TypeError
```


Esto evita que los autores creen un objeto envolvente explícito `Symbol` en lugar de un nuevo valor de símbolo y podría ser sorprendente ya que la creación de objetos envolventes explícitos alrededor de tipos de datos primitivos es generalmente posible (por ejemplo, `new Boolean`, `new String` y `new Number`).

Si realmente quieres crear un objeto envolvente `Symbol`, puedes utilizar la función `Object()`:


```js
let sym = Symbol("foo");
let symObj = Object(sym);
typeof sym; // => "symbol"
typeof symObj; // => "object"
```

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

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

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` en `core-js`
* Glosario: Tipo de datos de los símbolos
Symbol.keyFor()
===============

El método **`Symbol.keyFor(sym)`** recupera la clave de símbolo compartida del símbolo pasado como argumento desde el registro global de símbolos.

Pruébalo
--------

Sintaxis
--------


```js
Symbol.keyFor(sym);
```

### Parámetros

`sym`

Symbol, obligatoria. El símbolo del que se desea encontrar la clave.

### Valor de retorno

Una cadena que representa la clave del símbolo pasado como parámetro si es encontrado en el registro global de símbolos; En caso contrario, `undefined`.

Ejemplos
--------

### Usando keyFor()


```js
const globalSym = Symbol.for("foo"); // crea un nuevo símbolo global
Symbol.keyFor(globalSym); // retorna: "foo"
const localSym = Symbol();
Symbol.keyFor(localSym); // retorna: undefined
// los símbolos de ámbito no son registrados
// en el registro global de símbolos.
Symbol.keyFor(Symbol.iterator); // retorna: undefined
```

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

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

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

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

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

* `Symbol.for()`
Symbol.toStringTag
==================

El símbolo conocido como **`Symbol.toStringTag`** es una propiedad con valor de cadena que se utiliza en la creación de la descripción de cadena por defecto de un objeto. Se accede a ella internamente mediante el método `Object.prototype.toString()`.

Pruébalo
--------

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

Ejemplos
--------

### Etiquetas por defecto


```js
Object.prototype.toString.call("foo"); // "[object String]"
Object.prototype.toString.call([1, 2]); // "[object Array]"
Object.prototype.toString.call(3); // "[object Number]"
Object.prototype.toString.call(true); // "[object Boolean]"
Object.prototype.toString.call(undefined); // "[object Undefined]"
Object.prototype.toString.call(null); // "[object Null]"
// ... and more
```

### Símbolos toStringTag integrados


```js
Object.prototype.toString.call(new Map()); // "[object Map]"
Object.prototype.toString.call(function\* () {}); // "[object GeneratorFunction]"
Object.prototype.toString.call(Promise.resolve()); // "[object Promise]"
// ... and more
```

### Clases personalizadas por defecto en la etiqueta objeto

Al crear su propia clase, JavaScript utiliza por defecto la etiqueta "Object":


```js
class ValidatorClass {}

Object.prototype.toString.call(new ValidatorClass()); // "[object Object]"
```

### Etiqueta personalizada con toStringTag

Ahora, con la ayuda de `toStringTag`, puede establecer su propia etiqueta personalizada:


```js
class ValidatorClass {
  get [Symbol.toStringTag]() {
    return "Validator";
  }
}

Object.prototype.toString.call(new ValidatorClass()); // "[object Validator]"
```

### toStringTag disponible en todos los objetos del prototipo DOM

Debido a un cambio en las especificaciones de WebIDL a mediados de 2020, los navegadores están añadiendo una propiedad `Symbol.toStringTag` a todos los objetos prototipo del DOM. Por ejemplo, para acceder a la propiedad `Symbol.toStringTag` de `HTMLButtonElement` (en-US):


```js
let test = document.createElement("button");
test.toString(); // Devuelve [object HTMLButtonElement]
test[Symbol.toStringTag]; // Devuelve HTMLButtonElement
```

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

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

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.toStringTag` en `core-js`
* `Object.prototype.toString()`
Symbol.prototype.toString()
===========================

El método **`toString()`** devuelve una cadena que representa el objeto `Symbol` especificado.

Pruébalo
--------

Sintaxis
--------


```js
toString();
```

### Valor de retorno

Una cadena que representa el objeto `Symbol` especificado.

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

El objeto `Symbol` reemplaza el método `toString` del objeto `Object`; no hereda `Object.prototype.toString()`. Para los objetos `Symbol`, el método `toString` devuelve una representación de cadena del objeto.

### Sin concatenación de cadenas

Aunque se puede llamar a `toString()` en los símbolos, no se puede utilizar la concatenación de cadenas con ellos:


```js
Symbol("foo") + "bar"; // TypeError: No se puede convertir el símbolo en cadena
```

Ejemplos
--------

### Usando toString()


```js
Symbol("desc").toString(); // "Symbol(desc)"

// símbolos conocidos
Symbol.iterator.toString(); // "Symbol(Symbol.iterator)

// símbolos globales
Symbol.for("foo").toString(); // "Symbol(foo)"
```

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

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

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

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

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

* `Object.prototype.toString()`
Symbol.hasInstance
==================

El símbolo conocido como **`Symbol.hasInstance`** se utiliza para determinar si un objeto constructor reconoce un objeto como su instancia. El comportamiento del operador `instanceof` puede personalizarse mediante este símbolo.

Pruébalo
--------

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

Ejemplos
--------

### Comportamiento de instanceof personalizado

Podrías personalizar el comportamiento de `instanceof` de la siguiente manera, por ejemplo:


```js
class MyArray {
  static [Symbol.hasInstance](instance) {
    return Array.isArray(instance);
  }
}
console.log([] instanceof MyArray); // true
```



```js
function MyArray() {}
Object.defineProperty(MyArray, Symbol.hasInstance, {
  value: function (instance) {
    return Array.isArray(instance);
  },
});
console.log([] instanceof MyArray); // true
```

### Comprobación de la instancia de un objeto

De la misma manera que se puede comprobar si un objeto es una instancia de una clase utilizando la palabra clave `instanceof`, también podemos utilizar `Symbol.hasInstance` para dichas comprobaciones.


```js
class Animal {
  constructor() {}
}

const cat = new Animal();

console.log(Animal[Symbol.hasInstance](cat)); // true
```

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

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

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

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

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

* `instanceof`
Symbol.match
============

El símbolo conocido como **`Symbol.match`** especifica la coincidencia de una expresión regular con una cadena. Esta función es llamada por el método `String.prototype.match()`.

Pruébalo
--------

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

Esta función también se utiliza para identificar si los objetos tienen el comportamiento de las expresiones regulares. Por ejemplo, los métodos `String.prototype.startsWith()`, `String.prototype.endsWith()` y `String.prototype.includes()`, comprueban si su primer argumento es una expresión regular y lanzarán un `TypeError` si lo son. Ahora bien, si el símbolo `match` se establece como `false` (o un valor Falsy (en-US)), indica que el objeto no está destinado a ser utilizado como un objeto de expresión regular.

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

Ejemplos
--------

### Desactivar la comprobación de `isRegExp`

El siguiente código lanzará un `TypeError`:


```js
"/bar/".startsWith(/bar/);

// Lanza TypeError, ya que /bar/ es una expresión regular
// y Symbol.match no se modifica.
```


Sin embargo, si establece `Symbol.match` a `false`, la comprobación `isRegExp` (que utiliza la propiedad `match`) indicará que el objeto no es un objeto de expresión regular. Los métodos `startsWith` y `endsWith` no lanzarán un `TypeError` como consecuencia.


```js
const re = /foo/;
re[Symbol.match] = false;
"/foo/".startsWith(re); // true
"/baz/".endsWith(re); // false
```

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

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

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.match` en `core-js`
* `Symbol.replace`
* `Symbol.search`
* `Symbol.split`
* `RegExp.prototype[@@match]()` (en-US)
Symbol.search
=============

El símbolo conocido como **`Symbol.search`** especifica el método que devuelve el índice dentro de una cadena que coincide con la expresión regular. Esta función es llamada por el método `String.prototype.search()`.

Para más información, véase `RegExp.prototype[@@search]()` (en-US) y `String.prototype.search()`.

Pruébalo
--------

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

Ejemplos
--------

### Búsqueda de cadenas personalizadas


```js
class caseInsensitiveSearch {
  constructor(value) {
    this.value = value.toLowerCase();
  }
  [Symbol.search](string) {
    return string.toLowerCase().indexOf(this.value);
  }
}

console.log("foobar".search(new caseInsensitiveSearch("BaR")));
// resultado esperado: 3
```

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

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

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.search` en `core-js`
* `Symbol.match`
* `Symbol.replace`
* `Symbol.split`
* `RegExp.prototype[@@search]()` (en-US)
Symbol.replace
==============

El símbolo conocido como **`Symbol.replace`** especifica el método que reemplaza las subcadenas coincidentes de una cadena. Esta función es llamada por el método `String.prototype.replace()`.

Para más información, consulte `RegExp.prototype[@@replace]()` (en-US) y `String.prototype.replace()`.

Pruébalo
--------

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

Ejemplos
--------

### Usando Symbol.replace


```js
class CustomReplacer {
  constructor(value) {
    this.value = value;
  }
  [Symbol.replace](string) {
    return string.replace(this.value, "#!@?");
  }
}

console.log("football".replace(new CustomReplacer("foo")));
// salida esperada: "#!@?tball"
```

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

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

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.replace` en `core-js`
* `Symbol.match`
* `Symbol.search`
* `Symbol.split`
* `RegExp.prototype[@@replace]()` (en-US)
Symbol.prototype[@@toPrimitive]
===============================

El método **`[@@toPrimitive]()`** convierte un objeto Symbol en un valor primitivo.

Sintaxis
--------


```js
Symbol()[Symbol.toPrimitive](hint);
```

### Valor de retorno

El valor primitivo del objeto `Symbol` especificado.

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

El método `[@@toPrimitive]()` de `Symbol` devuelve el valor primitivo de un objeto Symbol como un tipo de datos Symbol. El argumento `hint` no se utiliza.

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

Ejemplos
--------

### Uso de @@toPrimitive


```js
const sym = Symbol("ejemplo");
sym === sym[Symbol.toPrimitive](); // true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.prototype-@@toprimitive |

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

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

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

* `Symbol.toPrimitive`
Symbol.asyncIterator
====================

El símbolo conocido **`Symbol.asyncIterator`** especifica el AsyncIterator por defecto para un objeto. Si se establece esta propiedad en un objeto, es un iterable asíncrono y puede utilizarse en un bucle `for await...of`.

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

El símbolo `Symbol.asyncIterator` es un símbolo incorporado que se utiliza para acceder al método `@@asyncIterator` de un objeto. Para que un objeto sea iterable asíncrono, debe tener una clave `Symbol.asyncIterator`.

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

Ejemplos
--------

### Iterables asíncronos definidos por el usuario

Puedes definir tu propio iterable asíncrono estableciendo la propiedad `[Symbol.asyncIterator]` en un objeto.


```js
const myAsyncIterable = {
  async \*[Symbol.asyncIterator]() {
    yield "hello";
    yield "async";
    yield "iteration!";
  },
};

(async () => {
  for await (const x of myAsyncIterable) {
    console.log(x);
    // resultado esperado:
    // "hello"
    // "async"
    // "iteration!"
  }
})();
```


Cuando crees una API, recuerda que los iterables asíncronos están diseñados para representar algo *iterable* — como un flujo de datos o una lista —, no para reemplazar completamente las devoluciones de llamada y los eventos en la mayoría de las situaciones.

### Iterables asíncronos incorporados

Actualmente no hay objetos JavaScript incorporados que tengan la clave `[Symbol.asyncIterator]` establecida por defecto. Sin embargo, los flujos de WHATWG están preparados para ser el primer objeto incorporado que sea iterable asíncrono, con `[Symbol.asyncIterator]` recientemente aterrizando en la especificación.

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

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

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

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

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

* Protocolos de iteración
* for await... of
Symbol.for()
============

El método **`Symbol.for(key)`** busca los símbolos existentes en un registro de símbolos en tiempo de ejecución con la clave dada y lo devuelve si lo encuentra. En caso contrario, se crea un nuevo símbolo en el registro global de símbolos con esta clave.

Pruébalo
--------

Sintaxis
--------


```js
Symbol.for(key);
```

### Parametros

`key`

String, obligatoria. La clave del símbolo (y también se utiliza para la descripción del símbolo).

### Valor de retorno

Un símbolo existente con la clave dada si se encuentra; en caso contrario, se crea un nuevo símbolo y se devuelve.

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

A diferencia de `Symbol()`, la función `Symbol.for()` crea un símbolo disponible en una lista global de registro de símbolos. Además, `Symbol.for()` no crea necesariamente un nuevo símbolo en cada llamada, sino que comprueba primero si un símbolo con la `key` dada ya está presente en el registro. En ese caso, se devuelve ese símbolo. Si no se encuentra ningún símbolo con la clave dada, `Symbol.for()` creará un nuevo símbolo global.

### Registro mundial de símbolos

El registro global de símbolos es una lista con la siguiente estructura de registros y se inicializa vacía:

| Nombre del campo | Valor |
| --- | --- |
| [[key]] | Una clave de cadena utilizada para identificar un símbolo. |
| [[symbol]] | Un símbolo que se almacena globalmente. |

Ejemplos
--------

### Uso de Symbol.for()


```js
Symbol.for("foo"); // crear un nuevo símbolo global
Symbol.for("foo"); // obtener el símbolo ya creado

// El mismo símbolo global, pero no localmente
Symbol.for("bar") === Symbol.for("bar"); // true
Symbol("bar") === Symbol("bar"); // false

// La clave también se utiliza como descripción
const sym = Symbol.for("mario");
sym.toString(); // "Symbol(mario)"
```


Para evitar conflictos de nombres con sus claves de símbolos globales y otros símbolos globales (del código de la biblioteca), puede ser una buena idea poner un prefijo a sus símbolos:


```js
Symbol.for("mdn.foo");
Symbol.for("mdn.bar");
```

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

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

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

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

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

* `Symbol.keyFor()`
Symbol.iterator
===============

El símbolo conocido como **`Symbol.iterator`** especifica el iterador por defecto para un objeto. Utilizado por `for...of`.

Pruébalo
--------

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

Siempre que un objeto necesite ser iterado (como al principio de un bucle `for..of`), se llama a su método `@@iterator` sin argumentos, y el **iterador** devuelto se utiliza para obtener los valores a iterar.

Algunos tipos incorporados tienen un comportamiento de iteración por defecto, mientras que otros tipos (como `Object`) no lo tienen. Los tipos incorporados con un método `@@iterador` son:

* `Array.prototype[@@iterator]()`
* `TypedArray.prototype[@@iterator]()` (en-US)
* `String.prototype[@@iterator]()` (en-US)
* `Map.prototype[@@iterator]()` (en-US)
* `Set.prototype[@@iterator]()`

Véase también Protocolos de iteración para más información.

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

Ejemplos
--------

### Iterables definidos por el usuario

Podemos hacer nuestros propios iterables así:


```js
const myIterable = {};
myIterable[Symbol.iterator] = function\* () {
  yield 1;
  yield 2;
  yield 3;
};
[...myIterable]; // [1, 2, 3]
```


O los iterables pueden ser definidos directamente dentro de una clase u objeto usando una propiedad computada (en-US):


```js
class Foo {
  \*[Symbol.iterator]() {
    yield 1;
    yield 2;
    yield 3;
  }
}

const someObj = {
  \*[Symbol.iterator]() {
    yield "a";
    yield "b";
  },
};

console.log(...new Foo()); // 1, 2, 3
console.log(...someObj); // 'a', 'b'
```

### Iterables formados incorrectamente

Si el método `@@iterator` de un iterable no devuelve un objeto iterador, entonces es un iterable formado incorrectamente. Si se utiliza como tal, es probable que se produzcan excepciones en tiempo de ejecución o un comportamiento erróneo:


```js
const nonWellFormedIterable = {}
nonWellFormedIterable[Symbol.iterator] = () => 1
[...nonWellFormedIterable] // TypeError: [] no es una función
```

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

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

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.iterator` en `core-js`
* Protocolos de iteración
* `Array.prototype[@@iterator]()`
* `TypedArray.prototype[@@iterator]()` (en-US)
* `String.prototype[@@iterator]()` (en-US)
* `Map.prototype[@@iterator]()` (en-US)
* `Set.prototype[@@iterator]()`