recursal/MDN huggingface dataset:
Reflect.set()
=============

El método estático **`Reflect.set()`** funciona igual que asignar una propiedad en un objeto.

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

Reflect.set(target, propertyKey, value[, receiver])
```

### Parámetros

`target`

El objeto en el cual se va a asignar una propiedad.

`propertyKey`

El nombre de la propiedad a asignar.

value

El valor de la propiedad.

receiver

El valor de `this` para usar en la llamada a `target` si se encuentra un setter.

### Valor de retorno

Un `Boolean` indicando si se pudo o no asignar la propiedad.

### Excepciones

Un `TypeError`, si `target` no es un `Object`.

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

El método `Reflect.set` permite asignar una propiedad a un objeto. It does property assignment and is like the property accessor syntax as a function.

Ejemplos
--------

### `Uso de Reflect.set()`


```js
// Objeto
var obj = {};
Reflect.set(obj, "prop", "value"); // true
obj.prop; // "value"

// Arreglo
var arr = ["duck", "duck", "duck"];
Reflect.set(arr, 2, "goose"); // true
arr[2]; // "goose"

// Puede truncar un arreglo.
Reflect.set(arr, "length", 1); // true
arr; // ["duck"];

// Con solo un argumento, propertyKey y value son "undefined".
var obj = {};
Reflect.set(obj); // true
Reflect.getOwnPropertyDescriptor(obj, "undefined");
// { value: undefined, writable: true, enumerable: true, configurable: true }
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.set |

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

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

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

* `Reflect`
* Property accessors
handler.getOwnPropertyDescriptor()
==================================

El método **`handler.getOwnPropertyDescriptor()`** captura `Object.getOwnPropertyDescriptor()`.Sintaxis
--------


```js
var p = new Proxy(target, {
  getOwnPropertyDescriptor: function (target, prop) {},
});
```

### Parámetros

El método `getOwnPropertyDescriptor` recibe los siguiente parámetros. `this` está asociado al handler del proxy.

`target`

El objeto destino.

`prop`

El nombre de la propiedad cuya descripción ha de ser devuelta.

### Valor Devuelto

El método `getOwnPropertyDescriptor` debe devolver un objeto o `undefined`.

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

El método **`handler.getOwnPropertyDescriptor()`** captura `Object.getOwnPropertyDescriptor()`.

### Intercepciones

Este método intercepta las siguientes operaciones:

* `Object.getOwnPropertyDescriptor()`
* `Reflect.getOwnPropertyDescriptor()` (en-US)
### Invariantes

Si los siguientes invariantes son violados, el proxy lanzará `TypeError`:

* `getOwnPropertyDescriptor` debe devolver un objeto o `undefined`.
* No puede devolver que una propiedad no existe si está presente en el objeto como no configurable.
* No puede devolver que una propiedad no existe si esta está presente como una propiedad propia del objeto destino y el objeto no es extensible.
* No puede devolver que una propuedad existe, si esta no está presente en el objeto destino y el objeto no es extensible.
* No puede devolver que una propiedad es no configurable si esta no existe en el objeto destino o si existe pero sí es configurable.
* El resultado de `Object.getOwnPropertyDescriptor(target)` puede ser aplicado al objeto destino mediante `Object.defineProperty` y no lanzará ningún tipo de excepción.
Ejemplos
--------

El siguiente código captura `Object.getOwnPropertyDescriptor()`.


```js
var p = new Proxy(
  { a: 20 },
  {
    getOwnPropertyDescriptor: function (target, prop) {
      console.log("called: " + prop);
      return { configurable: true, enumerable: true, value: 10 };
    },
  },
);

console.log(Object.getOwnPropertyDescriptor(p, "a").value); // "called: a"
// 10
```


El siguiente código viola uno de los invariantes definidos previamente.


```js
var obj = { a: 10 };
Object.preventExtensions(obj);
var p = new Proxy(obj, {
  getOwnPropertyDescriptor: function (target, prop) {
    return undefined;
  },
});

Object.getOwnPropertyDescriptor(p, "a"); // TypeError is thrown
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-getownproperty-p |

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

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

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

* `Proxy`
* `handler`
* `Object.getOwnPropertyDescriptor()`
* `Reflect.getOwnPropertyDescriptor()` (en-US)
handler.set()
=============

El método **`handler.set()`** captura las asignaciones de un valor a una determinada propiedad.

Sintaxis
--------


```js
var p = new Proxy(target, {
  set: function (target, property, value, receiver) {},
});
```

### Parámetros

El método `set` recibe los siguientes parámetros. `this` se asocia al handler.

`target`

El objeto objetivo.

`property`

El nombre de la propiedad a la que se le asignará el valor.

`value`

El nuevo valor asignado a la propiedad.

`receiver`

El objeto al que originalmente iba dirigida la asignación. Normalmente es el proxy. Sin embargo el manejador o `set` handler puede ser llamado de forma indirecta a través de un prototipo entre otros.

Por ejemplo, suponga que un escript ejecuta la sentencia `obj.name = "jen"`, y `obj` no es un proxy, y no posee la propiedad `.name`, pero tiene un proxy en su cadena de prototipos. El manejador `set` de este proxy será llamado y obj será pasado como el receiver.

### Valor Devuelto

El método `set` debe devolver un valor booleano. Devolverá `true` para indicar que la asignación se ha llevado a cabo con éxito. Si devuelve `false`, y la asignación tiene lugar en modo estricto, se lanzará un error de tipo `TypeError`.

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

El método **`handler.set`** captura la asignación de un valor a una propiedad.

### Qué intercepta

Las siguientes operaciones son capturadas:

* Asignación a propiedades: `proxy[foo] = bar` y `proxy.foo = bar`
* Asignación a propiedades heredadas: `Object.create(proxy)[foo] = bar`
* `Reflect.set()`
### Invariantes

Si los siguientes invariantes son violados, el proxy lanzará un `TypeError`:

* El valor de la propiedad no puede ser diferente al de la correspondiente propiedad del objeto, si esta es una propiedad no configurable, o sin permisos de escritura.
* No se puede asignar un valor a una propiedad si la correspondiente propiedad en el objeto objetivo es no configurable y tiene `undefined` como su atributo [[Set]].
* En modo estricto, la devolución de `false` pro parte del manejador `set` lanzará una excepción del tipo `TypeError`.
Ejemplos
--------

El siguiente código captura la asignación de un valor a una propiedad.


```js
var p = new Proxy(
  {},
  {
    set: function (target, prop, value, receiver) {
      target[prop] = value;
      console.log("property set: " + prop + " = " + value);
      return true;
    },
  },
);

console.log("a" in p); // false

p.a = 10; // "propiedad asignada: a = 10"
console.log("a" in p); // true
console.log(p.a); // 10
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-set-p-v-receiver |

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

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

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

* `Proxy`
* `handler`
* `Reflect.set()`
Method definitions
==================

A partir de ECMAScript 2015 (ES6), se introdujo una sintaxis abreviada para la definición de métodos en inicializadores de objetos. Es una forma abreviada para la asignación de una función al nombre del método.Sintaxis
--------
```

var obj = {
  property( parameters… ) {},
  *generator( parameters… ) {},
// also with computed keys:
  [property]( parameters… ) {},
  *[generator]( parameters… ) {},
// compare ES5 getter/setter syntax:
  get property() {},
  set property(value) {}
};
```

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

La sintaxis abreviada es similar a la introducida en ECMAScript 5 con getter y setter.

Dado el siguiente código:


```js
var obj = {
  foo: function () {},
  bar: function () {},
};
```


Ahora se puede abreviar esto mismo como:


```js
var obj = {
  foo() {},
  bar() {},
};
```


**Nota:** La sintaxis abreviada usa funciones con nombre en lugar de funciones anónimas (como en … `foo: function() {}`…). Las funciones con nombre pueden ser llamadas desde el cuerpo de la función (esto es imposible con funciones anónimas, ya que no existe un identificador al que referirse). Para más detalles, ver `function`.

### Abreviatura de métodos generadores

Los métodos generadores también pueden definirse usando la sintaxis abreviada. Note que el asterisco (\*) en la sintaxis abreviada debe estar antes del nombre de propiedad del generador. Esto es, `* g(){}` funcionará, pero `g *(){}` no.
```

// Usando una propiedad con nombre (pre-ES6)
var obj2 = {
  g: function*() {
    var index = 0;
    while(true)
      yield index++;
  }
};

// El mismo objeto, usando la sintaxis abreviada
var obj2 = {
  * g() {
    var index = 0;
    while(true)
      yield index++;
  }
};

var it = obj2.g();
console.log(it.next().value); // 0
console.log(it.next().value); // 1
```

### Las definiciones de métodos no son constructores (instanciables con new)

Las las definiciones de métodos no son constructores y generarán un `TypeError` si intenta instanciarlos.


```js
var obj = {
  method() {},
};
new obj.method(); // TypeError: obj.method no es un constructor

var obj = {
  \*g() {},
};
new obj.g(); // TypeError: obj.g no es un constructor (cambiado en ES2016)
```

Ejemplos
--------

### Caso de prueba simple
```

var obj = {
  a : "foo",
  b(){ return this.a; }
};
console.log(obj.b()); // "foo"
```

### Nombres de propiedad computados

La sintaxis abreviada también soporta nombres de propiedades computados.
```

var bar = {
  foo0 : function (){return 0;},
  foo1(){return 1;},
  ["foo" + 2](){return 2;},
};

console.log(bar.foo0()); // 0
console.log(bar.foo1()); // 1
console.log(bar.foo2()); // 2
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-method-definitions |

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

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

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

* `get`
* `set`
* Lexica grammatical
get
===

Enlaza la propiedad de un objeto con una función que será llamada cuando la propiedad es buscada.

Sintaxis
--------

`{get prop() { . . . } }`

Parámetros
----------

`prop`

el nombre de la propiedad a unir con la función dada

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

A veces es deseable permitir acceso a una propiedad que retorna un valor dinámicamente calculado, o si desea mostrar el estado de alguna variable interna sin requerir el uso de llamadas a métodos explícitos. En JavaScript, esto se puede lograr con el uso de un getter (captador). No es posible tener simultáneamente un getter ligado a una propiedad y que dicha propiedad tenga actualmente un valor, aunque es posible usar un getter junto con un setter para crear un tipo de pseudo-propiedad.

Tenga en cuenta lo siguiente al trabajar con la sintaxis `get`:

* Puede tener un identificador que sea un número o una cadena.
* Debe tener exactamente cero parametros (ver Cambio ES5 incompatible: las funciones getter y setter literal deben tener ahora exactamente cero o un argumento para mas información);
* No debe haber múltiples getters para una misma propiedad (`{ get x() { }, get x() { } }` y `{ x: ..., get x() { } }` están prohibidos).

El getter puede ser removido usando el operador `delete`.

Ejemplos
--------

### Definir un getter con el operador `get`

Esto creará una pseudo-propiedad `latest` (ver ejemplo) del objecto `o` que podría retornar la más reciente entrada dentro de `o.log`:


```js
var o = {
  get latest() {
    if (this.log.length > 0) {
      return this.log[this.log.length - 1];
    } else {
      return null;
    }
  },
  log: [],
};
```


Note que intentar asignar un valor a `latest` no lo cambiará.

### Borrar un getter usando el operador `delete`


```js
delete o.latest;
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-method-definitions |

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

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

Consulta también
----------------

* `delete`
* `set` (en-US)
* `Object.defineProperty()`
* `Object.prototype.__defineGetter__()`
* `Object.prototype.__defineSetter__()` (en-US)
* Defining Getters and Setters in JavaScript Guide
arguments.length
================

La propiedad **`arguments.length`** contiene el número de argumentos pasados a una función.

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

arguments.length
```

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

La propiedad arguments.length devuelve el número total de argumentos pasados a una función. Esto puede ser más o menos que el número de parametros definidos. (Véase `Function.length`).

Ejemplos
--------

### Usando `arguments.length`

En este ejemplo definimos una función que puede sumar dos o más números.


```js
function adder(base /\*, n2, ... \*/) {
  base = Number(base);
  for (var i = 1; i < arguments.length; i++) {
    base += Number(arguments[i]);
  }
  return base;
}
```


**Nota:** Tenga en cuenta la diferencia entre `Function.length` y arguments.length

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-arguments-exotic-objects |

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

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

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

* `Function`
* `Function.length`
callee
======

Resumen
-------

Especifica la función que se está ejecutando actualmente.

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

`callee` es una propiedad de la variable local `arguments` disponible dentro de todos los objetos function; `callee` como una propiedad de `Function.arguments` ya no se utiliza. (`Function.arguments` en sí mismo está también desaconsejado.)

`arguments.callee` permite a funciones anónimas referirse a ellas mismas, lo cual es necesario en funciones anónimas recursivas.

La palabra clave `this` no se refiere a la función que se ejecuta actualmente. Use la propiedad `callee` para referirse a la función dentro del cuerpo de la función.

Ejemplos
--------

### Ejemplo: Usando `arguments.callee` en funciones anónimas recursivas

Una función recursiva debe ser capaz de referirse a sí misma. Típicamente, una función se refiere a sí misma por su nombre. Sin embargo, una función anónima no tiene nombre y por tanto es una variable de referencia para ella, es decir, si la función no está asignada a ninguna variable, la función no puede referirse a sí misma. (Se pueden crear funciones anónimas mediante una expresión `function` o el constructor `Function`.) Aquí es donde entra `arguments.callee`.

El siguiente ejemplo define una función, la cuál, en cada turno, define y devuelve una función factorial.


```js
function makeFactorialFunc() {
  alert("making a factorial function!");
  return function (x) {
    if (x <= 1) return 1;
    return x \* arguments.callee(x - 1);
  };
}

var result = makeFactorialFunc()(5); // returns 120 (5 \* 4 \* 3 \* 2 \* 1)
```


this example isn't very practical, but then again, there are few practical cases where arguments.callee is necessary, and most of the those cases involve closures
void
====

Resumen
-------

El operador `void` se usa en cualquiera de los siguientes modos:

1. `void (expresion )`
2. `void expresion`

El operador `void` especifica una expresión que se evalúa sin devolver un valor. `expresion` es una expresión JavaScript para evaluar. El paréntesis rodeando la expresión es opcional, pero usarlos es una buena práctica al programar.

Puede usar el operador `void` para especificar una expresión como un enlace de hipertexto. La expresión se evalúa pero no se carga en lugar del documento actual.

El siguiente código crea un enlace de hipertexto que no hace nada cuando el usuario hace click en él. Cuando el usuario hace click en el enlace, void(0) se evalúa como 0, pero eso no tiene ningún efecto en JavaScript.


```html
<a href="javascript:void(0)">Haga click aquí para no hacer nada</a>
```


El siguiente código crea un enlace de hipertexto que envía un formulario cuando el usuario hace click en él.


```html
<a href="javascript:void(document.forms["miFormulario"].submit())">
Haga click aquí para enviar</a>
```
typeof
======

Resumen
-------

El operador `typeof` se usa en cualquiera de los siguientes modos:

1. `typeof operando`
2. `typeof (operando)`

El operador `typeof` devuelve una cadena que indica el tipo del operando sin evaluarlo. `operando` es la cadena, variable, palabra clave u objeto para el que se devolverá su tipo. Los paréntesis son opcionales.

Suponga que define las siguientes variables:


```js
var miFuncion = new Function("5+2");
var forma = "redonda";
var tamano = 1;
var hoy = new Date();
```


El operador `typeof` devuelve los siguientes resultados para estas variables


```js
typeof miFuncion === "function";
typeof forma === "string";
typeof tamano === "number";
typeof hoy === "object";
typeof noExiste === "undefined";
```


Para las palabras clave `true` y `null`, el operador `typeof` devuelve los siguientes resultados:


```js
typeof true === "boolean";
typeof null === "object";
```


Para un número o una cadena, el operador `typeof` devuelve los siguientes resultados:


```js
typeof 62 === "number";
typeof "Hola mundo" === "string";
```


Para valores de propiedades, el operador `typeof` devuelve el tipo del valor que contiene la propiedad:


```js
typeof document.lastModified === "string";
typeof window.length === "number";
typeof Math.LN2 === "number";
```


Para métodos y funciones, el operador `typeof` devuelve los resultados siguientes:


```js
typeof blur === "function";
typeof eval === "function";
typeof parseInt === "function";
typeof shape.split === "function";
```


Para objetos predefinidos, el operador `typeof` devuelve los siguientes resultados:


```js
typeof Date === "function";
typeof Function === "function";
typeof Math === "object";
typeof Object === "function";
typeof String === "function";
```
instanceof
==========

Resumen
-------

El operador **`instanceof`** verifica si un objeto en su cadena de prototipos contiene la propiedad `prototype` de un constructor.

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

objeto instanceof constructor
```

### Parámetros

`objeto`

Objeto a verificar.

`constructor`

Función contra la que se hará la verificación.

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

Utilice `instanceof` cuando necesite confirmar el tipo de un objeto en tiempo de ejecución. Por ejemplo, cuando controle excepciones, puede recurrir a diferentes códigos de manipulación de excepciones dependiendo del tipo de excepción tomada.

Debe especificar un objeto en el lado derecho del operador `instanceof`. Por ejemplo, puede especificar una cadena creada con el constructor `String`, pero no puede especificar un literal de cadena.


```js
color1 = new String("verde");
color1 instanceof String; // devuelve verdadero (true)
color2 = "coral";
color2 instanceof String; // devuelve falso (color2 no es un objeto String)
```

### Ejemplos

También vea los ejemplos de `throw`.

#### Ejemplo: Determinando si `elDia` es un objeto `Date`

El siguiente código utiliza `instanceof` para determinar si `elDia` es un objeto `Date`. Debido a que `elDia` es un objeto `Date`, las instrucciones de la sentencia if se ejecutan.


```js
elDia = new Date(1995, 12, 17);
if (elDia instanceof Date) {
  // instrucciones a ejecutar
}
```


#### Ejemplo: Demostrando que `String` y `Date` son del tipo `Object`

El siguiente código utiliza `instanceof` para demostrar que los objetos `String` y `Date` son también del tipo `Object` (éstos se derivan de `Object`).


```js
miCadena = new String();
miFecha = new Date();

miCadena instanceof String; // devuelve true
miCadena instanceof Object; // devuelve true
miCadena instanceof Date; // devuelve false

miFecha instanceof Date; // devuelve true
miFecha instanceof Object; // devuelve true
miFecha instanceof String; // devuelve false
```


#### Ejemplo: Demostrando que `miCoche` es del tipo `Coche` y del tipo `Object`

El siguiente código crea un objeto del tipo `Coche` y una instancia de ese tipo de objeto, `miCoche`. El operador `instanceof` demuestra que el objeto `miCoche` es del tipo `Coche` y del tipo `Object`.


```js
function Coche(fabricante, modelo, ejercicio) {
  this.fabricante = fabricante;
  this.modelo = modelo;
  this.ejercicio = ejercicio;
}
miCoche = new Coche("Honda", "Accord", 1998);
a = miCoche instanceof Coche; // devuelve verdadero (true)
b = miCoche instanceof Object; // devuelve verdadero (true)
```
yield\*
=======

`La expresión` **`yield*`** es usada para delegar a otro `generator` u objeto iterable.

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

yield* [[expression]];
```


`expression`

La expresión que retorna un objeto iterable

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

La expresión `yield*` itera sobre el operador realizando yield de cada valor retornado por este.

El valor de la expresion `yield*` es el valor retornado por el iterador en si mismo cuando es finalizado (ej., cuando `done` es true).

Ejemplos
--------

### Delegando a otro generator

En el siguiente código, los valores declarados con yield en `g1()` son devueltos por las llamadas a `next()` al igual que en `g2()`.


```js
function\* g1() {
  yield 2;
  yield 3;
  yield 4;
}

function\* g2() {
  yield 1;
  yield\* g1();
  yield 5;
}

var iterator = g2();

console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
console.log(iterator.next()); // { value: 4, done: false }
console.log(iterator.next()); // { value: 5, done: false }
console.log(iterator.next()); // { value: undefined, done: true }
```

### Otros objetos iterables

Además de los objetos generator, `yield*` también se puede usar `yield sobre otros tipos de iterables`, ej. arrays, strings u objetos arguments.


```js
function\* g3() {
  yield\* [1, 2];
  yield\* "34";
  yield\* Array.from(arguments);
}

var iterator = g3(5, 6);

console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: "3", done: false }
console.log(iterator.next()); // { value: "4", done: false }
console.log(iterator.next()); // { value: 5, done: false }
console.log(iterator.next()); // { value: 6, done: false }
console.log(iterator.next()); // { value: undefined, done: true }
```

### El valor de la expresión `yield*`

`yield*` es una expresión, no una declaración, por lo que se evalua como un valor.


```js
function\* g4() {
  yield\* [1, 2, 3];
  return "foo";
}

var result;

function\* g5() {
  result = yield\* g4();
}

var iterator = g5();

console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
console.log(iterator.next()); // { value: undefined, done: true },
// g4() returned { value: "foo", done: true } at this point

console.log(result); // "foo"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator-function-definitions-runtime-semantics-evaluation |

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

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

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

* Protocolos de iteración
* `function*`
* `function* expression`
* `yield`