recursal/MDN huggingface dataset:
static
======

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 palabra clave **static** define un método estático para una clase.

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

static methodName() { ... }
```

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

Los métodos estáticos son llamados sin instanciar su clase. Son habitualmente utilizados para crear funciones para una aplicación.

Ejemplos
--------

El siguiente ejemplo demuestra varias cosas. Una de ellas es cómo un método estático es implementado en una clase, otra es que una clase con un miembro estático puede ser sub-claseada. Finalmente demuestra cómo un método estático puede (y cómo no) ser llamado.


```js
class Tripple {
  static tripple(n) {
    n = n || 1;
    return n \* 3;
  }
}

class BiggerTripple extends Tripple {
  static tripple(n) {
    return super.tripple(n) \* super.tripple(n);
  }
}

console.log(Tripple.tripple());
console.log(Tripple.tripple(6));
console.log(BiggerTripple.tripple(3));
var tp = new Tripple();
console.log(tp.tripple()); //Logs 'tp.tripple is not a function'.
```

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.

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

* `class` expression
* `class` declaration
* Classes
extends
=======

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 palabra clave **extends** es usada en la declaración o expresión de clases, para crear una clase hija de otra.

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

class ChildClass extends ParentClass { ... }
```

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

La palabra clave `extends` se puede usar para crear una subclase a partir de clases personalizadas, así como sus objetos incorporados.

La propiedad `.prototype` de la nueva subclase debe ser un `Object` o `null`.

Ejemplos
--------

### Como usar `extends`

El primer ejemplo crea una clase con el nombre `Square` a partir de una clase llamada `Polygon`. Este ejemplo ha sido extraido del siguiente live demo (código fuente).


```js
class Square extends Polygon {
  constructor(length) {
    // Aquí se invoca el constructor de la clase padre con longitud
    // proporcionada por el ancho y alto de Polygon
    super(length, length);
    // Nota: En las clases extendidas, se debe llamar a super()
    // antes de poder usar 'this'. El no hacerlo provocará un reference error.
    this.name = "Square";
  }

  get area() {
    return this.height \* this.width;
  }

  set area(value) {
    this.area = value;
  }
}
```

### Como usar `extends` con objetos incorporados

Este ejemplo extiende el objeto incorporado `Date`. Este ejemplo ha sido extraido del siguiente live demo (código fuente).


```js
class myDate extends Date {
  constructor() {
    super();
  }

  getFormattedDate() {
    var months = [
      "Jan",
      "Feb",
      "Mar",
      "Apr",
      "May",
      "Jun",
      "Jul",
      "Aug",
      "Sep",
      "Oct",
      "Nov",
      "Dec",
    ];

    return (
      this.getDate() + "-" + months[this.getMonth()] + "-" + this.getFullYear()
    );
  }
}
```

### Extendiendo de `null`

Extender de `null` es como hacerlo de una clase normal, excepto que el objeto prototype no hereda de `Object.prototype` (en-US).


```js
class nullExtends extends null {
  constructor() {}
}

Object.getPrototypeOf(nullExtends); // Function.prototype
Object.getPrototypeOf(nullExtends.prototype); // null
```

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

* Clases
* super
constructor
===========

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
El método constructor es un metodo especial para crear e inicializar un objeto creado a partir de una clase.

El código fuente para este ejemplo interactivo se encuentra almacenado en un repositorio de Github. Si quieres contribuir al proyecto de ejemplos interactivos, por favor clona https://github.com/mdn/interactive-examples y envíanos una solicitud para extraer el código (pull request).

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

constructor([argumentos]) { ... }
```

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

Sólo puede haber un método especial con el nombre de "constructor" en una clase. Un error de sintaxis será lanzado, si la clase contiene más de una ocurrencia de un método constructor.

Un constructor puede utilizar la palabra clave super para llamar al constructor de una clase padre.

Si no especifica un método constructor, se utiliza un constructor predeterminado.

Ejemplos
--------

### Usando el método constructor

Este fragmento de código se toma de la classes sample (live demo).


```js
class Square extends Polygon {
  constructor(length) {
    // Aquí, llama al constructor de la clase padre con sus longitudes
    // contemplando la anchura y la altura del Polígono
    super(length, length);
    // Nota: En las clases derivadas, super() se debe llamar primero
    // Se puede utilizar "this". Dejando esto causará un error de
    //referencia.
    this.name = "Square";
  }

  get area() {
    return this.height \* this.width;
  }

  set area(value) {
    this.area = value;
  }
}
```

### Constructores por defecto

Si no especifica un método constructor, se utiliza un constructor predeterminado. Para las clases base, el constructor por defecto es:


```js
constructor() {}
```


Para las clases derivadas, el constructor por defecto es:


```js
constructor(...args) {
  super(...args);
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-static-semantics-constructormethod |

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

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

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

* super()
* `class` expression
* `class` declaration
* Classes
ReferenceError: "x" is not defined
==================================
```

ReferenceError: "x" no está definida.
```

Tipo de error
-------------

`ReferenceError`¿Qué está mal?
--------------

Hay una variable no existente que está siendo referida en algún lugar. Esta variable necesita ser declarada o se debe comprobar su disponibilidad en el ámbito actual del script.

**Nota:** Cuando una librería es cargada (como por ejemplo jQuery) asegúrese de que se haya cargado antes de intentar acceder a sus variables, como por ejemplo "$". Ponga la etiqueta `<script>` (en-US), que carga la librería antes del código que la utiliza.

Ejemplo
-------

### Variable no declarada


```js
foo.substring(1); // ReferenceError: foo no está declarada.
```


La variable "foo" no está declarada en ninguna parte. La variable debe ser alguna cadena para que el método `String.prototype.substring()` funcione correctamente.


```js
var foo = "bar";
foo.substring(1); // "ar"
```

### Contexto erróneo

Una variable necesita estar disponible en el contexto actual de ejecución. No se puede acceder a las variables definidas dentro de una función desde fuera de dicha función, debido a que la variable está definida solamente dentro de la función.


```js
function numbers() {
  var num1 = 2,
    num2 = 3;
  return num1 + num2;
}

console.log(num1); // ReferenceError num1 sin definir.
```


Sin embargo, una función puede acceder a todas las variables y funciones definidas dentro del ámbito en la cual ha sido definida. Es decir, una función en el contexto global puede acceder a todas las variables definidas en el contexto global.


```js
var num1 = 2,
  num2 = 3;

function numbers() {
  return num1 + num2;
}

console.log(num1); // 2
```

Temas relacionados
------------------

* Ámbito
* Guía; declarando variables en JavaScript
* Guía; contexto de la función en Java Script
SyntaxError: indicador de expresión regular no válido "x"
=========================================================

La excepción de JavaScript "indicador de expresión regular no válido" se produce cuando las indicadores, definidas después de la segunda barra en la expresión regular literal, no son de `g`, `i`, `m`, `s`, `u` o `y`.

Mensaje
-------
```

SyntaxError: error de sintaxis en la expresión regular (Edge)
SyntaxError: marca de expresión regular no válida "x" (Firefox)
SyntaxError: indicadores de expresión regular no válidos (Chrome)
```

Tipo `Error`
------------

`SyntaxError`¿Qué salió mal?
---------------

Hay indicadores de expresión regular no válidos en el código. En una expresión regular literal, que consiste en un patrón encerrado entre barras, los indicadores se definen después de la segunda barra. También se pueden definir en la función constructora del objeto `RegExp` (segundo parámetro). Los indicadores de expresión regular se pueden usar por separado o juntos en cualquier orden, pero solo hay seis de ellos en ECMAScript.

Para incluir una bandera con la expresión regular, usa esta sintaxis:


```js
var re = /patrón/indicadores;
```


o


```js
var re = new RegExp("patrón", "indicadores");
```


| Bandera | Descripción |
| --- | --- |
| `g` | Búsqueda global. |
| i | Búsqueda que no distingue entre mayúsculas y minúsculas. |
| m | Búsqueda multilínea. |
| s | Permite que el punto (`.`) coincida con las nuevas líneas (agregado en ECMAScript 2018) |
| u | Unicode; trata el patrón como una secuencia de puntos de código Unicode |
| y | Realiza una búsqueda "pegajosa" que coincida a partir de la posición actual en la cadena de destino. Consulta `sticky` (en-US) |

Ejemplos
--------

Solo hay seis indicadores de expresión regular válidos.


```js
/foo/bar;

// SyntaxError: indicador de expresión regular no válido "b"
```


¿Tenías la intención de crear una expresión regular? Una expresión que contiene dos barras se interpreta como una expresión regular literal.


```js
let obj = {
  url: /docs/Web
};

// SyntaxError: indicador de expresión regular no válido "W"
```


¿O pretendías crear una cadena en su lugar? Agrega comillas simples o dobles para crear una cadena literal.


```js
let obj = {
  url: "/docs/Web",
};
```

### Indicadores de expresión regular válidos

Consulta la tabla anterior para ver las seis marcas de expresiones regulares válidas que están permitidas en JavaScript.


```js
/foo/g;
/foo/gims;
/foo/uy;
```

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

* `Expresiones regulares`
* Indicadores de RegEx – biblioteca de expresiones regulares que proporciona cuatro nuevos indicadores (`n`, `s`, `x`, `A`)
InternalError: too much recursion
=================================

Mensaje
-------
```

InternalError: too much recursion
```

Tipo de error
-------------

`InternalError`.

¿Qué ha ido mal?
----------------

Una función que se llama a sí misma es una función recursiva. Podemos decir que la recursión es análoga a un bucle. Ambos ejecutan el mismo código varias veces y ambos requieren de una condición de fin (para evitar un bucle infinito o recursión infinita). Cuando hay recursión infinita o mucha recursión, JavaScript lanza este error.

Ejemplos
--------

Esta función recursiva se ejecuta 10 veces, debido a la condición de salida.


```js
function loop(x) {
  if (x >= 10) {
    // "x >= 10" es la condición de salida
    return;
  }
  // hacer cosas
  loop(x + 1); // llamada recursiva
}
loop(0);
```


Si establecemos esta condición para un valor muy alto, no funcionará:


```js
function loop(x) {
  if (x >= 1000000000000) {
    return;
  }
  // hacer cosas
  loop(x + 1);
}
loop(0);

// InternalError: too much recursion (demasiada recursión)
```

See also
--------

* Recursion
* Recursive functions
ReferenceError: reference to undefined property "x"
===================================================

Mensaje
-------
```

ReferenceError: reference to undefined property "x" (Firefox)
```

Tipo de error
-------------

Advertencia `ReferenceError` únicamente en modo estricto.

¿Qué salió mal?
---------------

El script intentó acceder a una propiedad no definida en un objeto. Hay dos formas de acceder a las propiedades; vea la página operadores de miembros para aprender más sobre ellas.

Los errores sobre referencias a propiedades no definidas ocurren únicamente en el modo de código estricto. En el modo no estricto, estos intentos de obtener propiedades no definidas son silenciosamente ignorados.

Ejemplos
--------

### Casos inválidos

En este caso, la propiedad `bar` no está definida, produciéndose un `ReferenceError`.


```js
"use strict";

var foo = {};
foo.bar; // ReferenceError: reference to undefined property "bar"
```

### Casos válidos

Para evitar este error, es necesario ya sea definir la propiedad `bar` en el objeto o verificar su existencia antes de leerla; una manera de hacerlo es usar el método `Object.prototype.hasOwnProperty()`, como en el siguiente ejemplo:


```js
"use strict";

var foo = {};

// Definir la propiedad bar

foo.bar = "luna";
console.log(foo.bar); // "luna"

// Prueba para asegurarse que bar existe antes de leerla

if (foo.hasOwnProperty("bar")) {
  console.log(foo.bar);
}
```

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

* Modo estricto
SyntaxError: missing ) after argument list
==========================================

Mensaje
-------
```

SyntaxError: missing ) after argument list
```

Tipo de error
-------------

`SyntaxError`.

¿Cuál es el problema?
---------------------

Hay un error en cómo la función es llamada. Esto puede ser un typo, la falta de un operador, o un string no escapado, por ejemplo.

Ejemplo
-------

Debido a que no se encuentra el operador "`+`" para concatenar el string, JavaScript espera que el argumento de la función `log` sea solo `"PI: "`. En tal caso, debería terminar con el paréntesis de cierre.


```js
console.log('PI: ' Math.PI);
// SyntaxError: missing ) after argument list
```


Puedes corregir la llamada del `log`, agregando el operador "`+`":


```js
console.log("PI: " + Math.PI);
// "PI: 3.141592653589793"
```

### Strings sin cierre


```js
console.log('"Java" + "Script" = "' + 'Java' + 'Script");
// SyntaxError: missing ) after argument list
```


Aquí JavaScript piensa que tienes `);` dentro del string y lo ignora, y termina no sabiendo que quisiste utilizar `);` para cerrar la función `console.log`. Para solucionar esto, podemos poner un `'` después del string "Script":


```js
console.log('"Java" + "Script" = "' + "Java" + 'Script"');
// '"Java" + "Script" = "JavaScript"'
```

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

* Funciones
SyntaxError: Unexpected token
=============================

Mensaje
-------
```

SyntaxError: expected expression, got "x"
SyntaxError: expected property name, got "x"
SyntaxError: expected target, got "x"
SyntaxError: expected rest argument name, got "x"
SyntaxError: expected closing parenthesis, got "x"
SyntaxError: expected '=>' after argument list, got "x"
```

Tipo de error
-------------

`SyntaxError`¿Que significa el error?
------------------------

Se esperaba un constructor específico de JavaScript pero se recibió algo diferente. Puede ser un simple error de tipeo.

Ejemplos
--------

### Se espera expresión

Cuando se llama a una función, no se permiten comas al final de los argumentos. JavaScript espera un argumento que puede ser en realidad cualquier tipo de expresión.


```js
Math.max(2, 42,);
// SyntaxError: expected expression, got ')'
```


El error se corrije omitiendo la coma o agregando otro argumento:


```js
Math.max(2, 42);
Math.max(2, 42, 13 + 37);
```

See also
--------

* `Math.max()`
RangeError: invalid date
========================

Mensaje
-------
```

RangeError: invalid date (Firefox)
RangeError: invalid time value (Chrome)
RangeError: Provided date is not in valid range (Chrome)
```

Tipo de error
-------------

`RangeError`¿Cuál es el problema?
---------------------

Se ha proporcionado una cadena con una fecha no válida para `Date` o `Date.parse()`.

Ejemplos
--------

### Casos no válidos

Las cadenas o fechas irreconocibles que contienen valores de elementos ilegales en cadenas con formato ISO suelen devolver `Nan`. Sin embargo, dependiendo de la implementación, las cadenas de formato ISO no conformes, también pueden lanzar `RangeError: invalid date`, como los siguientes casos en Firefox:


```js
new Date("foo-bar 2014");
new Date("2014-25-23").toISOString();
new Date("foo-bar 2014").toString();
```


Esto, sin embargo, devuelve `NaN` en Firefox:


```js
Date.parse("foo-bar 2014"); // NaN
```


Para más información, consulte la documentación de `Date.parse()`.

### Casos válidos


```js
new Date("05 October 2011 14:48 UTC");
```

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

* `Date`
* `Date.prototype.parse()`
* `Date.prototype.toISOString()`
RangeError: argument is not a valid code point
==============================================

Message
-------
```

RangeError: {0} is not a valid code point (Firefox)
RangeError: Invalid code point {0} (Chrome)
```

Tipo de error
-------------

`RangeError`¿Qué estuvo mal?
----------------

El metodo `String.fromCodePoint()` acepta solamente ***code point*** validos.

Un code point es un valor en el conjunto de caracteres Unicode; esto es, un rango de enteros que va desde `0` a `0x10FFFF`.

Usando valores `NaN`, enteros negativos (`-1`), no enteros (`3.14`), o valores mayores a `0x10FFFF` (`1114111`) no trabajarian con este metodo.

Ejemplos
--------

### Casos invalidos


```js
String.fromCodePoint("\_"); // RangeError
String.fromCodePoint(Infinity); // RangeError
String.fromCodePoint(-1); // RangeError
String.fromCodePoint(3.14); // RangeError
String.fromCodePoint(3e-2); // RangeError
String.fromCodePoint(NaN); // RangeError
```

### Casos validos


```js
String.fromCodePoint(42); // "\*"
String.fromCodePoint(65, 90); // "AZ"
String.fromCodePoint(0x404); // "\u0404"
String.fromCodePoint(0x2f804); // "\uD87E\uDC04"
String.fromCodePoint(194564); // "\uD87E\uDC04"
String.fromCodePoint(0x1d306, 0x61, 0x1d307); // "\uD834\uDF06a\uD834\uDF07"
```

Observe tambien
---------------

* `String.fromCodePoint()`
SyntaxError: missing formal parameter
=====================================

Mensaje
-------
```

SyntaxError: missing formal parameter (Firefox)
```

Tipo de error
-------------

`SyntaxError`¿Que es lo que fue mal?
-----------------------

"Formal parameter" es una forma adornada de decir "parámetro de función". Tu declaración de funcion carece de parámetros válidos. En la declaración de la función, los parámetros deben ser identifiers, no ningún valor cómo números, cadenas, o objetos. Declarar las funciones y invocarlas son dos pasos distindos. La declaración sólo requiere identificador/es. Es en la invocación que asignas los valores.

En JavaScript, los indentificadosres sólo pueden contener carácteres alfanuméricos (o "$" y "\_"), no pueden comenzar por número. Un identificador difiere de una **cadena** en que la cadena son datos, mientras que lo primero es parte del código.

Ejemplos
--------

Los parámetros de función deben ser identificadores cuando creas la función. Todas estas declaraciones fallan, ya que proveen parámetros:


```js
function square(3) {
  return number \* number;
};
// SyntaxError: missing formal parameter

function greet("Howdy") {
  return greeting;
};
// SyntaxError: missing formal parameter

function log({ obj: "value"}) {
  console.log(arg)
};
// SyntaxError: missing formal parameter
```


Necesitarás usar identificadores en las funciones:


```js
function square(number) {
  return number \* number;
}

function greet(greeting) {
  return greeting;
}

function log(arg) {
  console.log(arg);
}
```


Entonces podrás invocarlas con argumentos a tu gusto:


```js
square(2); // 4

greet("Howdy"); // "Howdy"

log({ obj: "value" }); // Object { obj: "value" }
```

También interesante
-------------------

* Otros errores relacionados con parámetros formales:
    + SyntaxError: Malformed formal parameter
    + SyntaxError: redeclaration of formal parameter "x" (en-US)
SyntaxError: missing ; before statement
=======================================

Mensaje
-------
```

SyntaxError: missing ; before statement
```

Tipo de Error
-------------

`SyntaxError`.

¿Qué salio mal?
---------------

Hay un punto y coma (`;`) faltando en alguna parte. Las declaraciones Javascript deben terminar con punto y coma. Algunas de ellas son afectadas por la inserción automática (ASI), pero en este caso necesitas colocar un punto y coma, de esta forma Javascript puede analizar el código fuente de forma correcta.

Sin embargo, algunas veces, este error es solo una consecuencia de otro error, como no separar las cadenas de texto correctamente, o usar *var* incorrectamente. Tal vez tengas muchos paréntesis en algún lugar. Revisa cuidadosamente la sintaxis cuando este error es lanzado.

Ejemplo
-------

### Cadenas de texto (strings) sin terminar

Este error puede pasar fácilmente cuando no se colocan las comillas correctamente y el motor de JavaScript esta esperando el final de la cadena. por ejemplo:


```js
var foo = 'El bar de Tom's';
// SyntaxError: missing ; before statement
```


En este caso se pueden usar comillas dobles para escapar del apóstrofe:


```js
var foo = "El bar de Tom's";
var foo = 'El bar de Tom\'s';
```


**Nota:** Este error suele pasar frecuentemene con cadenas del idioma Inglés

### Declarar propiedades con var

**No se pueden** declarar propiedades de un objeto o arreglo con una declaración `var`


```js
var obj = {};
var obj.foo = 'hola'; // SyntaxError: missing ; before statement

var array = [];
var array[0] = 'mundo'; // SyntaxError: missing ; before statement
```


En vez de esto. omitamos la palabra `var`:


```js
var obj = {};
obj.foo = "hola";

var array = [];
array[0] = "mundo";
```

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

* Automatic semicolon insertion (ASI)
* JavaScript statements
SyntaxError: "x" is not a legal ECMA-262 octal constant
=======================================================

Mensaje
-------
```

Warning: SyntaxError: 08 is not a legal ECMA-262 octal constant.
Warning: SyntaxError: 09 is not a legal ECMA-262 octal constant.
```

Tipo de Error
-------------

`SyntaxError` warning in strict mode only.

Que salio mal ?
---------------

Los literales decimales pueden comenzar con un cero (0) seguido de otro dígito decimal, pero Si todos los dígitos después del 0 inicial son más pequeños que 8, el número se interpreta como un número octal. Pero este no es el caso con 08 y 09, JavaScript advierte sobre ello.

Tenga en cuenta que las literales octales y las secuencias de escape octal están obsoletas y presentarán una advertencia de depreciación adicional. Con ECMAScript 6 y posteriores, la sintaxis utiliza un cero a la izquierda seguido de una letra latina en minúscula o mayúscula "O" (0o o 0O). Consulte la página sobre gramática léxica para obtener más información.

Ejemplos
--------

### Numeros octales invalidos


```js
08;
09;
// SyntaxError: 08 is not a legal ECMA-262 octal constant
// SyntaxError: octal literals and octal escape sequences are deprecated
```

### Números octales válidos

Utilice el cero inicialmente seguido de la letra "o";


```js
0O755;
0o644;
```

Ver Tambien
-----------

* Gramatica lexica