recursal/MDN huggingface dataset:
class
=====

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

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

* Learn more
* See full compatibility
* Report feedback
La **declaración class** crea una nueva clase con el nombre proporcionado utilizando la herencia basada en prototipos

También se puede definir una clase usando una expresión de clase. Pero a diferencia de las expresiones de clases, la declaración de clases no permite que una clase existente sea declarada de nuevo y en caso de hacerse, lanzará un error de tipo.

Sintaxis
--------


```js
class name [extends] {
  // Contenido de la clase
}
```

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

De la misma manera que con las expresiones de clase, el contenido de una clase se ejecuta en modo estricto.

Las declaraciones de clases no están izadas (al contrario que las declaraciones de funciones).

Ejemplos
--------

### Declaración sencilla de una clase

En el siguiente ejemplo, primero definimos la clase `Polygon`, luego extendemos de ella para crear la clase `Square`. Notar que `super()`, utilizado en el constructor, sólo puede ser llamado dentro del constructor y debe ser llamado antes de que la palabra clave `this` pueda ser usada.


```js
class Polygon {
  constructor(height, width) {
    this.name = "Polygon";
    this.height = height;
    this.width = width;
  }
}

class Square extends Polygon {
  constructor(length) {
    super(length, length);
    this.name = "Square";
  }
}
```

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

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

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

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

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

* `declaración de funciones`
* `expresión de clases`
* Clases
label
=====

Resumen
-------

Proporciona una sentencia con un identificador al que se puede referir al usar las sentencias `break` o `continue`.

Por ejemplo, puede usar una etiqueta para identificar un bucle, y entonces usar las sentencias `break` o `continue` para indicar si un programa debería interrumpir el bucle o continuar su ejecución.

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

etiqueta :sentencia
```


`etiqueta`

Cualquier identificador JavaScript que no sea una palabra reservada.

`sentencia`

Sentencias. `break` puede ser usado con cualquier sentencia etiquetada, y `continue` puede usarse con bucles etiquetados de sentencias.

Ejemplos
--------

Para un ejemplo de una sentencia label usando `break`, vea `break`. Para un ejemplo de una sentencia label usando `continue`, vea `continue`.

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

* `break`
* `continue`
function\*
==========

La declaración **`function*`** (la palabra clave `function` seguida de un asterisco) define una *función generadora*, que devuelve un objeto `Generator`.

También puedes definir funciones generadoras usando el constructor `GeneratorFunction` (en-US) y una `function* expression`.

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

function* nombre([param[, param[, ... param]]]) {
   instrucciones
}
```


`nombre`

El nombre de la función.

`param`

El nombre de los argumentos que se le van a pasar a la función. Una función puede tener hasta 255 argumentos.

`instrucciones`

Las instrucciones que componen el cuerpo de la función.

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

Los generadores son funciones de las que se puede salir y volver a entrar. Su contexto (asociación de variables) será conservado entre las reentradas.

La llamada a una función generadora no ejecuta su cuerpo inmediatamente; se devuelve un objeto iterador para la función en su lugar. Cuando el metodo `next()` del iterador es llamado , el cuerpo de la función generadora es ejecutado hasta la primera expresión `yield`, la cual especifica el valor que será retornado por el iterador o con, `yield*`, delega a otra función generadora. El método `next()` retorna un objeto con una propiedad *value* que contiene el valor bajo el operador yield y una propiedad *done* que indica, con un booleano, si la función generadora ha hecho yield al último valor.

Ejemplos
--------

### Ejemplo simple


```js
function\* idMaker() {
  var index = 0;
  while (index < 3) yield index++;
}

var gen = idMaker();

console.log(gen.next().value); // 0
console.log(gen.next().value); // 1
console.log(gen.next().value); // 2
console.log(gen.next().value); // undefined
// ...
```

### Ejemplo con yield\*


```js
function\* anotherGenerator(i) {
  yield i + 1;
  yield i + 2;
  yield i + 3;
}

function\* generator(i) {
  yield i;
  yield\* anotherGenerator(i);
  yield i + 10;
}

var gen = generator(10);

console.log(gen.next().value); // 10
console.log(gen.next().value); // 11
console.log(gen.next().value); // 12
console.log(gen.next().value); // 13
console.log(gen.next().value); // 20
```

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.

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

* `function* expression`
* `GeneratorFunction` (en-US) object
* The Iterator protocol (en-US)
* `yield`
* `yield*`
* `Function` object
* `function declaration`
* `function expression`
* `Functions and function scope` (en-US)
* Other web resources:
    + Regenerator an ES2015 generator compiler to ES5
    + Forbes Lindesay: Promises and Generators: control flow utopia — JSConf EU 2013
    + Hemanth.HM: The New gen of \*gen(){}
    + Task.js
debugger
========

La sentencia **debugger** invoca cualquier funcionalidad de depuración disponible, tiene la misma función que un breakpoint. Si la funcionalidad de depuración no está disponible, esta sentencia no tiene efecto alguno.

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

debugger;
```

Ejemplos
--------

El siguiente ejemplo muestra un bloque de código donde ha sido insertada una sentencia debugger, para invocar el depurador (si existe) cuando la función es ejecutada.


```js
function codigoPotencialmenteDefectuoso() {
  debugger;
  // realizar paso a paso o examinar código que contiene
  // potenciales errores
}
```


Cuando el depurador es invocado, la ejecución se detiene en la sentencia debugger. Es como un punto de interrupción en el script.

![Paused at a debugger statement.](/es/docs/Web/JavaScript/Reference/Statements/debugger/screen_shot_2014-02-07_at_9.14.35_am.png)

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-debugger-statement |

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

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

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

* Debugging JavaScript
* The Debugger in the Firefox Developer Tools
for
===

Resumen
-------

Crea un bucle que consiste en tres expresiones opcionales, encerradas en paréntesis y separadas por puntos y comas, seguidas de una sentencia ejecutada en un bucle.

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

for ([expresion-inicial]; [condicion]; [expresion-final])sentencia
```


`expresion-inicial`

Una expresión (incluyendo las expresiones de asignación) o la declaración de variable. Típicamente se utiliza para usarse como variable contador. Esta expresión puede opcionalmente declarar nuevas variables con la palabra clave `var`. Estas variables no son locales del bucle, es decir, están en el mismo alcance en el que está el bucle `for`. El resultado de esta expresión es descartado.

`condicion`

Una expresión para ser evaluada antes de cada iteración del bucle. Si esta expresión se evalúa como verdadera, se ejecuta `sentencia`. Esta comprobación condicional es opcional. Si se omite, la condición siempre se evalúa como verdadera. Si la expresión se evalúa como falsa, la ejecución salta a la primera expresión que sigue al constructor de `for`.

`expresion-final`

Una expresión para ser evaluada al final de cada iteración del bucle. Esto ocurre antes de la siguiente evaluación de la `condicion`. Generalmente se usa para actualizar o incrementar la variable contador.

`sentencia`

Una sentencia que se ejecuta mientras la condición se evalúa como verdadera. Para ejecutar múltiples sentencias dentro del bucle, utilice una sentencia `block` (`{ ... }`) para agrupar aquellas sentecias.

### Ejemplos

#### Ejemplo: Usando `for`

La siguiente sentencia `for` comienza mediante la declaración de la variable `i` y se inicializa a `0`. Comprueba que `i` es menor que nueve, realiza las dos sentencias con éxito e incrementa `i` en 1 después de cada pase del bucle.


```js
for (var i = 0; i < 9; i++) {
  n += i;
  mifuncion(n);
}
```

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

* `break`
* `continue`
* `empty`
* `while`
* `do...while`
* `for...in`
* `for...of`
block
=====

Resumen
-------

Una sentencia block se utiliza para agrupar cero o más sentencias. Este grupo block se delimita por un par de llaves.

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

{ sentencia_1; sentencia_2; ... sentencia_n; }
```


`sentencia_1`, `sentencia_2`, `sentencia_n`

Sentencias agrupadas dentro de una sentencia block.

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

Esta sentencia se utiliza comúnmente para controlar sentencias de flujo (es decir `if`, `for`, `while`). Por ejemplo:


```js
while (x < 10) {
  x++;
}
```


Las variables declaradas con `var` **no** tienen alcance de bloque(block scope). Las variables introducidas dentro de un grupo block tienen el alcance de la función que lo contiene o del script, y los efectos de su asignación persisten más allá del grupo block en sí mismo. En otras palabras, las sentencias block no incluyen ningún alcance. Aunque los grupos block "en solitario" (standalone) son una sintaxis válida, usted no querrá utilizar grupos block en solitario en JavaScript, ya que ellos no hacen lo que parecen, si piensa que funcionan de manera similar a los bloques en C o Java. Por ejemplo:


```js
var x = 1;
{
  var x = 2;
}
alert(x); // resultado 2
```


Este obtiene el resultado 2 ya que la sentencia `var x` dentro del grupo block tiene el mismo alcance que la sentencia `var x` antes del mismo. En C o Java, el código equivalente tendría como resultado 1.

#### Con `let` y const

Por el contrario, las variables declaradas con `let` y `const` tienen alcance de bloque.


```js
let x = 1;
{
  let x = 2;
}
console.log(x); // logs 1
```


El alcance `x = 2` es limitado solamente al bloque en el que está definido.

Lo mismo para `const`:


```js
const c = 1;
{
  const c = 2;
}
console.log(c); // logs 1 y no lanza SyntaxError...
```


Tenga en cuenta que la variable `const c = 2 con alcance de bloque`, ***no* lanza** un `SyntaxError:` El identificador 'c' ya ha sido declarado. Esto es porque **se puede declarar de forma única** dentro del bloque, sin interferir con la otra que tiene un alcance global.

#### Con `function`

La declaración de una función también tiene un alcance limitado dentro del bloque donde se produce la declaración:


```js
nacion("frances"); // TypeError: nacion no es una función
{
  function nacion(nacionalidad) {
    console.log("Yo soy " + nacionalidad);
  }
  nacion("español"); // correcto. logs Yo soy español
}
```

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

* `while`
do...while
==========

La sentencia (hacer mientras) crea un bucle que ejecuta una sentencia especificada, hasta que la condición de comprobación se evalúa como falsa. La condición se evalúa después de ejecutar la sentencia, dando como resultado que la sentencia especificada se ejecute al menos una vez.

Pruébalo
--------

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

do
  sentencia
while (condición);
```


`sentencia`

Una sentencia que se ejecuta al menos una vez y es reejecutada cada vez que la condición se evalúa a verdadera. Para ejecutar múltiples sentencias dentro de un bucle, utilice la sentencia `block` (`{ ... }`) para agrupar aquellas sentencias.

`condición`

Una expresión se evalúa después de cada pase del bucle. Si `condición` se evalúa como verdadera, la `sentencia` se re-ejecuta. Cuando `condición` se evalúa como falsa, el control pasa a la siguiente sentencia hacer mientras.

Ejemplos
--------

### Usando `hacer mientras`

En el siguiente ejemplo, el bucle hacer mientras itera al menos una vez y se reitera hasta que `i` ya no sea menor que 5.


```js
do {
  i += 1;
  document.write(i);
} while (i < 5);
```

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

* `while`
* `for`
if...else
=========

Resumen
-------

Ejecuta una sentencia si una condición específicada es evaluada como verdadera. Si la condición es evaluada como falsa, otra sentencia puede ser ejecutada.

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

if (condición) sentencia1 [else sentencia2]
```


`condición`

Una expresión que puede ser evaluada como verdadera o falsa.

`sentencia1`

Sentencia que se ejecutará si `condición` es evaluada como verdadera. Puede ser cualquier sentencia, incluyendo otras sentenccias `if` anidadas. Para ejecutar múltiples sentencias, use una sentencia `block` ({ ... }) para agruparlas.

`sentencia2`

Sentencia que se ejecutará si `condición` se evalúa como falsa, y exista una cláusula `else`. Puede ser cualquier sentencia, incluyendo sentencias block y otras sentencias `if` anidadas.

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

Multiples sentencias `if...else` pueden ser anidadas para crear una cláusula `else if`:
```

if (condición1)
   sentencia1
else if (condición2)
   sentencia2
else if (condición3)
   sentencia3
...
else
   sentenciaN
```


Para entender como esto funciona, así es como se vería si el anidamiento hubiera sido indentado correctamente:
```

if (condición1)
   sentencia1
else
   if (condición2)
      sentencia2
   else
      if (condición3)
      ...
```


Para ejecutar varias sentencias en una cláusula, use una sentencia block (`{ ... }`) para agruparlas. Generalmente, es una buena práctica usar siempre sentencias block, especialmente en código que incluya sentencias if anidadas:


```js
if (condición) {
  sentencia1;
} else {
  sentencia2;
}
```


No confundir los valores primitivos `true` y `false` con los valores true y false del objeto `Boolean`. Cualquier valor diferente de `undefined`, `null`, `0`, `-0`, `NaN`, o la cadena vacía (`""`), y cualquier objecto, incluso un objeto Boolean cuyo valor es false, se evalúa como verdadero en una sentencia condicional. Por ejemplo:


```js
var b = new Boolean(false);
if (b) // Esta condición se evalúa como verdadera
```

Ejemplos
--------

### Ejemplo: Uso de `if...else`


```js
if (cipher_char == from_char) {
  result = result + to_char;
  x++;
} else result = result + clear_char;
```

### Ejemplo: Asignación en una expresión condicional

Es aconsejable no usar asignaciones simples en una expresión condicional, porque la asignación puede ser confundida con igualdad (operador relacional) cuando se lee el código. Por ejemplo, no use el siguiente código:


```js
if ((x = y)) {
  /\* sentencia \*/
}
```


Si realmente necesita una asignación dentro de una exprsión condicional, una práctica común es poner paréntesis adicionales alrededor del la asignación, por ejemplo:


```js
if ((x = y)) {
  /\* sentencia \*/
}
```

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

* `block`
* `switch`
function
========

Resumen
-------

Declara una función con los parámetros especificados.

Puede también definir funciones usando el constructor `Function` y el `function` (expresión function).

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

function nombre([parametro1] [,parametro2] [..., parametroN]) {sentencias}
```


`nombre`

El nombre de la función.

`parametroN`

El nombre de un argumento que se pasa a la función. Una función puede tener hasta 255 argumentos.

`sentencias`

Las sentencias que comprenden el cuerpo de la función.

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

Para devolver un valor, la función debe tener una sentencia `return` que especifica el valor a devolver.

Una función creada con la sentencia `function` es un objeto `Function` y tiene todas las propiedades, métodos, y comportamiento de los objetos `Function`. Vea `Function` para información detallada sobre funciones.

Una función puede también ser declarada dentro de una expresión. En este caso la función es normalmente anónima. Vea `function expression` para más información acerca de `function` (expresión function).

Las funciones pueden declararse condicionalmente. Es decir, una definición de una función puede estar anidada dentro de una sentecia `if`. Técnicamente, tales declaraciones no son en realidad declaraciones de funciones; son expresiones function (expresiones de función).

Ejemplo
-------

### Ejemplo: Usando `function`

El siguiente código declara una función que devuelve la cantidad total de ventas, cuando se da el número de unidades vendidas de productos `a`, `b`, y `c`.


```js
function calcular\_ventas(unidades\_a, unidades\_b, unidades\_c) {
  return unidades_a \* 79 + unidades_b \* 129 + unidades_c \* 699;
}
```

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

* Funciones
* `Function`
* Operadores`function`
break
=====

Resumen
-------

Termina el bucle actual, sentecia switch o label y transfiere el control del programa a la siguiente sentencia a la sentecia de terminación de éstos elementos.

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

break [etiqueta];
```


`etiqueta`

Identificador asociado con la etiqueta de la sentencia.

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

La sentencia `break` incluye una etiqueta opcional que permite al programa salir de una sentencia etiquetada. La sentencia `break` necesita estar anidada dentro de la sentencia etiquetada. La sentencia etiquetada puede ser cualquier tipo de sentencia; no tiene que ser una sentencia de bucle.

### Ejemplos

#### Ejemplo: Usando `break`

La siguiente función tiene una sentencia que termina el bucle `while` cuando `i` es 3, y entonces devuelve el valor 3 \* `x`.


```js
function comprobarBreak(x) {
  var i = 0;
  while (i < 6) {
    if (i == 3) break;
    i++;
  }
  return i \* x;
}
```

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

* `continue`
* `label`
* `switch`
while
=====

Resumen
-------

Crea un bucle que ejecuta una sentencia especificada mientras cierta condición se evalúe como verdadera. Dicha condición es evaluada antes de ejecutar la sentencia

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

while (condicion)
  sentencia
```


`condicion`

Una expresión que se evalúa antes de cada paso del bucle. Si esta condición se evalúa como verdadera, se ejecuta `sentencia`. Cuando la condición se evalúa como false, la ejecución continúa con la `sentencia` posterior al bucle `while`.

`sentencia`

Una sentecia que se ejecuta mientras la condición se evalúa como verdadera. Para ejecutar múltiples sentencias dentro de un bucle, utiliza una sentencia `block` (`{ ... }`) para agrupar esas sentencias.

Ejemplos
--------

El siguiente bucle `while` itera mientras `n` es menor que tres.


```js
n = 0;
x = 0;
while (n < 3) {
  n++;
  x += n;
}
```


Cada interación, el bucle incrementa `n` y la añade a `x`. Por lo tanto, `x` y `n` toman los siguientes valores:

* Después del primer pase: `n` = 1 y `x` = 1
* Después del segundo pase: `n` = 2 y `x` = 3
* Después del tercer pase: `n` = 3 y `x` = 6

Después de completar el tercer pase, la condición `n` < 3 no será verdadera más tiempo, por lo que el bucle terminará.

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

* `do...while`
* `for`
AggregateError
==============

El objeto **`AggregateError`** representa un error cuando se deben agrupar varios errores en un solo error. Se lanza cuando una operación necesita informar de varios errores, por ejemplo, `Promise.any()` (en-US), cuando todas las promesas que se le pasan son rechazadas.

Constructor
-----------

`AggregateError()` (en-US)

Crea un nuevo objeto `AggregateError`.

Propiedades de la instancia
---------------------------

`AggregateError.prototype.message`

Mensaje de error, el valor predeterminado es `""` (la cadena vacía).

`AggregateError.prototype.name`

Nombre del error, el valor predeterminado es `AggregateError`.

Ejemplos
--------

### Capturar un error agregado


```js
Promise.any([Promise.reject(new Error("algún error"))]).catch((e) => {
  console.log(e instanceof AggregateError); // true
  console.log(e.message); // "Todas las promesas rechazadas"
  console.log(e.name); // "AggregateError"
  console.log(e.errors); // [ Error: "algún error" ]
});
```

### Crear un `AggregateError`


```js
try {
  throw new AggregateError([new Error("algún error")], "Hola");
} catch (e) {
  console.log(e instanceof AggregateError); // true
  console.log(e.message); // "Hola"
  console.log(e.name); // "AggregateError"
  console.log(e.errors); // [ Error: "algún error" ]
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-aggregate-error-objects |

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

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

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

* `Error`
isFinite()
==========

Resumen
-------

La función global **`isFinite()`** determina si el valor que se le pasa como argumento es un numero finito. Si es necesario, realiza una conversión a un numero al parametro pasado.

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

isFinite(testValue)
```

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

`testvalue`

Valor a ser evaluado.

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

`isFinite` es una función de alto nivel y no está asociada a ningún objeto.

Puede usar esta función para determinar si un número es un número finito. La función `isFinite` examina el número de su argumento. Si el argumento es `NaN`, infinito positivo o infinito negativo, este método devuelve `false`, de otro modo devuelve `true`.

Ejemplos
--------


```js
isFinite(Infinity); // falso
isFinite(NaN); // falso
isFinite(-Inifinity); // falso

isFinite(0); // verdadero
isFinite(2e64); // verdadero

isFinite("0"); // verdadero, hubiera sido falso en el caso de usar Number.isFinite("0") que es mas robusta
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-isfinite-number |

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

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

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

* **`Number.isFinite()`**
* **`Number.NaN()`**
* **`Number.POSITIVE_INFINITY`**
* **`Number.NEGATIVE_INFINITY`**