recursal/MDN huggingface dataset:
RegExp.rightContext ($')
========================

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

La propiedad **rightContext *(No es estándar)*** es una propiedad estática y de solo lectura de expresiones regulares que contiene la subcadena que sigue a la coincidencia más reciente. el alias para esta propiedad es `RegExp.$'`.

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

RegExp.rightContext
RegExp["$'"]
```

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

La propiedad `rightContext` es estática, no es una propiedad de un objeto de expresión regular individual. Debe usarse como `RegExp.rightContext` o `RegExp["$'"].`

El valor de la propiedad `rightContext` es de solo lectura y se modifica cada que hay una coincidencia exitosa.

Tenga presente que no puede usar la abreviatura (`RegExp.$'`), porque el analizador espera una cadena de inicio, si lo hace optendra un error de sintaxis `SyntaxError` , para este caso, usted debe usar corchetes. consulte notación de paréntesis para acceso a la propiedad.

Ejemplos
--------

### Usando `rightContext` y `$'`


```js
var re = /hola/g;
re.test("hola mundo!");
RegExp.rightContext; // " mundo!"
RegExp["$'"]; // " mundo!"
```

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

| Specification |
| --- |
| Legacy RegExp features # additional-properties-of-the-regexp-constructor |

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

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

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

* Non-standard
 `RegExp.input ($_)` (en-US)
* Non-standard
 `RegExp.lastMatch ($&)` (en-US)
* Non-standard
 `RegExp.lastParen ($+)` (en-US)
* Non-standard
 `RegExp.leftContext ($`)` (en-US)
* Non-standard
 `RegExp.$1-$9` (en-US)
RegExp.prototype.ignoreCase
===========================

La propiedad **`ignoreCase`** indica si la expresión regular está usando la bandera "i". `ignoreCase` es una propiedad de *sólo lectura* de una instancia de expresión regular.

| Atributos de la propiedad `RegExp.prototype.ignoreCase` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | Sí |

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

El valor de `ignoreCase` es un `Boolean` y `true` si la bandera "i" fue usada. De otra manera es false. La bandera "i" indica que el se debe ignorar la capitalización al tratar de encontrar los equivalentes en un texto.

No se puede cambiar esta propiedad directamente.

Ejemplos
--------

### Usando `ignoreCase`


```js
var regex = new RegExp("foo", "i");

console.log(regex.ignoreCase); // true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.ignorecase |

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

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

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

* `RegExp.lastIndex` (en-US)
* `RegExp.prototype.global` (en-US)
* `RegExp.prototype.multiline` (en-US)
* `RegExp.prototype.source` (en-US)
* `RegExp.prototype.sticky` (en-US)
RegExp.prototype.toString()
===========================

El método **`toString()`** devuelve una cadena que representa el patrón de la expresión regular.

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

regexObj.toString();
```

### Valor de Retorno

Una cadena que representa el objeto dado.

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

El objeto `RegExp` reemplaza el método `toString()` del objeto `Object`; no hereda de `Object.prototype.toString()`. Para objetos `RegExp`, el método `toString()` retorna una cadena que representa el patrón de la expresión regular.

Ejemplos
--------

### Usando `toString()`

El siguiente ejemplo muestra la cadena de representación de un objeto `RegExp`:


```js
var myExp = new RegExp("a+b+c");
console.log(myExp.toString()); // '/a+b+c/'

var foo = new RegExp("bar", "g");
console.log(foo.toString()); // '/bar/g'
```

### Expresiones regulares vacías y escapado

A partir de ECMAScript 5, una expresión regular vacía devuelve la cadena "/(?:)/" y los terminadores de línea tales como "\n" son escapados:


```js
new RegExp().toString(); // "/(?:)/"

new RegExp("\n").toString() === "/\n/"; // true, antes de ES5
new RegExp("\n").toString() === "/\\n/"; // true, desde ES5
```

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

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

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

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

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

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

El método **`Object.fromEntries()`** transforma una lista de pares con `[clave-valor]` en un objeto.

Pruébalo
--------

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

Object.fromEntries(iterable);
```

### Parámetros

`iterador`

Un iterador como `Array`, `Map` (en-US) u otros objetos que implementen el protocolo iterable.

### Valor de retorno

Un nuevo objeto cuyas propiedades son dadas por las entradas del iterador.

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

El método `Object.fromEntries()` toma una lista de pares con clave-valor y devuelve un nuevo objeto cuyas propiedades son dadas por éstas entradas. El argumento *iterador* se espera que sea un objeto que implemente un método `@@iterator`, que devuelve un objeto iterador, que produce un objeto tipo array de dos elementos, donde el primer elemento es un valor que se usará como la clave de la propiedad, y el segundo elemento es el valor a asociar con esa clave de propiedad.

`Object.fromEntries()` realiza lo inverso de `Object.entries()`.

Ejemplos
--------

### Convirtiendo un `Map` en un `Objeto`

Con `Object.fromEntries`, puedes convertir de un `Map` (en-US) a un `Object`:


```js
const map = new Map([
  ["foo", "bar"],
  ["baz", 42],
]);
const obj = Object.fromEntries(map);
console.log(obj); // { foo: "bar", baz: 42 }
```

### Convirtiendo un `Arreglo` en un `Objeto`

Con `Object.fromEntries`, puedes convertir de un `Array` a un `Object`:


```js
const arr = [
  ["0", "a"],
  ["1", "b"],
  ["2", "c"],
];
const obj = Object.fromEntries(arr);
console.log(obj); // { 0: "a", 1: "b", 2: "c" }
```

### Transformación de Objetos

Con `Object.fromEntries`, su método inverso `Object.entries()`, y array métodos de manipulación de arreglos, puedes transformar objetos así:


```js
const object1 = { a: 1, b: 2, c: 3 };

const object2 = Object.fromEntries(
  Object.entries(object1).map(([key, val]) => [key, val \* 2]),
);

console.log(object2);
// { a: 2, b: 4, c: 6 }
```

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

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

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

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

Véase tambien
-------------

* `Object.entries()`
* `Object.keys()`
* `Object.values()`
* `Map.prototype.entries()` (en-US)
* `Map.prototype.keys()` (en-US)
* `Map.prototype.values()` (en-US)
Object.prototype.valueOf()
==========================

El método **`valueOf()`** retorna el valor primitivo del objeto especificado.

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

object.valueOf()
```

### Valor de retorno

El valor primitivo del objeto especificado.

Pruébalo
--------

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

JavaScript utiliza el método `valueOf` para convertir un objeto a un valor primitivo. Raramente usted necesitará invocar el método `valueOf` por su cuenta; JavaScript lo realizará de forma automática cuando encuentre un objeto, donde un valor primitivo es esperado.

Por defecto, el método `valueOf` es heredado por cada objeto descendiente de `Object`. Cada objeto incorporado en el núcleo del lenguaje sobreescribe este método para retornar un valor apropiado. Si un objeto no tiene un valor primitivo, `valueOf` devuelve el objeto en sí.

Puede utilizar `valueOf` dentro de su propio código para convertir un objeto incorporado en el núcleo del lenguaje en un valor primitivo. Cuando usted crea un objeto personalizado, puede sobreescribir el comportamiento de `Object.prototype.valueOf()` para invocar un método personalizado, en vez de utilizar el método por defecto `Object`.

### Sobreescribiendo `valueOf` para objetos personalizados

Puede crear una función para ser invocada en lugar de utilizar el método `valueOf` por defecto. Su función no debe contener ningún parámetro.

Suponga que tiene un objeto de tipo `myNumberType` y usted quiere crear un método `valueOf` para este. El código a continuación asigna una función personalizada al método `valueOf`:


```js
myNumberType.prototype.valueOf = function () {
  return customPrimitiveValue;
};
```


Al tener el código anterior funcionando, cada vez que un objeto de tipo `myNumberType` es utilizado en un contexto donde deba ser representado por un valor primitivo, JavaScript automáticamente invocará la función definida en el código anterior.

El método `valueOf` es invocado usualmente por JavaScript pero usted puede invocarlo directamente como sigue a continuación:


```js
myNumber.valueOf();
```


**Nota:** Objetos en contextos de string realizan la conversión a string a través del método `toString()` , el cual, es diferente de `String` para convertir objetos a primitivos string utilizando el método `valueOf`. Todos los objetos pueden ser convertidos a string, si solo "`[object _type_]`". Pero muchos objetos no se pueden convertir a number, boolean o function.

Ejemplos
--------

### Utilizando `valueOf`


```js
function myNumberType(n) {
  this.number = n;
}

myNumberType.prototype.valueOf = function () {
  return this.number;
};

myObj = new myNumberType(4);
myObj + 3; // 7
```

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

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

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

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

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

* `Object.prototype.toString()`
* `parseInt()`
Object.isSealed()
=================

El método **`Object.isSealed()`** si el objeto está sellado.

Pruébalo
--------

Syntax
------
```

Object.isSealed(obj)
```

### Parámetros

`obj`

El objeto que debe ser verificado.

### Valor devuelto

Un `Boolean` indicando si el objeto dado está sellado.

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

Devuelve `true` si el objeto está sellado, de lo contrario devuelve `false`. Un objeto está sellado si no es extensible y si todas sus propiedades no se pueden configurar y por lo tanto no removibles (pero no necesariamente no modificables).

Ejemplos
--------


```js
// Los objetos no están sellados por defecto
var empty = {};
Object.isSealed(empty); // === false

// Si haces un objeto vacío no extendible,
// está vacíamente sellado
Object.preventExtensions(empty);
Object.isSealed(empty); // === true

// Lo mismo no es vedad sobre un objeto no vacío,
// a menos que sus propiedades son todas no configurables.
var hasProp = { fee: "fie foe fum" };
Object.preventExtensions(hasProp);
Object.isSealed(hasProp); // === false

// Pero hazlas todas no configurables
// y el objeto se vuelve sellado.
Object.defineProperty(hasProp, "fee", {
  configurable: false,
});
Object.isSealed(hasProp); // === true

// La manerá más facil de sellar un objeto, por supuesto,
// es Object.seal
var sealed = {};
Object.seal(sealed);
Object.isSealed(sealed); // === true

// Un objeto sellado es, por definición, no extendible.
Object.isExtensible(sealed); // === false

// Un objeto sellado puodría estar congelado,
// pero no tiene que ser.
Object.isFrozen(sealed); // === true
// (Todas las propiedades también no modificables)

var s2 = Object.seal({ p: 3 });
Object.isFrozen(s2); // === false
// ('p' todavía es modificable)

var s3 = Object.seal({
  get p() {
    return 0;
  },
});
Object.isFrozen(s3); // === true
// (solo la configurabilidad es importante para las propiedades de acceso)
```

Notes
-----

En ES5, si el argumento de este método no es un objeto (primitivo), entonces causará un `TypeError`. En ES2015, un argumento que no sea un objeto será tratado como si fuera un objeto sellado ordinario, simplemente devuelve `true`.


```js
Object.isSealed(1);
// TypeError: 1 no es un objeto (ES5 code)

Object.isSealed(1);
// true (ES2015 code)
```

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

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

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

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

See also
--------

* `Object.seal()`
* `Object.preventExtensions()`
* `Object.isExtensible()`
* `Object.freeze()`
* `Object.isFrozen()`
Object.prototype.constructor
============================

Resumen
-------

Retorna una referencia a la función del `Object` que creó el objeto de la instancia. Note que el valor de esta propiedad es una referencia a la función misma, no a un string conteniendo el nombre de la función. El valor es sólo de lectura para valores primitivos tales como 1, true y 'test'.

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

Todos los objetos tienen una propiedad `constructor.` Los objetos creados sin explicitar el uso de una función (como son los objetos y las cadenas literales) tendrán una propiedad de `constructor` que apunta al tipo de constructor del Objeto Fundamento para ese objeto.


```js
var o = {};
o.constructor === Object; // true

var a = [];
a.constructor === Array; // true

var n = new Number(3);
n.constructor === Number; // true
```

Ejemplos
--------

### Ejemplo: Mostrando el constructor de un objeto

El siguiente ejemplo crea un prototipo, `Tree`, y un objeto de este tipo, `theTree`. El ejemplo muestra entonces la propiedad `constructor` para el objeto `theTree`.


```js
function Tree(name) {
  this.name = name;
}

var theTree = new Tree("Redwood");
console.log("theTree.constructor is " + theTree.constructor);
```


Este ejemplo muestra la siguiente salida:


```js
theTree.constructor is function Tree (name) {
    this.name = name;
}
```

### Ejemplo: Cambiando el constructor de un objeto

El siguiente ejemplo demuestra como modificar el valor del constructor de objetos genéricos. Solo `true`, `1` y `"test"` no serán afectados ya que ellos tienen constructores nativos de solo lectura. Este ejemplo demuestra que no siempre es seguro confiar en la propiedad constructor de un objeto.


```js
function Type() {}

var types = [
  new Array(),
  [],
  new Boolean(),
  true, // no cambia
  new Date(),
  new Error(),
  new Function(),
  function () {},
  Math,
  new Number(),
  1, // no cambia
  new Object(),
  {},
  new RegExp(),
  /(?:)/,
  new String(),
  "test", // no cambia
];

for (var i = 0; i < types.length; i++) {
  types[i].constructor = Type;
  types[i] = [
    types[i].constructor,
    types[i] instanceof Type,
    types[i].toString(),
  ];
}

console.log(types.join("\n"));
```

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

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

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Object.getPrototypeOf()
=======================

Resumen
-------

El método **`Object.getPrototypeOf()`** devuelve el prototipo (es decir, el valor de la propiedad interna `[[Prototype]]`) del objeto especificado.

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

Object.getPrototypeOf(obj)
```

### Parámetros

`obj`

El objeto cuyo prototipo va a ser devuelto.

### Valor Devuelto

El prototipo del objeto dado. Si no existen propiedades heredadas se devolverá `null`.

Ejemplos
--------


```js
var proto = {};
var obj = Object.create(proto);
Object.getPrototypeOf(obj) === proto; // true
```

Notas
-----

En ES5, lanzará una excepción `TypeError` si el parámetro `obj` no es un objeto. en ES6, El parámetro será forzado a un `Object`.


```js
> Object.getPrototypeOf('foo')
TypeError: "foo" is not an object  // ES5 code
> Object.getPrototypeOf('foo')
String.prototype                   // ES6 code
```

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

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

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

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

Mira también
------------

* `Object.prototype.isPrototypeOf()`
* `Object.setPrototypeOf()` 
Experimental
* John Resig's post on getPrototypeOf
* `Object.prototype.__proto__`
* `Reflect.getPrototypeOf()` (en-US)
Object.values()
===============

El método **`Object.values()`** devuelve un array con los valores correspondientes a las propiedades **enumerables** de un objeto. Las propiedades son devueltas en el mismo orden a como lo haría un bucle `for...in` (la única diferencia es que un bucle `for-in` también enumera las propiedades en la cadena de prototipo de un objeto).

Pruébalo
--------

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

Object.values(obj)
```

### Parámetros

`obj`

Objeto cuyas propiedades enumerables serán devueltas.

### Valor devuelto

Un `array` con las propiedades enumerables del objeto pasado como parámetro.

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

El método `Object.values()` devuelve un array cuyos elementos son valores de propiedades enumarables que se encuentran en el objeto. El orden de las propiedades es el mismo que el dado cuando se recorre el objeto de forma manual.

Ejemplos
--------


```js
var obj = { foo: "bar", baz: 42 };
console.log(Object.values(obj)); // ['bar', 42]

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

// array como objeto con una ordenación aleatoria de las claves
var an_obj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.values(an_obj)); // ['b', 'c', 'a']

// getFoo no es una propiedade enumerable, por lo que como se observa, no se devuelve
var my_obj = Object.create(
  {},
  {
    getFoo: {
      value: function () {
        return this.foo;
      },
    },
  },
);
my_obj.foo = "bar";
console.log(Object.values(my_obj)); // ['bar']

// parámetros que no son Objetos se fuerzan a que se comporten como tal
console.log(Object.values("foo")); // ['f', 'o', 'o']
```

Polyfill
--------

Para dar soporte compatible con `Object.values()` a entornos antiguos que no la soportan de forma nativa, puedes encontrar un Polyfill en tc39/proposal-object-values-entries o en los repositorios es-shims/Object.values.

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

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

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

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

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

* Enumeración y propietarios de propiedades
* `Object.keys()`
* `Object.entries()`
* `Object.prototype.propertyIsEnumerable()`
* `Object.create()`
* `Object.getOwnPropertyNames()`
Object.entries()
================

El método **`Object.entries()`** devuelve una matriz de pares propios de una propiedad enumerable [key, value] de un objeto dado, en el mismo orden que es proporcionado por `for...in` (La diferencia es que un bucle for-in enumera las propiedades en la cadena de prototipos).

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

Object.entries(obj)
```

### Parámetros

`obj`

The object whose enumerable own property `[key, value]` pairs are to be returned.

### Valor de retorno

An array of the given object's own enumerable property `[key, value]` pairs.

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

`Object.entries()` returns an array whose elements are arrays corresponding to the enumerable property `[key, value]` pairs found directly upon `object`. The ordering of the properties is the same as that given by looping over the property values of the object manually.

Ejemplos
--------


```js
var obj = { foo: "bar", baz: 42 };
console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]

// array like object
var obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]

// array like object with random key ordering
var an_obj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.entries(an_obj)); // [ ['2', 'b'], ['7', 'c'], ['100', 'a'] ]

// getFoo is property which isn't enumerable
var my_obj = Object.create(
  {},
  {
    getFoo: {
      value: function () {
        return this.foo;
      },
    },
  },
);
my_obj.foo = "bar";
console.log(Object.entries(my_obj)); // [ ['foo', 'bar'] ]

// non-object argument will be coerced to an object
console.log(Object.entries("foo")); // [ ['0', 'f'], ['1', 'o'], ['2', 'o'] ]

// iterate through key-value gracefully
var obj = { a: 5, b: 7, c: 9 };
for (var [key, value] of Object.entries(obj)) {
  console.log(key + " " + value); // "a 5", "b 7", "c 9"
}

// Or, using array extras
Object.entries(obj).forEach(([key, value]) => {
  console.log(key + " " + value); // "a 5", "b 7", "c 9"
});
```

### Converting an `Object` to a `Map`

The `new Map()` (en-US) constructor accepts an iterable of `entries`. With `Object.entries`, you can easily convert from `Object` to `Map` (en-US):


```js
var obj = { foo: "bar", baz: 42 };
var map = new Map(Object.entries(obj));
console.log(map); // Map { foo: "bar", baz: 42 }
```

Polyfill
--------

To add compatible `Object.entries` support in older environments that do not natively support it, you can find a Polyfill in the tc39/proposal-object-values-entries or in the es-shims/Object.entries repositories.

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

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

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

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

See also
--------

* Enumerability and ownership of properties
* `Object.keys()`
* `Object.values()` 
Experimental
* `Object.prototype.propertyIsEnumerable()`
* `Object.create()`
* `Object.getOwnPropertyNames()`
Object.prototype.\_\_defineGetter\_\_()
=======================================

**Advertencia:** Esta característica está obsoleta en favor de definir getters usando el object initializer syntax (en-US) o la API `Object.defineProperty()`.

En todo caso, como es ampliamente implementada y usada en la Web, es poco probable que los navegadores dejen de implementarla.

El método **`__defineGetter__`** enlaza una propiedad de un objeto a una función a ser llamada cuando esa propiedad es buscada.

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

obj.__defineGetter__(prop, func)
```

### Parámetros

`prop`

Un texto (string) que contiene el nombre de la propiedad para enlazar la función dada.

`func`

A function to be bound to a lookup of the specified property.

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

The `__defineGetter__` allows a getter (en-US) to be defined on a pre-existing object.

Ejemplos
--------


```js
// Forma no-estándar y obsoleta

var o = {};
o.\_\_defineGetter\_\_("gimmeFive", function () {
  return 5;
});
console.log(o.gimmeFive); // 5

// Formas compatibles con el estándar

// Usando el operador get
var o = {
  get gimmeFive() {
    return 5;
  },
};
console.log(o.gimmeFive); // 5

// Usando Object.defineProperty
var o = {};
Object.defineProperty(o, "gimmeFive", {
  get: function () {
    return 5;
  },
});
console.log(o.gimmeFive); // 5
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.\_\_defineGetter\_\_ |

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

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

Mira también
------------

* `Object.prototype.__defineSetter__()` (en-US)
* `get` (en-US) operator
* `Object.defineProperty()`
* `Object.prototype.__lookupGetter__()` (en-US)
* `Object.prototype.__lookupSetter__()` (en-US)
* JS Guide: Defining Getters and Setters
* [Blog Post] Deprecation of \_\_defineGetter\_\_ and \_\_defineSetter\_\_
* Error 647423 en Firefox