recursal/MDN huggingface dataset:
RangeError: invalid array length
================================

Mensaje
-------
```

RangeError: invalid array length (Firefox)
RangeError: Invalid array length (Chrome)
RangeError: Invalid array buffer length (Chrome)
```

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

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

Una longitud de array inválida puede presentarse en éstas situaciones:

* Cuando se crea un `Array` o un `ArrayBuffer` el cual tiene una longitud negativa o es igual o mayor a 2^32, o
* cuando se define la propiedad `Array.length` a un valor el cual es negativo o es igual o mayor a 2^32.

¿Por qué el `Array` y `ArrayBuffer` tienen longitud limitada? La propiedad de longitud de un `Array` o un `ArrayBuffer` está representada con un entero sin signo de 32 bits, el cual sólo puede almacenar valores que estén en el rango de 0 a (2^32)-1.

Si estás creando un `Array` usando el constructor, es mejor que utilices la notación literal, ya que el primer argumento es interpretado como la longitud del `Array`.

De lo contrario, puedes especificar un mínimo y un máximo para la longitud antes de definir la propiedad de longitud, o puedes usarla como el argumento del constructor.

Ejemplos
--------

### Casos inválidos


```js
new Array(Math.pow(2, 40));
new Array(-1);
new ArrayBuffer(Math.pow(2, 32));
new ArrayBuffer(-1);

let a = [];
a.length = a.length - 1; // definir la propiedad de longitud a -1

let b = new Array(Math.pow(2, 32) - 1);
b.length = b.length + 1; // definir la propiedad de longitud a 2^32
```

### Casos válidos


```js
[Math.pow(2, 40)]; // [ 1099511627776 ]
[-1]; // [ -1 ]
new ArrayBuffer(Math.pow(2, 32) - 1);
new ArrayBuffer(0);

let a = [];
a.length = Math.max(0, a.length - 1);

let b = new Array(Math.pow(2, 32) - 1);
b.length = Math.min(0xffffffff, b.length + 1);

// 0xffffffff es la notación hexadecimal de 2^32 - 1
// el cual también se puede especificar como (-1 >>> 0)
```

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

* `Array`
* `Array.length`
* `ArrayBuffer`
TypeError: "x" is (not) "y"
===========================

Mensaje
-------
```

TypeError: "x" is (not) "y"

Examples:
TypeError: "x" is undefined
TypeError: "x" is null
TypeError: "undefined" is not an object
TypeError: "x" is not an object or null
TypeError: "x" is not a symbol
```

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

`TypeError`.

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

Tipo inesperado. Esto ocurre amenudo con valores `undefined` o `null` .

Además, ciertos métodos, como `Object.create ()` o `Symbol.keyFor()`, requieren de un tipo específico, que debe ser proporcionado, ejemplos

### Casos inválidos


```js
// undefined and null cases on which the substring method won't work
var foo = undefined;
foo.substring(1); // TypeError: foo is undefined

var foo = null;
foo.substring(1); // TypeError: foo is null

// Certain methods might require a specific type
var foo = {};
Symbol.keyFor(foo); // TypeError: foo is not a symbol

var foo = "bar";
Object.create(foo); // TypeError: "foo" is not an object or null
```

### Cómo solucionar el problema

Para fijar un puntero nulo a indefinidos o valores nulos, puede utilizar el operador typeof, por ejemplo


```js
if (typeof foo !== "undefined") {
  // Ahora sabemos que foo está definido, ahora podemos continuar.
}
```

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

* `undefined`
* `null`
TypeError: More arguments needed
================================

Mensage
-------
```

TypeError: argument is not an Object and is not null (Edge)
TypeError: Object.create necesita al menos 1 argumento, pero solo only 0 fueron aprovadas.
TypeError: Object.setPrototypeOf necesita al menos 2 argumentos, pero solo 0 fueron aprovados
TypeError: Object.defineProperties requires at least 1 argument, but only 0 were passed
```

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

`TypeError`.

¿Qué fué mal?
-------------

Hay un error con que una funcion es llamada. Más argumentos necesitan ser dados.

Ejemplos
--------

El método `Object.create()` necesita al menos un argumento y el método `Object.setPrototypeOf()` necesita al menos 2 argumentos.


```js
var obj = Object.create();
// TypeError: Object.create necesita al menos 1 argumento, pero ninguno fue aprovad

var obj = Object.setPrototypeOf({});
// TypeError: Object.setPrototypeOf requires at least 2 arguments, but only 1 were passed
```


Puedes arreglar esto configurando `null` como el prototipo, por ejemplo:


```js
var obj = Object.create(null);

var obj = Object.setPrototypeOf({}, null);
```

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

* Funciones
SyntaxError: missing variable name
==================================

Mensaje
-------
```

SyntaxError: missing variable name (Firefox)
SyntaxError: Unexpected token = (Chrome)
```

Error
-----

`SyntaxError`¿Qué anda mal?
--------------

Una variable no tiene nombre. Esto es un error recurrente en el código. Probablemente una coma está mal colocada en algún lugar o nombraste mal una variable. Completamente entendible. Nombrar cosas es difícil.

Ejemplos
--------

### Missing a variable name


```js
var = "foo";
```


Es bueno nombrar buenas variables. Todos hemos estado así.


```js
var ohGodWhy = "foo";
```

### Palabras reservadas no pueden ser nombre de variables

Hay algunas palabras que son reservadas. No puedes usarlas para nombrar variables, lo siento :(


```js
var debugger = "whoop";
// SyntaxError: missing variable name
```

### Declarar multiples variables

Toma especial atención a las comas cuando declaras multiples variables. ¿Hay un exceso de comas? ¿Accidentalmente añadiste comas en vez de punto y coma?


```js
var x, y = "foo",
var x, = "foo"

var first = document.getElementById('one'),
var second = document.getElementById('two'),

// SyntaxError: missing variable name
```


La versión arreglada:


```js
var x,
  y = "foo";
var x = "foo";

var first = document.getElementById("one");
var second = document.getElementById("two");
```

### Arrays

`Array` literales en JavaScript necesitan corchetes alrededor de los valores. Esto no funciona:


```js
var arr = 1, 2, 3, 4, 5;
// SyntaxError: missing variable name
```


Esto es correcto:


```js
var arr = [1, 2, 3, 4, 5];
```

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

* Good variable names
* `var`
* Variable declarations in the JavaScript Guide
SyntaxError: "use strict" no permitida en función con parámetros complejos
==========================================================================

La excepción de JavaScript: "`'use strict' no permitida en función`" ocurre cuando se usa una directiva `"use strict"` en la parte superior de una función con parámetros predeterminados, parámetros rest o Desestructuración de parámetros.

Mensaje
-------

Edge:
```

No se puede aplicar el modo estricto en funciones con una lista de parámetros complejos
```


Firefox:
```

SyntaxError: "use strict" no permitido en la función con parámetro predeterminado
SyntaxError: "use strict" no permitido en la función con parámetro rest
SyntaxError: "use strict" no permitido en la función con parámetro de desestructuración
```


Chrome:
```

SyntaxError: directiva ilegal 'use strict' en función con una lista de parámetros complejos
```

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

`SyntaxError`.

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

Se escribió una directiva `"use strict"` en la parte superior de una función que tiene uno de los siguientes parámetros:

* Parámetros predeterminados
* Parámetros rest
* Desestructuración de parámetros

No está permitida una directiva `"use strict"` en la parte superior de dichas funciones según la especificación ECMAScript.

Ejemplos
--------

### Declaración de función

En este caso, la función `sum` tiene los parámetros predeterminados `a = 1` y `b = 2`:


```js
function sum(a = 1, b = 2) {
  SyntaxError: 'use strict' no permitida en la función con parámetros predeterminados
  'use strict';
  return a + b;
}
```


Si la función debe estar en modo estricto, y todo el script o la función adjunta también está bien que esté en modo estricto, puedes mover la directiva `"use strict"` fuera de la función:


```js
"use strict";
function sum(a = 1, b = 2) {
  return a + b;
}
```

### Expresión `Function`

Una expresión `function` puede usar otra solución alternativa:


```js
var sum = function sum([a, b]) {
  // SyntaxError: "use strict" no permitido en función con parámetros de desestructuración
  'use strict';
  return a + b;
};
```


Esta se puede convertir a la siguiente expresión:


```js
var sum = (function () {
  "use strict";
  return function sum([a, b]) {
    return a + b;
  };
})();
```

### Función de flecha

Si una función de flecha necesita acceder a la variable `this`, puedes usar la función de flecha como función circundante:


```js
var callback = (...args) => {
  SyntaxError: "use strict" no permitido en la función con parámetro rest
  'use strict';
  return this.run(args);
};
```


Esta se puede convertir a la siguiente expresión:


```js
var callback = (() => {
  "use strict";
  return (...args) => {
    return this.run(args);
  };
})();
```

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

* Modo estricto
* Declaración de función
* Expresión function
* Parámetros predeterminados
* Parámetros rest
* Desestructuración de parámetros
Warning: unreachable code after return statement
================================================

Mensaje
-------
```

Warning: unreachable code after return statement (Firefox)
```

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

Advertencia

Qué va mal?
-----------

Código inalcanzable después de una sentencia de retorno puede ocurrir en estas situaciones:

* Cuando se usa una expresión despues de una sentencia `return`
* Cuando se usa una sentencia de retorno sin punto y coma pero inluye una expresion directamente despues.

Cuando una expresion existe después de una sentencia de retorno válida, se da una advertencia para indicar que el código después de la sentencia de retorno es inalcanzable, lo que significa que nunca será ejecutado.

¿Porqué deberia tener un punto y coma despues de la sentencia de retorno? En el caso de sentencias sin punto y coma, estas pueden no ser claras, puede que el desarrollador intentara retornar el resultado de la sentencia en la siguiente línea, o detener la ejecución y retornar. La advertencia indica que hay una ambiguedad en la forma en la que la sentencia de retorno está escrita.

Advertencias no seran mostradas por retornos sin punto y coma si la sentencia lo sigue:

* `throw`
* `break`
* `var`
* `function`
Ejemplos
--------

### Casos invalidos


```js
function f() {
  var x = 3;
  x += 4;
  return x; // return sale de la funcion inmediatamente
  x -= 3; // esta linea nunca se ejecutara ; es inalcanzable
}

function f() {
  return; // es tratado como `return;`
  3 + 4; //la funcion regresa, y esta linea nunca es alcanzada
}
```

### Casos validos


```js
function f() {
  var x = 3;
  x += 4;
  x -= 3;
  return x; // OK: regreso despues de todas las otras declaraciones
}

function f() {
  return 3 + 4; // OK: sin punto y coma regresa la expresion en la misma linea
}
```

Ve tambien
----------

* Automatic Semicolon Insertion
SyntaxError: Using //@ to indicate sourceURL pragmas is deprecated. Use //# instead
===================================================================================

Mensaje
-------
```

Advertencia: Error de Sintaxis al utilizar //@ para indicar el código fuente de la URL esta obsoleto. En su lugar use //#.

Advertencia: Error de Sintaxis: al utilizar //@ para indicar el mapeo de programas del código fuente de la URL esta obsoleto. En su lugar use //#.
```

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

Una advertencia ocurrida como esta `SyntaxError`. JavaScript no se detendrá.

Descripción del error
---------------------

Esta es una sintaxis obsoleta del codigo fuente de mapa en JavaScript.

Las sintaxis de código fuente de mapa en JavaScript se suelen combinar y minificar para hacer que la entrega desde el servidor sea más eficiente. Con los códigos de origen de mapas, el depurador puede asignar el código que se está ejecutando a los archivos de origen.

La especificación de mapa de código fuente cambió la sintaxis debido a un conflicto con IE con la versión windows 8.x siempre que se encontró en la página. Despues `//@cc_on` fue interpretado para activar la compilación condicional en el motor IE JScript. El comentario de compilación condicional en IE es una característica poco conocida, pero rompió mapas de fuente de origen con jQuery y otras bibliotecas.

Ejemplos
--------

### Sintaxis obsoleta

Sintaxis con el signo obsoleto "@".


```js
//@ sourceMappingURL=http://example.com/path/to/your/sourcemap.map
```

### Sintaxis estándar

En su lugar use el signo "#".


```js
//# sourceMappingURL=http://example.com/path/to/your/sourcemap.map
```


O, alternativamente, puede establecer un encabezado en su archivo JavaScript para evitar tener un comentario de error de sintaxis:


```js
X-SourceMap: /path/to/file.js.map
```

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

* Como utilizar un mapa de Fuentes - Documentación de Herramientas de Firefox
* Introducción a las fuentes – HTML5 rocks
SyntaxError: missing } after property list
==========================================

Mensaje
-------
```

SyntaxError: missing } after property list
```

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

`SyntaxError`¿Que estuvo mal?
----------------

Es un error de sinaxis en algún lugar en el object initializer (en-US). Prodría provocarse debido a la falta de una llave, pero, por ejemplo tambien por falta de alguna coma. Tambien verifique si alguna llave o parentesis se encuentra en el orden correcto. Indentar o darle un buen formato al codido puede ayudarlo a observar mejor el error.

Ejemplos
--------

### Olvido de coma

Algunas veces, hace faltan las comas en codigo inicial del proyecto, he aquí un ejemplo:


```js
var obj = {
  a: 1,
  b: { myProp: 2 }
  c: 3
};
```


La correción podría ser:


```js
var obj = {
  a: 1,
  b: { myProp: 2 },
  c: 3,
};
```

Observe Tambien
---------------

* Object initializer (en-US)
SyntaxError: illegal character
==============================

Mensaje
-------
```

SyntaxError: illegal character (Firefox)
SyntaxError: Invalid or unexpected token (Chrome)

ErrorDeSintasix: Carácter ilegal (Firefox)
ErrorDeSintasix: Componente léxico inválido o inesperado (Chrome)
```

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

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

Hay un componente léxico inválido o inesperado que no pertenece a su posición en el código. Utilice un editor que soporte el resaltado de sintaxis y que revise cuidadosamente su código contra discrepancias como un signo menos (`-`) contra un guion (`–`) o comillas simples (`"`) contra comillas no estándar (`“`).

Ejemplos
--------

### Caracteres no coincidentes

Algunos caracteres parecen iguales, pero hará que el analizador falle al interpretar su código.


```js
“Esto parece una cadena de caracteres”;
// SyntaxError: illegal character
// ErrorDeSintaxis: Carácter ilegal

42 – 13;
// SyntaxError: illegal character
// ErrorDeSintaxis: Carácter ilegal
```


Esto debería funcionar:


```js
"Esto en realidad es una cadena de caracteres";

42 - 13;
```

### Caracteres olvidados

Es fácil olvidar caracteres aquí o allí.


```js
var colors = ['#000', #333', '#666'];
// SyntaxError: illegal character
// ErrorDeSintaxis: Carácter ilegal
```


Agregue la comilla olvidada para `'#333'`.


```js
var colors = ["#000", "#333", "#666"];
```

### Caracteres escondidos

Cuando copia y pega un código de una fuente externa, puede haber caracteres inválidos. ¡Cuidado!


```js
var foo = 'bar';​
// SyntaxError: illegal character
// ErrorDeSintaxis: Carácter ilegal
```


Al inspeccionar este código en un editor como Vim, puede ver que en realidad hay un carácter de espacio de ancho cero (ZWSP) (U+200B).


```js
var foo = 'bar';​<200b>
```

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

* Gramática léxica
Error: Permission denied to access property "x"
===============================================

Mensaje
-------
```

Error: Permission denied to access property "x"
```

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

`Error`.

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

Se ha intentado acceder a un objeto al cual no tienes permiso. Probablemente es un elemento `<iframe>` cargado de otro dominio en el cual violaste la política del mismo origen.

Ejemplos
--------


```html
<!doctype html>
<html>
  <head>
    <iframe
 id="myframe"
 src="http://www1.w3c-test.org/common/blank.html"></iframe>
    <script>
 onload = function () {
 console.log(frames[0].document);
 // Error: Permission denied to access property "document"
 };
 </script>
  </head>
  <body></body>
</html>
```

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

* `<iframe>`
* Política del mismo origen
TypeError: cannot use 'in' operator to search for 'x' in 'y'
============================================================

Mensaje
-------
```

TypeError: cannot use 'in' operator to search for 'x' in 'y' (Firefox, Chrome)
```

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

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

El operador `in` puede ser usado sólo para verificar si una propiedad se encuentra en un objeto. No puede buscar en cadenas de caracteres, o en números, u otro tipo primitivo.

Ejemplos
--------

### Buscando en cadenas de caracteres

A diferencia de otros lenguajes de programación (ej. Python), no puede buscar cadenas de texto usando el operator `in`.


```js
"Hello" in "Hello World";
// TypeError: cannot use 'in' operator to search for 'Hello' in 'Hello World'
```


En su lugar, deberá usar `String.prototype.indexOf()`, por ejemplo.


```js
"Hello World".indexOf("Hello") !== -1;
// true
```

### El operando no puede ser `null` o `undefined`

Asegúrese que el objeto que está inspeccionando no sea `null` o `undefined`.


```js
var foo = null;
"bar" in foo;
// TypeError: cannot use 'in' operator to search for 'bar' in 'foo'
```


El operador `in` siempre espera un objeto.


```js
var foo = { baz: "bar" };
"bar" in foo; // false

"PI" in Math; // true
"pi" in Math; // false
```

### Buscando en arreglos

Tenga cuidado cuando use el operador `in` para buscar en objetos `Array`. El operador `in` verifica el índice numérico, no el valor de dicho índice.


```js
var trees = ["redwood", "bay", "cedar", "oak", "maple"];
3 in trees; // true
"oak" in trees; // false
```

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

* `in` operator
continue
========

Resumen
-------

Termina la ejecución de las sentencias de la iteración actual del bucle actual o la etiqueta y continua la ejecución del bucle con la próxima iteración.

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

continue [ etiqueta ];
```


`label`

Identificador asociado con la etiqueta de la sentencia.

### Descripción

En contraste con la sentencia `break`, `continue` no termina la ejecución del bucle por completo; en cambio,

* En un bucle `while`, salta de regreso a la condición.
* En un bucle `for`, salta a la expresión actualizada.

La sentencia `continue` puede incluir una etiqueta opcional que permite al programa saltar a la siguiente iteración del bucle etiquetado en vez del bucle actual. En este caso, la sentencia `continue` necesita estar anidada dentro de esta sentecia etiquetada.

Ejemplos
--------

### Ejemplo: Usando `continue` con `while`

El siguiente ejemplo muestra un bucle `while` que tiene una sentencia `continue` que se ejecuta cuando el valor de `i` es 3. Así, `n` toma los valores 1, 3, 7 y 12.


```js
i = 0;
n = 0;
while (i < 5) {
  i++;
  if (i == 3) {
    continue;
  }
  n += i;
}
```

### Ejemplo: Usando `continue` con una etiqueta

En el siguiente ejemplo, una sentencia etiquetada `checkiandj` contiene una sentencia etiquetada `checkj`. Si se encuentra `continue`, el programa continua hasta encima de la sentencia `checkj`. Cada vez que se encuentra `continue`, `checkj` se reitera hasta que su condición devuelve false. Cuando se devuelve false, el recordatorio de la sentencia `checkiandj` se completa.

Si `continue` tuviese una etiqueta `checkiandj`, el programa continuaría hasta encima de la sentencia `checkiandj`.


```js
checkiandj: while (i < 4) {
  document.write(i + "<br>");
  i += 1;

  checkj: while (j > 4) {
    document.write(j + "<br>");
    j -= 1;
    if (j % 2 == 0) continue checkj;
    document.write(j + " is odd.<br>");
  }
  document.write("i = " + i + "<br>");
  document.write("j = " + j + "<br>");
}
```

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

* `break`
* `label`
empty
=====

Un **empty statement** o sentencia vacía es usada para no proveer una sentencia, incluso si la sintaxis JavaScript esperase una.

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

;
```

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

La sentencia vacía es un punto y coma (;) que indica que no se ejecutará ninguna sentencia, incluso si la sintaxis JavaScript requiere una. El comportamiento opuesto, donde se desean ejecutar varias sentencias pero JavaScript solo permite una sola, es posible usando una sentencia de bloque; la cual combina varias declaraciones en una.

Ejemplos
--------

La sentencia vacía es comúnmente usada en bucles. Por ejemplo, un bucle for sin bloque de sentencias:


```js
var arr = [1, 2, 3];

// Asignar el valor 0 a todos los elementos del array
for (i = 0; i < arr.length; arr[i++] = 0) {
  /\* sentencia vacía \*/
}

console.log(arr);
// [0, 0, 0]
```


**Nota:** Es una buena práctica comentar el uso intencional de la sentencia vacía, ya que no es fácilmente distinguible de un punto y coma normal. Un ejemplo de uso probablemente no intencional:


```js
if (condicion); // Esta condición no ejerce ningún control!
  borrarTodo(); // Por lo cual esta sentencia será ejecutada siempre!!!
```


Otro ejemplo de uso:


```js
var a = 1,
  b = 1;
if (a == 0 || (b = 0)); // Asigna a 'b' el valor cero si 'a' no es cero.
console.log(b); // 0
```

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

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

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

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

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

* `Sentencia de bloque`
return
======

Resumen
-------

La sentencia `return` finaliza la ejecución de la función y especifica un valor para ser devuelto a quien llama a la función.

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

return [[ expresion ]];
```


expresion

La expresión a retornar. Si se omite, `undefined` es retornado en su lugar.

Description
-----------

Cuando una instrucción de retorno se llama en una función, se detiene la ejecución de esta. Si se especifica un valor dado, este se devuelve a quien llama a la función. Si se omite la expresión, `undefined` se devuelve en su lugar. Todas las siguientes sentencias de retorno rompen la ejecución de la función:


```js
return;
return true;
return false;
return x;
return x + y / 3;
```

La inserción automática Punto y coma
------------------------------------

La instrucción de retorno se ve afectada por la inserción automática de punto y coma (ASI). No se permite el terminador de línea entre la palabra clave de retorno y la expresión.


```js
return;
a + b;
```


se transforma por ASI en:


```html
return; a + b;
```


La consola le advertirá "código inalcanzable después de la declaración de retorno".

**Nota:** A partir de Gecko 40 (Firefox 40 / Thunderbird 40 / SeaMonkey 2.37), una advertencia es mostrada en la consola si se encuentra código inalcanzable despues de una instrucción return.

Ejemplos
--------

### Ejemplo: Usando `return`

La siguiente función devuelve el cuadrado de su argumento, `x`, donde `x` es un número.


```js
function cuadrado(x) {
  return x \* x;
}
```

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

* Funciones