recursal/MDN huggingface dataset:
Object.prototype.toString()
===========================

Resumen
-------

Devuelve una cadena que representa al objeto.

Sintaxis
--------

`toString()`

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

Todos los objetos tienen un método `toString` que se llama automáticamente cuando el objeto se representa como un valor de texto o cuando un objeto se referencia de tal manera que se espera una cadena. Por defecto, el método `toString` es heredado por todos los objetos que descienden de `Object`. Si este método no se sobreescribe en el objeto personalizado, `toString` devuelve `[objecttype]`, donde `type` es el tipo de objeto. El siguiente código ilustra esto:


```js
var objeto = new Object();
objeto.toString(); // Devuelve [object Object]
```

### Ejemplos

#### Sobreescribir el método por defecto `toString`

Puede crear una función que sea llamada en lugar del método predeterminado `toString`. El método `toString` no toma argumentos y debería devolver una cadena. El método `toString` que cree puede ser cualquier valor que quiera, pero será más útil si aporta información sobre el objeto.

El siguiente código define el tipo de objeto `Perro` y crea `elPerro`, un objeto de tipo `Perro`:


```js
function Perro(nombre, criadero, color, sexo) {
  this.nombre = nombre;
  this.criadero = criadero;
  this.color = color;
  this.sexo = sexo;
}

elPerro = new Perro("Gabby", "Laboratorio", "chocolate", "femenino");
```


Si llama al método `toString` en el objeto personalizado, devuelve el valor predeterminado heredado de `Object`:


```js
elPerro.toString(); //devuelve [object Object]
```


El siguiente código crea y asigna `perroToString` para sobreescribir el método predeterminado `toString`. Esta función genera una cadena que contiene nombre, criadero, color, y sexo del objeto, en la forma "`propiedad = valor;`".


```js
Perro.prototype.toString = function perroToString() {
  var retorno = `Perro ${this.nombre} es ${this.sexo} ${this.color} ${this.criadero}`;
  return retorno;
};
```


Con el código precedente en su lugar, cualquier vez que se use `elPerro` en un contexto de una cadena, JavaScript automáticamente llamará a la función `perroToString`, la cuál devuelve la siguiente cadena:
```

Perro Gabby es femenino chocolate Laboratorio
```

Vea También
-----------

* `Object.prototype.toSource()`
* `Object.prototype.valueOf()`
Object.prototype.toLocaleString()
=================================

El método **`toLocaleString()`** devuelve un string que representa a un objeto. Este método está pensado para ser redefinido en los objetos derivados, para los propósitos específicos de cada configuración regional.

Pruébalo
--------

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

objeto.toLocaleString()
```

### Valor de retorno

Un string que representa al objeto.

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

`Object`'s `toLocaleString` devuelve el resultado de llamar a `toString()`.

Se proporciona esta función para que los objetos dispongan de un método `toLocaleString` genérico, aunque puede que no todos la utilicen. Véase la lista siguiente.

### Objetos que redefinen `toLocaleString`

* `Array`: `Array.prototype.toLocaleString()`
* `Number`: `Number.prototype.toLocaleString()`
* `Date`: `Date.prototype.toLocaleString()`
* `TypedArray`: `TypedArray.prototype.toLocaleString()` (en-US)
* `BigInt` (en-US): `BigInt.prototype.toLocaleString()` (en-US)
Ejemplos
--------

### Redefinición de toLocaleString() en Array

En los objetos `Array` se puede utilizar `toLocaleString()` para imprimir los valores del *array* como un string, con indicadores opcionales de configuración regional (como símbolos de moneda) aplicados.

Por ejemplo:


```js
const unArray = [4, 7, 10];

let preciosEnEuros = unArray.toLocaleString("fr", {
  style: "currency",
  currency: "EUR",
});
// "4,00 €,7,00 €,10,00 €"
```

### Redefinición de toLocaleString() para Date

En los objetos `Date` se usa `toLocaleString()` para imprimir fechas en un formato adecuado a la configuración regional.

Por ejemplo:


```js
const unaFecha = new Date(Date.now());
// "2020-07-07T19:51:44.046Z"

let fechaAleman = unaFecha.toLocaleString("de");
// "7.7.2020, 21:55:22"

var fechaFrances = unaFecha.toLocaleString("fr");
//"07/07/2020 à 21:55:22"
```

### Redefinición de toLocaleString() para Number

En los objetos `Number` se usa `toLocaleString()` para imprimir números de forma adecuada a la configuración regional, p. ej. para usar los separadores de miles correctos.

Por ejemplo:


```js
const unNumero = 2901234564;
// "2901234564"

let numeroAleman = unNumero.toLocaleString("de");
// "2.901.234.564"

let numeroFrances = unNumero.toLocaleString("fr");
// "2 901 234 564"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.tolocalestring |

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

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

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

* `Object.prototype.toString()`
Object.isExtensible()
=====================

El método **`Object.isExtensible()`** determina si un objeto es extendible (si puede tener propiedades nuevas agregadas a éste).

Síntaxis
--------
```

Object.isExtensible(obj)
```

### Parametros

`obj`

El objeto a ser revisado.

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

Los objetos son extendibles por defecto: ellos pueden tener propiedades nuevas agregadas a ellos, y (en motores que soportan `Object.prototype.__proto__` 
Obsoleto
 la propiedad \_\_proto\_\_) pueden ser modificados. Un objeto puede ser marcado como no extendible usando `Object.preventExtensions()`, `Object.seal()`, o `Object.freeze()`.

Ejemplos
--------


```js
// Los Objetos nuevos son extendibles (por defecto).
var empty = {};
Object.isExtensible(empty); // === true

// ...pero eso puede cambiar.
Object.preventExtensions(empty);
Object.isExtensible(empty); // === false

// Objetos sellados por definición son no-extendibles.
var sealed = Object.seal({});
Object.isExtensible(sealed); // === false

// Objetos congelados también por definición son no-extendibles.
var frozen = Object.freeze({});
Object.isExtensible(frozen); // === false
```

Notas
-----

En ES5, si el argumento pasado a éste método no es un objeto (primitivo), entonces regresará `TypeError`. En ES6, un no-objeto pasado como argumento será tratado como si fuera un objeto no-extendible ordinario, simplemente regresa `false`.


```js
Object.isExtensible(1);
// TypeError: 1 is not an object (ES5 code)

Object.isExtensible(1);
// false (ES6 code)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.isextensible |

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

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

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

* `Object.preventExtensions()`
* `Object.seal()`
* `Object.isSealed()`
* `Object.freeze()`
* `Object.isFrozen()`
* `Reflect.isExtensible()` (en-US)
Object.is()
===========

El método **`Object.is()`** determina si dos valores son iguales.

Síntaxis
--------
```

Object.is(valor1, valor2);
```

### Parámetros

`valor1`

Primer valor a comparar.

`valor2`

Segundo valor a comparar.

### Valor return del método

Este método devuelve un valor de tipo `Boolean` indicando si los valores pasados como parámetros son iguales o no.

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

`Object.is()` determina si dos valores son iguales. Dos valores son iguales si se puede asegurar que:

* ambos son `undefined`
* ambos son `null`
* ambos son `true` o `false`
* ambos son strings y tienen la misma longitud con los mismos carácteres
* ambos son el mismo objeto
* ambos son números y
    + `ambos +0 (mayores que 0)`
    + `ambos -0 (menores que 0)`
    + ambos son `NaN`
    + o ambos no son cero o no son de tipo `NaN` y tienen el mismo valor

Esta comparación *no* es igual a la que realiza el operador `==` (en-US). El operador `==` (en-US) aplica varias coerciones(comprobaciones) en ambos sentidos (si no tienen el mismo Type) antes de probar la igualdad (lo que resulta en comportamientos como `"" == false` siendo `true`), pero `Object.is` no obliga a niguno de los valores.

Esta *tampoco* es igual a la que realiza el operador `===` (en-US). El operador `===` (en-US) (y el operador `==` (en-US)) trata los valores `-0` `y +0` como iguales, y además, trata `Number.NaN` como no igual a `NaN`.

Ejemplos
--------


```js
Object.is("foo", "foo"); // true
Object.is(window, window); // true

Object.is("foo", "bar"); // false
Object.is([], []); // false

var test = { a: 1 };
Object.is(test, test); // true

Object.is(null, null); // true

// Special Cases
Object.is(0, -0); // false
Object.is(-0, -0); // true
Object.is(NaN, 0 / 0); // true
```

Polyfill para navegadores no ES6
--------------------------------

`Object.is()` es una adición propuesta en el estandar ECMA-262; y como tal, puede no estar presente en todos los navegadores. Para los casos en que no tenga disponible este método, podría utilizar este código haciendolo que se cargue antes que cualquier otro script. Esto permite que puedas utilizar `Object.is()` en los navegadores que no lo llevan incluído.


```js
if (!Object.is) {
  Object.is = function (x, y) {
    // SameValue algorithm
    if (x === y) {
      // Steps 1-5, 7-10
      // Steps 6.b-6.e: +0 != -0
      return x !== 0 || 1 / x === 1 / y;
    } else {
      // Step 6.a: NaN == NaN
      return x !== x && y !== y;
    }
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.is |

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

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

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

* Comparadores de igualdad e identidad —Una comparación de las 3 operaciones de cotejamiento integradas.
Constructor Object()
====================

El **constructor `Object`** convierte la entrada en un objeto. Su comportamiento depende del tipo de entrada.

* Si el valor es `null` o `undefined`, este crea y regresa un objeto vacio.
* En caso contrario, devuelve un objeto de un tipo que corresponde al valor dado.
* Si el valor ya es un objeto, devuelve el valor.
Sintaxis
--------


```js
new Object(value)
Object(value)
```


**Nota:** `Object()` puede ser llamado con o sin `new`. Ambos crean un nuevo objeto.

### Parametros

`value`

Cualquier valor.

Ejemplos
--------

### Creando un nuevo Objeto


```js
const o = new Object();
o.foo = 42;

console.log(o);
// { foo: 42 }
```

### Uso de objetos dados tipos indefinidos y nulos

Los siguientes ejemplos almacenan un objeto `Object` vacio en `o`


```js
const o = new Object();
```



```js
const o = new Object(undefined);
```



```js
const o = new Object(null);
```

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

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

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

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

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

* Inicializador de objetos (en-US)
Object.getOwnPropertySymbols()
==============================

El método **`Object.getOwnPropertySymbols()`** regresa una colección de todos las propiedades de los simbolos encontrados directamente en un objeto dado.

Síntaxis
--------
```

Object.getOwnPropertySymbols(obj)
```

### Parametros

`obj`

El objeto del cual los simbolos de propiedades son devueltos.

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

Similar a `Object.getOwnPropertyNames()`, puedes obtener todas las propiedades de simbolos de un objeto dado como una colección de simbolos. Note que `Object.getOwnPropertyNames()` no contiene en sí mismo las propiedades de simbolos de un objeto y solo contiene las propiedades de cadenas.

Cómo todos los objetos no tienen inicialmente propiedades simbolos propios, `Object.getOwnPropertySymbols()` regresa una colección vacia a menos que tengas propiedades de simbolos establecidas en tu objeto.

Ejemplos
--------


```js
var obj = {};
var a = Symbol("a");
var b = Symbol.for("b");

obj[a] = "localSymbol";
obj[b] = "globalSymbol";

var objectSymbols = Object.getOwnPropertySymbols(obj);

console.log(objectSymbols.length); // 2
console.log(objectSymbols); // [Symbol(a), Symbol(b)]
console.log(objectSymbols[0]); // Symbol(a)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.getownpropertysymbols |

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

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

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

* `Object.getOwnPropertyNames()`
* `Symbol`
Object.keys()
=============

El método estático **`Object.keys()`** devuelve un arreglo de propiedades enumerables propias de un objeto dado.

Pruébalo
--------

Sintaxis
--------


```js
Object.keys(obj)
```

### Parámetros

`obj`

Un objeto.

### Valor devuelto

Un arreglo de strings que representan todas las propiedades del objeto.

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

`Object.keys` devuelve un arreglo cuyos elementos son cadenas correspondientes a las propiedades enumerables que se encuentran directamente en el `object`. Esto es lo mismo que iterar con un bucle `for...in`, excepto que un bucle `for...in` también enumera las propiedades en la cadena de prototipo. El orden del arreglo devuelto por `Object.keys()` es el mismo que proporciona el bucle `for...in`.

Si necesita los valores de la propiedad, use `Object.values()` en su lugar. Si necesita ambos las claves de la propiedad como sus valores, use `Object.entries()` en su lugar

Ejemplos
--------

### Usando Object.keys()


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

// Arreglo como objeto
const obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.keys(obj)); // ['0', '1', '2']

// arreglo como objeto con nombres ordenados aleatoriamente
const anObj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.keys(anObj)); // ['2', '7', '100']

// getFoo es una propiedad no enumerable
const myObj = Object.create(
  {},
  {
    getFoo: {
      value() {
        return this.foo;
      },
    },
  },
);
myObj.foo = 1;
console.log(Object.keys(myObj)); // ['foo']
```


Si quieres *todas* las propiedades, incluso las no enumerables, mira `Object.getOwnPropertyNames()`.

### Usando Object.keys() en primitivos

Los argumentos que no son objetos son objetos forzados. Únicamente las cadenas pueden tener propiedades enumerables propias, mientras que todas las demás primitivas devuelven un arreglo vacío.


```js
// Las cadenas de texto tienen índices como propiedades propias enumerables
console.log(Object.keys("foo")); // ['0', '1', '2']

// Otros primitivos no tienen propiedas propias
console.log(Object.keys(100)); // []
```


**Nota:** En ES5, si el argumento para `Object.keys()` no es un objeto, causará `TypeError`.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.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 `Object.keys` en `core-js`
* Enumerabilidad y posesión de propiedades
* `Object.entries()`
* `Object.values()`
* `Object.prototype.propertyIsEnumerable()`
* `Object.create()`
* `Object.getOwnPropertyNames()`
* `Map.prototype.keys()` (en-US)
Object.prototype.isPrototypeOf()
================================

El método **`isPrototypeOf()`** comprueba si un objeto se encuentra en la cadena de prototipado de otro.

**Nota:** `isPrototypeOf` difiere del operador `instanceof`. En la expresión "`object instanceof AFunction`", la cadena de prototipado de `object` es comprobada contra `AFunction.prototype`, no contra la propia `AFunction`.

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

prototypeObj.isPrototypeOf(obj)
```

### Parámetros

`prototypeObj`

Un objeto para ver comprobado contra cada vínculo en la cadena de prototipado del argumento **object**.

`object`

El object sobre cuya cadena de prototipado se realizará la búsqueda.

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

El método `isPrototypeOf` permite comprobar si un objetyo existe o no en la cadena de prototipado de otro.

Por ejemplo, considerese la siguiente cadena de prototipado:


```js
function Fee() {
  // ...
}

function Fi() {
  // ...
}
Fi.prototype = new Fee();

function Fo() {
  // ...
}
Fo.prototype = new Fi();

function Fum() {
  // ...
}
Fum.prototype = new Fo();
```


Al final de la secuencia, si se instanci `Fum` y se necesita verificar si el prototipo de `Fi` existe en la cadena de prototipado de `Fum` prototype chain, puede hacerse esto:


```js
var fum = new Fum();
// ...

if (Fi.prototype.isPrototypeOf(fum)) {
  // do something safe
}
```


Esto, junto con el operador `instanceof` resulta especialmente útil si se tiene código que sólo puede operar cuando se trata de objetos descendientes de una cadena de prototipado específica, p.e., para garantizar que ciertos métodos o propiedades estén presentes en dichos objetos.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.isprototypeof |

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

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

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

* `instanceof`
* `Object.getPrototypeOf()`
* `Object.setPrototypeOf()`
* `Object.prototype.__proto__`
Object.getOwnPropertyDescriptors()
==================================

El método **`Object.getOwnPropertyDescriptors()`** regresa todos los descriptores de propiedad propios de un objeto dado.

Pruébalo
--------

Sintáxis
--------


```js
Object.getOwnPropertyDescriptors(obj);
```

### Parámetros

`obj`

El objeto para el cual obtener todos los descriptores de propiedad.

### Valores devueltos

Un objeto que contiene todos los descriptores de propiedad propios de un objeto.

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

Este método permite la examinación de la descripción precisa de todas las propiedades de un objeto. Una propiedad en JavaScript consiste en un valor-cadena nombre y un descriptor de propiedad. Más información acerca de los tipos de descriptores de propiedad y sus atributos pueden ser encontrados en `Object.defineProperty()`.

Un descriptor de propiedad es un registro con algunos de los siguientes atributos:

`value`

El valor asociado con la propiedad (solo descriptores de datos).

**`writable`**

`true` si y solo si el valor asociado con la propiedad puede ser cambiado (solo descriptores de datos).

`get`

Un función que sirve como un getter para la propiedad, o `undefined` si no hay getter (solo descriptores de acceso).

`set`

Una función que sirve como un setter para la propiedad, o `undefined` si no hay setter (solo descriptores de acceso).

`configurable`

`true` si y solo si el tipo de este descriptor de propiedad puede ser cambiado y si la propiedad puede ser borrada de el objeto correspondiente.

`enumerable`

`true` si y solo si esta propiedad aparece durante la enumeración de las propiedad en el objeto correspondiente.

Ejemplos
--------

### Creando un clon superficial

Mientras el método `Object.assign()` solo copiará las propiedades enumerables y propias de un objeto fuente a un objeto destino, puedes usar este método y `Object.create()` para una copia superficial entre dos objetos desconocidos:


```js
Object.create(
  Object.getPrototypeOf(obj),
  Object.getOwnPropertyDescriptors(obj),
);
```

### Creando una subclase

Una manera típica de crear una subclase es definir la subclase, establecer su prototipo a una instancia de la superclase, y después definir propiedades en esa instancia. Esto puede ponerse incómodo especialmente por los getters y setters. En cambio, tú puedes usar este código para establecer el prototipo:


```js
function superclass() {}
superclass.prototype = {
  // Define tus métodos y propiedades aquí
};
function subclass() {}
subclass.prototype = Object.create(superclass.prototype, {
  // Define tus métodos y propiedades aquí
});
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.getownpropertydescriptors |

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

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

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

* `Object.getOwnPropertyDescriptor()`
* `Object.defineProperty()`
* Polyfill
get ArrayBuffer[@@species]
==========================

La propiedad de acceso **`ArrayBuffer[@@species]`** devuelve el constructor `ArrayBuffer`.

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

ArrayBuffer[Symbol.species]
```

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

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

Ejemplos
--------

La propiedad `species` devuelve la función constructora predeterminada, que es el constructor `ArrayBuffer` para los objetos `ArrayBuffer`:


```js
ArrayBuffer[Symbol.species]; // función ArrayBuffer()
```


En un objeto de colección derivado (por ejemplo, su búfer de array personalizado `MyArrayBuffer`), `MyArrayBuffer` species es el constructor `MyArrayBuffer`. Sin embargo, es posible que desee sobrescribir esto para devolver objetos `ArrayBuffer` principales en sus métodos de clase derivados:


```js
class MyArrayBuffer extends ArrayBuffer {
  // Overwrite MyArrayBuffer species to the parent ArrayBuffer constructor
  static get [Symbol.species]() {
    return ArrayBuffer;
  }
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-arraybuffer-@@species |

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

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

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

* `ArrayBuffer`
* `Symbol.species`
ArrayBuffer.prototype.byteLength
================================

La propiedad de acceso **`byteLength`** representa la longitud de `ArrayBuffer` en bytes.

Pruébalo
--------

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

arraybuffer.byteLength
```

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

La propiedad `byteLength` es una propiedad de acceso cuya función de acceso de conjunto es `undefined`, lo que significa que solo puede leer esta propiedad. El valor se establece cuando la matriz se construye y no se puede cambiar. Esta propiedad devuelve `0` si este `ArrayBuffer` ha sido separado.

Ejemplos
--------


```js
var buffer = new ArrayBuffer(8);
buffer.byteLength; // 8
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-arraybuffer.prototype.bytelength |

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

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

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

* `ArrayBuffer`
Constructor InternalError()
===========================

**No estándar:** Esta característica no es parte de los estándares. No la uses en sitios Web en producción: no funcionará para todos los usuarios. Podrían haber también incompatibilidades considerables entre distintas implementaciones y el comportamiento podría cambiar en el futuro.

El constructor **`InternalError()`** crea un error que indica un error que ocurrió internamente en el motor de JavaScript. Por ejemplo: **"InternalError**: demasiada recursividad".

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

new InternalError([message[, fileName[, lineNumber]]])
```

### Parámetros

`message`

Opcional. Una descripción del error legible para los humanos.

`fileName`

Opcional. El nombre del archivo que contiene el código que provocó la excepción.

`lineNumber`

Opcional. El número de línea del código que provocó la excepción.

Ejemplos
--------

### Crear un nuevo `InternalError`


```js
new InternalError("Fallo del motor");
```

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

No forma parte de ningún estándar.

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

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

Ve también
----------

* `Error`