recursal/MDN huggingface dataset:
Division (/)
============

El operador de división (`/`) produce el cociente de sus operandos donde el operando izquierdo es el dividendo y el operando derecho es el divisor.

Pruébalo
--------

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

Operador: x / y
```

Ejemplos
--------

### Division basica


```js
1 / 2; // 0.5

Math.floor(3 / 2); // 1

1.0 / 2.0; // 0.5
```

### Division por cero


```js
2.0 / 0; // Retorna Infinity

2.0 / 0.0; // Retorna Infinity, Dado que 0.0 === 0

2.0 / -0.0; // Retorna -Infinity
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-multiplicative-operators |

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

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

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

* Addition operator
* Subtraction operator
* Multiplication operator (en-US)
* Remainder operator
* Exponentiation operator (en-US)
* Increment operator (en-US)
* Decrement operator
* Unary negation operator (en-US)
* Unary plus operator (en-US)
await
=====

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

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

* Learn more
* See full compatibility
* Report feedback
El operador `await` es usado para esperar a una `Promise`. Sólo puede ser usado dentro de una función `async function`.Sintaxis
--------
```

[rv] = await expression;
```


`expression`

Una `Promise` o cualquier otro valor por el cual haya que esperar.

`rv`

Regresa el valor terminado de la promesa o solamente un valor si no es una `Promise`.

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

La expresión `await` provoca que la ejecución de una función `async` sea pausada hasta que una `Promise` sea terminada o rechazada, y regresa a la ejecución de la función `async` después del término. Al regreso de la ejecución, el valor de la expresión `await` es la regresada por una promesa terminada.

Si la `Promise` es rechazada, el valor de la expresión `await` tendrá el valor de rechazo.

Si el valor de la expresión seguida del operador `await` no es una promesa, será convertido a una resolved Promise.

Ejemplos
--------

Si una `Promise` se pasa a una expresión `await`, espera a que la `Promise` se resuelva y devuelve el valor resuelto.


```js
function resolveAfter2Seconds(x) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(x);
    }, 2000);
  });
}

async function f1() {
  var x = await resolveAfter2Seconds(10);
  console.log(x); // 10
}
f1();
```


Si el valor no es una `Promise`, convierte el valor a una `Promise` resuelta, y espera por dicho valor.


```js
async function f2() {
  var y = await 20;
  console.log(y); // 20
}
f2();
```


Si la `Promise` es rechazada, se lanza una excepción con dicho el valor.


```js
async function f3() {
  try {
    var z = await Promise.reject(30);
  } catch (e) {
    console.log(e); // 30
  }
}
f3();
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-async-function-definitions |

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

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

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

* `async function`
* `async function expression`
* `AsyncFunction` object
function
========

Resumen
-------

El operador `function` define una función dentro de una expresión.

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

function [name]([param1, param2, ..., paramN]) {
   statements
}
```

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

`name`

El nombre de la función. Puede ser omitido, en cuyo caso la función es *anonymous*. El nombre sólo es local para el cuerpo de la función.

`paramN`

El nombre de un argumento que será pasado a la función. Una función puede tener hasta 255 argumentos.

`statements`

Las declaraciones que conforman el cuerpo de la función.

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

La expresión de una función es muy similar y tiene casi la misma sintaxis que la declaración de una función (véase `function` para más detalles). Véase Funciones para ver más información sobre las diferencias entre declaraciones de funciones y expresiones de funciones.

Ejemplos
--------

El siguiente ejemplo define una función sin nombre y se le asigna a la variable x. La función devuelve como resultado el cuadrado de su argumento:


```js
var x = function (y) {
  return y \* y;
};
```

### Expresión de función nombrada

Si quiere referirse a la función actual dentro del cuerpo de la función, debe crear una expresión de función nombrada. Luego, este nombre será local solo para el cuerpo de la función (alcance). Esto también evita usar la propiedad no estándar `arguments.callee`.


```js
var math = {
  factorial: function factorial(n) {
    if (n <= 1) return 1;
    return n \* factorial(n - 1);
  },
};
```

Consulte también
----------------

* Funciones
* `Function`
* Sentencias `function`
Decremento(--)
==============

El operador de decremento (--) disminuye (o resta de a uno) su operando y retorna un valor.

Pruébalo
--------

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

Operadores: x-- o --x
```

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

Si usamos la forma de sufijo, operador después del operando (por ejemplo, `x--`), el operador de disminución disminuye y devuelve el valor antes de disminuir.

Si se usamos la forma de prefijo, operador antes del operando (por ejemplo, `--x`), el operador de disminución disminuye y devuelve el valor después de disminuir.

Ejemplos
--------

### Usando Sufijo


```js
let x = 3;
y = x--;

// y = 3
// x = 2
```

### Usando Prefijo


```js
let a = 2;
b = --a;

// a = 1
// b = 1
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-postfix-decrement-operator |

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

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

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

* Addition operator
* Subtraction operator
* Division operator
* Multiplication operator (en-US)
* Remainder operator
* Exponentiation operator (en-US)
* Increment operator (en-US)
* Unary negation operator (en-US)
* Unary plus operator (en-US)
Igualdad Estricta (===)
=======================

El operador de estricta igualdad (`===`) revisa si dos operandos son iguales y produce un resultado Booleano. A diferencia del operador de igualdad regular (==), el operador de estricta igualdad siempre considera que los operandos de distinto tipo de valor son diferentes y nunca similares.

Pruébalo
--------

The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.Sintaxis
--------
```

x === y
```

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

Los operadores de estricta igualdad (`===` y `!==`) usan el Algoritmo Estricto Comparativo de Igualdadpara comparar dos operandos:

* Si los operandos son de diferente tipo de valor, produce `false`.
* Si ambos operandos son objetos, produce `true` solo si se refiere al mismo objeto.
* Si ambos operandos son de tipo `null` o ambos operandos son `undefined`, produce `true`.
* Si cualquier operando es de tipo NaN, produce `false`.
* En otros casos, compara los valores de ambos operandos:
    + Los números deben tener el mismo valor numérico, aunque `+0` y `-0` son considerados como del mismo valor.
    + Los strings deben tener los mismos caracteres en el mismo orden.
    + Los booleanos deben ambos ser `true` o ambos ser `false`.

La diferencia más notable entre este operador y el operador de igualdad regular (`==`) es que si los operandos son de distinto tipo de valor, el operador `==` intenta convertir los valores a un mismo tipo de dato antes de compararlos.

Ejemplos
--------

### Comparando operandos del mismo tipo


```js
console.log("hello" === "hello"); // true
console.log("hello" === "hola"); // false

console.log(3 === 3); // true
console.log(3 === 4); // false

console.log(true === true); // true
console.log(true === false); // false

console.log(null === null); // true
```

### Comparando operandos de distinto tipo


```js
console.log("3" === 3); // false

console.log(true === 1); // false

console.log(null === undefined); // false
```

### Comparando objetos


```js
const object1 = {
  name: "hello",
};

const object2 = {
  name: "hello",
};

console.log(object1 === object2); // false
console.log(object1 === object1); // true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-equality-operators |

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

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

También revisa
--------------

* Operador de igualdad
* Operador de desigualdad (en-US)
* Operador de estricta desigualdad (en-US)
Miembros
========

Resumen
-------

Los operadores de miembros proporcionan acceso a las propiedades y métodos de un objeto.

Un objeto es en realidad un *arreglo asociativo* (por ejemplo *map* ,*dictionary* ,*hash* ,*lookup table* ). Las *claves* en este arreglo son los nombres de las propiedades y los métodos (propiedades que hacen referencia a funciones). Hay dos modos de acceder a estas propiedades: notación por punto y notación por corchete (es decir, operador de subscripción).

Nota: La especificación ECMAScript etiqueta estos operadores como "property accessors" en vez de "operadores de miembro" (member operators).

### Notación por punto


```js
get = objeto.propiedad;
objeto.propiedad = set;
```


`propiedad` debe ser un identificador válido de JavaScript, esto es, una secuencia alfanumérica de caracteres, incluyendo también el guión bajo ("`_`") y el signo dolar ("`$`"), que no puede comenzar por un número. Por ejemplo, `objeto.$1` es válido, mientras que `objeto.1` no lo es.

Ejemplo:


```js
document.createElement("pre");
```


Aquí, el método llamado "createElement" se recupera de `document` y se le llama.

### Notación por corchetes


```js
get = objeto[nombre_propiedad];
objeto[nombre_propiedad] = set;
```


`nombre_propiedad` es una cadena. La cadena no tiene que ser un identificador válido; puede tener cualquier valor, por ejemplo "1foo", "!bar!", o incluso " " (un espacio).

Ejemplo:


```js
document["createElement"]("pre");
```


Esto hace exactamente lo mismo que el ejemplo anterior.

### Nombres de propiedades

Los nombres de propiedades deben ser cadenas. Esto significa que no pueden usarse objetos distintos a cadenas como claves en un objeto. Cualquier objeto que no sea una cadena, incluyendo números, se convierte al tipo cadena a través de su método `Object.toString`.

Ejemplos:


```js
var objeto = {};
objeto["1"] = "valor";
alert(objeto[1]);
```


Ésto tendrá como resultado "valor", ya que 1 se convertirá por tipo a '1'.


```js
var foo = { propiedad\_unica: 1 },
  bar = { propiedad\_unica: 2 },
  objeto = {};
objeto[foo] = "valor";
alert(objeto[bar]);
```


Ésto también tiene como resultado "valor", ya que tanto foo como bar se convierten a la misma cadena. En el motor de JavaScript SpiderMonkey, esta cadena sería `[objeto Object]`.

### Enlace a métodos

Un método no está enlazado al objeto del que es método. Específicamente, `this` no está establecido en un método, es decir, `this` no se refiere necesariamente a un objeto conteniendo el método. `this`, en cambio, se "pasa" mediante la llamada de función.

Vea enlace a métodos.

### Nota sobre `eval`

Los principiantes en JavaScript a menudo tienen el error de usar `eval` (en-US) cuando la notación por corchetes puede usarse a cambio. Por ejemplo, la siguiente sintaxis se ve a menudo en muchos scripts.


```js
x = eval("document.nombre\_formulario." + cadenaControlFormulario + ".value");
```


`eval` es lenta y se debería evitar en la medida de lo posible. Es mejor usar la notación por corchetes a cambio:


```js
x = document.nombre_formulario[cadenaControlFormulario].value;
```
in
==

El **operador `in`** devuelve `true` si la propiedad especificada está en el objeto especificado o su prototipo.Sintaxis
--------
```

prop in object
```

### Parámetros

`prop`

Una cadena o expresión númerica que representa el nombre de una propiedad o el índice de un array (lo que no sea un símbolo se forzará a string).

`object`

El objeto (o su cadena de prototipo) sobre el que comprobar si contiene la propiedad con el nombre especificado.

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

Los siguientes ejemplos muestran algunos de los usos del operador `in`.


```js
// Arrays
var arboles = new Array("secoya", "pino", "cedro", "roble", "arce");
0 in arboles; // devuelve true
3 in arboles; // devuelve true
6 in arboles; // devuelve false
"pino" in arboles; // devuelve false (debe especificar el número de índice,
// no el valor del índice)
"length" in arboles; // devuelve true (length es una propiedad de Array)

// Objetos predefinidos
"PI" in Math; // devuelve true

// Objetos personalizados
var micoche = { marca: "Honda", modelo: "Accord", año: 1998 };
"marca" in micoche; // devuelve true
"modelo" in micoche; // devuelve true
```


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


```js
var color1 = new String("verde");
"length" in color1; // devuelve true

var color2 = "coral";
"length" in color2; // genera un error (color2 no es un objeto String)
```

### Usando `in` con propiedades eliminadas o no definidas

Si se elimina una propiedad con el operador `delete`, el operador `in` devuelve `false` para esa propiedad.


```js
var micoche = { marca: "Honda", modelo: "Accord", año: 1998 };
delete micoche.marca;
"marca" in micoche; // devuelve false

var arboles = new Array("secoya", "pino", "cedro", "roble", "arce");
delete arboles[3];
3 in arboles; // devuelve false
```


Si se cambia una propiedad a `undefined` pero no se elimina, el operador `in` devuelve true para esa propiedad.


```js
var micoche = { marca: "Honda", modelo: "Accord", año: 1998 };
micoche.marca = undefined;
"marca" in micoche; // devuelve true
```



```js
var arboles = new Array("secayo", "pino", "cedro", "roble", "arce");
arboles[3] = undefined;
3 in arboles; // devuelve true
```

### Propiedades heredadas

El operador `in` devuelve `true` para propiedades en la cadena del prototipo.


```js
"toString" in {}; // devuelve true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-relational-operators |

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

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

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

* `for...in`
* `delete`
* `Object.prototype.hasOwnProperty()`
* `Reflect.has()` (en-US)
* Enumerability and ownership of properties (en-US)
Asignacion (=)
==============

El operador de asignación (=) se utiliza para asignar un valor a una variable. La operación de asignación evalúa el valor asignado. Es posible encadenar el operador de asignación para asignar un solo valor a múltiples variables

Pruébalo
--------

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

Operador: x = y
```

Ejemplos
--------

### Asignación


```js
// Asumimos las siguientes variables
// x = 5
// n = 10
// z = 25

x = n; // La variable x contiene el valor 10
x = n = z; // x = n (es decir 10) y z pisa el valor total remplazandolo por 25
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-assignment-operators |

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

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

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

* Assignment operators in the JS guide
new.target
==========

La propiedad **`new.target`** te permite detectar si una función o constructor fue llamado usando el operador new. En constructores y funciones instanciadas con el operador new, `new.target` devuelve una referencia al constructor o función. En llamadas a funciones normales, `new.target` es `undefined`.

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

new.target
```

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

La sintaxis `new.target` consiste en el keyword `"new`", un punto, y el nombre de propiedad `"target"`. Normalmente "`new."` sirve como contexto para el acceso a la propiedad, pero aquí, `"new."` no es realmente un objeto. En llamadas a constructores, sin embargo, `new.target` hace referencia al constructor invocado por new por lo que "`new.`" se convierte en un contexto virtual.

La propiedad `new.target` es una meta propiedad que está disponible para todas las funciones. En funciones flecha, `new.target` se refiere al `new.target` de la función que la contiene.

Ejemplos
--------

### new.target en llamadas a funciones

En llamadas a funciones normales (en contraposición a llamadas a constructores), `new.target` es `undefined`. Esto te permite detectar si la función fue llamada con new como constructor.


```js
function Foo() {
  if (!new.target) throw "Foo() debe ser llamado con new";
  console.log("Foo instanciado con new");
}

Foo(); // Lanza "Foo() debe ser llamado con new"
new Foo(); // escribe en el log "Foo instanciado con new"
```

### new.target en constructores

En constructores de clase, `new.target` hace referencia al constructor que fue directamente invocado por `new`. Este también es el caso si el constructor está en una clase padre y fue delegado desdes el constructor hijo.


```js
class A {
  constructor() {
    console.log(new.target.name);
  }
}

class B extends A {
  constructor() {
    super();
  }
}

var a = new A(); // escribe en el log "A"
var b = new B(); // escribe en el log "B"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-built-in-function-objects |

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

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

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

* Funciones
* Clases
* `new`
* `this`
expresión function\*
====================

La palabra clave **`function*`** puede ser utilizada para definir una función generadora en una expresión.

Pruébalo
--------

El código fuente de este ejemplo interactivo se encuentra almacenado en un repositorio GitHub. Si le gustaría contribuir al proyecto de ejemplos interactivos, por favor clone https://github.com/mdn/interactive-examples y envíenos un pull request.

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

function* [nombre]([param1[, param2[, ..., paramN]]]) {
   sentencias
}
```

### Parámetros

`nombre`

Nombre de la función. Puede ser omitido, en cuyo caso la función es *anínima*. El nombre sólo es local al cuerpo de la función.

`paramN`

Nombre de un parámetro a ser pasado a la función. Una función puede tener hasta 255 argumentos.

`sentencias`

Sentencias que componen el cuerpo de la función.

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

Una expresión `function*` es muy similar y tiene casi la misma sintaxis que una `function* statement`. La principal diferencia entre una expresión `function*` y una sentencia `function*` es el *nombre de la función*, que en expresiones `function*` puede ser omitido para creaar funciones generadoras *anónimas*. Para más información vea también el capítulo acerca de funciones.

Ejemplos
--------

El siguiente ejemplo define una función generadora sin nombre y la asigna a `x`. La función produce el cuadrado de su argumento:


```js
var x = function\* (y) {
  yield y \* y;
};
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator-function-definitions |

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

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

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

* `Sentencia function*`
* Objeto `GeneratorFunction` (en-US)
* El protocolo iterable
* `yield`
* `yield*`
* Objeto `Function`
* `Sentencia function`
* `Expresión function`
* `Funciones y alcance de funciones` (en-US)
import.meta
===========

El objeto **`import.meta`** expone el contenido especifico de la metadata al módulo JavaScript. Este contiene informacion sobre el módulo, como por ejemplo, la URL del mismo.

Syntax
------
```

import.meta
```

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

La sintasis consiste de la palabra clave `import`,un punto, y un identificador `meta`. Normalmente, la parte a la izquierda del punto es el objeto sobre el cual la accion es realizada, pero aqui `import` no es realmente un objeto.

El objeto `import.meta` es creado por la implementacion ECMAScript , con un prototipo `null` . El objeto es extensible y sus propiedades son grabables, editables y enumerables.

Ejemplos
--------

### Usando import.meta

Dado un módulo `my-module.js`


```html
<script type="module" src="my-module.js"></script>
```


puedes acceder a la meta información sobre el módulo usando el objeto `import.meta`.


```js
console.log(import.meta); // { url: "file:///home/user/my-module.js" }
```


Este retorna un objeto con una propiedad `url` indicando la URL base del módulo.Esta será la URL de la que el script fue obtenido, por scripts externos, o la URL base del documento que contiene el documento, por scripts inline.

Nota que este incluirá parametros de la consulta y/o el hash (ej: seguido del `?` or `#`).

Por ejemplo, con el siguiente HTML:


```html
<script type="module">
 import "./index.mjs?someURLInfo=5";
</script>
```


..El siguiente archivo JavaScript registrará el parámetro `someURLInfo`:


```js
// index.mjs
new URL(import.meta.url).searchParams.get("someURLInfo"); // 5
```


Lo mismo aplica cuando un archivo importa otro:


```js
// index.mjs
import "./index2.mjs?someURLInfo=5";

// index2.mjs
new URL(import.meta.url).searchParams.get("someURLInfo"); // 5
```


Nota que mientras Node.js pasa en la consulta los parámetros (o el hash ) como en el último ejemplo, a partir de Node 14.1.0, una URL con parametros en la consulta fallará cuando se carguen en el formato `node --experimental-modules index.mjs?someURLInfo=5` (es tratado como un archivo en lugar de una URL en este contexto).

Tal argumento específico del archivo podria ser complementario al usado en toda la aplicacion `location.href` (con consultas strings o hash añadidas despues de la ruta HTML) (o en Node.js, mediante `process.argv`).

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

| Specification |
| --- |
| ECMAScript Language Specification # prod-ImportMeta |
| HTML Standard # hostgetimportmetaproperties |

Browser compatibility
---------------------

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

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

* `import`
* `export`