recursal/MDN huggingface dataset:
Erro de Sintaxe: faltando : depois da propriedade id
====================================================

Mensagem
--------
```

SyntaxError: missing : after property id
```

Tipo de erro
------------

`SyntaxError` (en-US)O que deu errado?
-----------------

Ao criar objetos com a sintaxe do iniciador do objeto, dois pontos (`:`) separam chaves e valores para as propriedades do objeto.


```js
var obj = { propertyKey: "value" };
```

Exemplos
--------

### Dois-pontos contra sinal de igualdade

Este código falha, pois o sinal de igualdade não pode ser usado dessa maneira nesta sintaxe do iniciador do objeto.


```js
var obj = { propertyKey = 'value' };
// SyntaxError: missing : after property id
```


Correto seria usar um dois-pontos, ou usar colchetes para atribuir uma nova propriedade depois que o objeto já foi criado.


```js
var obj = { propertyKey: "value" };

// or alternatively

var obj = {};
obj["propertyKey"] = "value";
```

### Propriedades vazia

Você não pode criar propriedades vazias como esta:


```js
var obj = { propertyKey; };
// SyntaxError: missing : after property id
```


Se você precisa definir uma propriedade sem um valor, você pode usar `null` como um valor.


```js
var obj = { propertyKey: null };
```

### Propriedades computadas

Se você criar uma chave de propriedade de uma expressão, você precisa usar colchetes. Caso contrário, o nome da propriedade não pode ser computado:


```js
var obj = { 'b'+'ar': 'foo' };
// SyntaxError: missing : after property id
```


Coloque a expressão entre parênteses `[]`:


```js
var obj = { ["b" + "ar"]: "foo" };
```

Veja também
-----------

* Inicializador de objeto
InternalError: too much recursion
=================================

Mensagem
--------
```

Error: Out of stack space (Edge)
InternalError: too much recursion (Firefox)
RangeError: Maximum call stack size exceeded (Chrome)
```

Tipo de erro
------------

`InternalError`.

O que deu errado?
-----------------

Uma função que invoca a si mesma é chamada *função recursiva*. Assim que uma condição é atendida, a função para de se invocar.

De certa forma, recursão é análoga a um loop. Ambos executam o mesmo código múltiplas vezes, e ambos exigem uma condição (para evitar um loop infinito ou, nesse caso, uma recursão infinita). Quando são feitas excessivas invocações, ou a função não possui uma condição para interromper a recursividade, este erro é lançado.

Exemplos
--------

Esta função recursiva roda 10 vezes, como definido pela condição de saída.


```js
function loop(x) {
  if (x >= 10) {
    // "x >= 10" é a condição de saída
    return;
  }
  loop(x + 1); // o código recursivo em si
}
loop(0);
```


Mudar esta condição para um valor extremamente alto não vai funcionar:


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

// InternalError: too much recursion
```


A seguinte função recursiva não possui condição de saída. Assim, ela vai continuar se invocando indefinidamente (até que o erro seja lançado e a execução interrom).


```js
function loop(x) {
  // Não há condição de saída

  loop(x + 1); // Código recursivo
}

loop(0);

// InternalError: too much recursion
```

Veja também
-----------

* Recursion
* Funções recursivas
SyntaxError: flag de expressão regular inválida "x"
===================================================

A exceção JavaScript "flag de expressão regular inválida" ocorre quando as flags de uma expressão regular contêm qualquer flag que não seja uma das flag: `g`, `i`, `m`, `s`, `u`, `y` ou `d`.

Também pode ser lançada se a expressão contiver mais do que uma instância de uma flag válida.

Mensagem
--------
```

SyntaxError: Invalid regular expression flags (V8-based)
SyntaxError: invalid regular expression flag x (Firefox)
SyntaxError: Invalid regular expression: invalid flags (Safari)
```

Tipo de erro
------------

`SyntaxError` (en-US)O que ocorreu de errado?
------------------------

A expressão regular contém flags inválidas, ou foram utilizadas flags válidas mais de uma vez na expressão.

As flags válidas (permitidas) são listadas em Expressões regulares > Pesquisa avançada com flags, e reproduzidas abaixo:

| Flag | Descrição |
| --- | --- |
| `g` | Pesquisa Global. Veja `global` (en-US) |
| `i` | Pesquisa case-sensitive. Veja `ignoreCase`. |
| `m` | Pesquisa em múltiplas linhas. Veja `multiline` (en-US). |
| `s` | Permitir que `.` se igualem a novas linhas. Veja `dotAll` (en-US). |
| `u` | Unicode; trata um padrão como uma sequência de pontos de código Unicode. Veja `unicode` (en-US). |
| `y` | Realiza uma pesquisa "sticky" que coincida a partir da posição atual na cadeia de destino. Veja `sticky` |
| `d` | Índices. Geração de índices para a correspondência de substrato. Veja `hasIndices` (en-US) |

Exemplos
--------

 Em uma expressão regular literal, que consiste em um padrão fechado entre barras, as flags são definidas após a segunda barra.
 As flags de expressão regular podem ser utilizadas separadamente ou em conjunto em qualquer ordem.
 Esta sintaxe mostra como declarar as flags usando a expressão regular literal:


```js
const re = /pattern/flags;
```


Podem também ser definidos na função construtora do objecto `RegExp` (segundo parâmetro):


```js
const re = new RegExp("pattern", "flags");
```


Aqui está um exemplo que mostra a utilização apenas de flags corretas.


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


Abaixo está um exemplo que mostra a utilização de algumas flags inválidas `b`, `a` e `r`:


```js
/foo/bar;

// SyntaxError: invalid regular expression flag "b"
```


O código abaixo está incorrecto, porque `W`, `e` e `b` não são flags válidas.


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

// SyntaxError: invalid regular expression flag "W"
```


 Uma expressão contendo duas barras é interpretada como uma expressão regular literal.
 Muito provavelmente a intenção era criar uma cadeia literal, usando citações simples ou duplas, como se mostra abaixo:


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

Veja também
-----------

* Expressões Regulares
* XRegEx flags – biblioteca de expressões regulares que fornece quatro novas bandeiras (`n`, `s`, `x`, `A`)
SyntaxError: Unexpected token
=============================

Mensagem
--------
```

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

`SyntaxError` (en-US)O que deu errado?
-----------------

Uma construção específica da linguagem era esperada, mas algo não foi fornecido. Isto deve ser um simples erro de digitação.

Exemplos
--------

### Expressão esperada

Por exemplo, quando funções são chamadas, vírgulas sem um valor na sequência não são permitidas. O JavaScript esperarará outro argumento, como pode ser qualquer expressão.


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


O correto é omitir a vírgula ou adicionar outro argumento:


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

Veja também
-----------

* `Math.max()`
Error: Permission denied to access property "x"
===============================================

Mensagem
--------
```

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

Tipo de erro
------------

`Error`.

O que houve de errado?
----------------------

Tentativa de acessar um objeto no qual você não possui permissões. Provavelmente um `<iframe>` carregado de um dominio diferente no qual foi violado o same-origin policy (en-US).

Exemplos
--------


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

Veja também
-----------

* `<iframe>`
* Same-origin policy (en-US)
RangeError: precision is out of range
=====================================

A exceção JavaScript "precision is out of range" (precisão fora de alcance) ocorre quando um número que está fora do intervalo que vai de 0 à 20 (ou 21) foi passado para `toFixed` ou `toPrecision`.

Mensagem
--------
```

RangeError: The number of fractional digits is out of range (Edge)
RangeError: The precision is out of range (Edge)
RangeError: precision {0} out of range (Firefox)
RangeError: toExponential() argument must be between 0 and 20 (Chrome)
RangeError: toFixed() digits argument must be between 0 and 20 (Chrome)
RangeError: toPrecision() argument must be between 1 and 21 (Chrome)
```

Tipo de erro
------------

`RangeError` (en-US)O que houve de errado?
----------------------

Existe um argumento de precisão fora do intervalo em um desses métodos:

* `Number.prototype.toExponential()` (en-US)
* `Number.prototype.toFixed()`
* `Number.prototype.toPrecision()`

Po padrão, o intervalo permitido para os métodos acima é de 0 à 20 (ou 21). Todavia, a especificação ECMAScript nos permite extender o intervalo.

| Método | Firefox (SpiderMonkey) | Chrome, Opera (V8) |
| --- | --- | --- |
| `Number.prototype.toExponential()` (en-US) | 0 to 100 | 0 to 20 |
| `Number.prototype.toFixed()` | -20 to 100 | 0 to 20 |
| `Number.prototype.toPrecision()` | 1 to 100 | 1 to 21 |

Exemplos
--------

### Casos inválidos


```js
(77.1234).toExponential(-1); // RangeError
(77.1234).toExponential(101); // RangeError

(2.34).toFixed(-100); // RangeError
(2.34).toFixed(1001); // RangeError

(1234.5).toPrecision(-1); // RangeError
(1234.5).toPrecision(101); // RangeError
```

### Casos válidos


```js
(77.1234).toExponential(4); // 7.7123e+1
(77.1234).toExponential(2); // 7.71e+1

(2.34).toFixed(1); // 2.3
(2.35).toFixed(1); // 2.4 (perceba que ele foi arredondado nesse caso)

(5.123456).toPrecision(5); // 5.1235
(5.123456).toPrecision(2); // 5.1
(5.123456).toPrecision(1); // 5
```

Veja também
-----------

* `Number.prototype.toExponential()` (en-US)
* `Number.prototype.toFixed()`
* `Number.prototype.toPrecision()`
SyntaxError: missing formal parameter
=====================================

Mensagem
--------
```

SyntaxError: missing formal parameter (Firefox)
```

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

`SyntaxError` (en-US)O que deu errado?
-----------------

"Parâmetro Formal" é uma maneira elegante de dizer "parâmetro de função". Faltam parâmetros válidos em sua função. Na declaração de uma função os parâmetros devem ser identifiers, em vez de um valor como números, strings ou objetos. Declarar funções e chamar funções são dois passos diferentes. Declarações exigem identificadores como parâmetros e é apenas ao chamar (invocar) a função que você fornece os valores que a função deve usar.

Em JavaScript, identificadores podem obter apenas caracteres alfanuméricos (ou "$" e "\_"), e não podem começar com um número. Um identificador difere de uma **string** porque uma string é um dado, enquanto que um identificador é parte do código.

Exemplos
--------

Parâmetros de função devem ser identificadores ao se configurar uma função. Todas essas declarações de função abaixo falham, pois estão fornecendo valores para seus parâmetros:


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

function saudacao("Olá") {
  return saudacao;
};
// SyntaxError: missing formal parameter

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


Você terá de usar identificadores nas declarações de função:


```js
function quadrado(numero) {
  return numero \* numero;
}

function saudar(saudacao) {
  return saudacao;
}

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


You can then call these functions with the arguments you like:


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

saudar("Olá"); // "Olá"

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

Ver também
----------

* Outros erros referentes a parâmetros formais:
    + SyntaxError: Parâmetro formal mal formado (en-US)
    + SyntaxError: redeclaração de parâmetro formal "x"
Erro de sintaxe falta ) depois da lista de argumentos
=====================================================

Mensagem
--------
```

Erro de sintaxe: Falta ) depois da lista de argumento
```

Tipo de Erro
------------

`Erro de sintaxe`.

O que houve de errado?
----------------------

Ocorreu um erro quando a função foi chamada. Pode ter sido um erro de escrita, falta de operador, ou uma string fora das aspas, por exemplo.

Exemplos
--------

Pela falta do operador "+" para fazer a concatenação da string, o JavaScript esperou um argumento para a função log ser "PI: ". Nesse caso, deveria ser finalizado com parênteses de fechamento ')'.


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


Você pode corrigir a chamada do log adicionand o operador "+":


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

Veja também
-----------

* Funções
ReferenceError: reference to undefined property "x"
===================================================

Mensagem
--------
```

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

Tipo de Erro
------------

(Apenas no Firefox) O aviso `ReferenceError` é reportado somente se a preferência `javascript.options.strict` está definida como `true`.

O que está errado?
------------------

O script tentou acessar uma propriedade de objeto que não existe. Existem duas maneiras de acessar propriedades; veja a página de referência property accessors para saber mais sobre eles.

Exemplos
--------

### Errado

Neste caso, a propriedade `bar` é uma propriedade não definida, assim, ocorrerá um `ReferenceError`.


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

### Certo

Para evitar o erro, você precisa adicionar uma definição de `bar` ao objeto ou verificar a existência da propriedade `bar` antes de tentar acessá-la; Uma maneira de fazer isso é usar o método `Object.prototype.hasOwnProperty ()`, desta forma:


```js
var foo = {};

// Define a propriedade bar

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

// Teste para ter certeza se bar existe antes de acessa-lo

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

Veja também
-----------

* property accessors
SyntaxError: redeclaration of formal parameter "x"
==================================================

Mensagem
--------
```

SyntaxError: Let/Const redeclaration (Edge)
SyntaxError: redeclaration of formal parameter "x" (Firefox)
SyntaxError: Identifier "x" has already been declared (Chrome)
```

Tipo de Erro
------------

`SyntaxError` (en-US)O que deu errado?
-----------------

O mesmo nome de variável ocorre como parâmetro da função e é então redeclarada atribuindo `let` no corpo da função. Redeclarando a mesma variável dentro da mesma função ou no escopo do bloco usando `let` não é permitido em JavaScript.

Exemplos
--------

Neste caso, a variável "arg" redeclara o argumento.


```js
function f(arg) {
  let arg = "foo";
}

// SyntaxError: redeclaration of formal parameter "arg"
```


Se você quiser mudar o valor de "arg" no corpo da função, você pode fazer, mas você não precisa declarar novamente a mesma variável. Em outras palavras: você pode omitir a palavra chave `let`. Se você quiser criar uma nova variável, você precisa renomea-la, pois isso conflita com o parâmetro da função.


```js
function f(arg) {
  arg = "foo";
}

function f(arg) {
  let bar = "foo";
}
```

Notas de compatibilidade
------------------------

* Antes do Firefox 49, isto foi lançado como um `TypeError` (Erro do Firefox 1275240).
Veja também
-----------

* `let`
* `const`
* `var`
* Declaring variables in the JavaScript Guide
RangeError: argument is not a valid code point
==============================================

Mensagem
--------
```

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

Tipo de Erro
------------

`RangeError` (en-US)O que está errado?
------------------

`String.fromCodePoint()` dispara esse erro quando são passados valores `NaN`, inteiros negativos (-1), não inteiros (5.4), ou valores maiores que 0x10FFFF (1114111).

Um code point é um valor Unicode; isto é,é um valor inteiro entre `0` e `0x10FFFF`.

Exemplos
--------

### Errado


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

### Certo


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

Veja também
-----------

* `String.fromCodePoint()`
ReferenceError: can't access lexical declaration`X' before initialization
=========================================================================

Mensagem
--------
```

ReferenceError: Use before delaration (Edge)
ReferenceError: can't access lexical declaration `X' before initialization (Firefox)
ReferenceError: 'x' is not defined (Chrome)
```

Tipo de Erro
------------

`ReferenceError`O que está errado
-----------------

Uma variável léxica foi acessada antes de ser inicializada. Isso acontece dentro de qualquer declaração de bloco, quando as declarações `let` ou `const` são acessadas antes de serem definidas.

Exemplos
--------

### Errado

Neste caso, a variável "foo" é redeclarada usando `let`.


```js
function test() {
  let foo = 33;
  if (true) {
    let foo = foo + 55;
    // ReferenceError: can't access lexical
    // declaration `foo' before initialization
  }
}
test();
```

### Certo

Para mudar "foo" dentro do bloco if você precisa remover o `let` que causa a redeclaração.


```js
function test() {
  let foo = 33;
  if (true) {
    foo = foo + 55;
  }
}
test();
```

Veja também
-----------

* Temporal Dead Zone e erros com let.
Erro de sintaxe: declaração de função requer um nome
====================================================

Mensagem
--------
```

Errodesintaxe: Identificador Esperado(Edge)
Errodesintaxe: declaração de função requer um nome [Firefox]
Errodesintaxe: Token inesperado ( [Chrome]
```

Tipo de erro
------------

`Errodesintaxe`O que estava errado?
--------------------

Existe uma declaração no código que requer um nome. Você precisa checar como as funções são definidas e se você precisa providenciar um nome, se a função em questão precisa ser uma expressão de função, um IIFE ou se o código da função está colocado corretamente neste contexto.

Exemplos
--------

### Statements vs expressions

Uma *declaração de função* (ou *declaração de função*) requer um nome, isso não vai funcionar:


```js
function () {
  return 'Olha mundo';
}
// SyntaxError: function statement requires a name
```


Você pode usar uma expressão de função ao invés de uma atribuição.


```js
var saudar = function () {
  return "Ola mundo";
};
```


Ou, sua função pode ser pretendida a ser uma IIFE (Immediately Invoked Function Expression), qual é uma função que será em breve definida. Você vai precisar de um pouco mais de colchetes neste caso:


```js
(function () {})();
```

### Funçoes etiquetadas

Se usar labels, precisará providenciar um nome de função depois da palavra `function` . Isto não funciona:


```js
function Saudacao() {
  alemao: function () {
    return "Moin";
  }
}
// SyntaxError: a função declaração requer um nome
```


Isso funciona ,veja o exemplo:


```js
function Saudacao() {
  alemao: function g() {
    return "Moin";
  }
}
```

### Métodos de Objetos

Se pretende criar um metodo para um objeto, voce precisa-rá criar um objeto (hehehe). A seguir uma sintaxe sem nome depois de `function` é válida.


```js
var saudacao = {
  alemao: function () {
    return "Moin";
  },
};
```

### Callback Sintaxe

Alem disso,cheque sua sintaxe usando callbacks. Colchetes e virgulas ficam facilmente atrapalhar e dificultar.


```js
promessa.then(
  function() {
    console.log("sucesso");
  });
  function() {
    console.log("erro");
}
// SyntaxError: function statement requires a name
```


O correto seria:


```json
promise.then(
  function() {
    console.log("success");
  },
  function() {
    console.log("error");
  }
);//sempre que abrir feche();
```

Veja também
-----------

* Guia de funções em JavaScript
* Funções de Declaração
* Funções de Expressão
* Funções imediatas (IIFE)
* Etiqueta
SyntaxError: as declarações da cabeça do laço for-in podem não ter inicializadores
==================================================================================

 O JavaScript em modo estrito-somente exceção
 "as declarações for-in loop head podem não ter inicializadores"
 isso ocorre quando a cabeça de um for...in contém
 uma expressão inicializadora, tal como `for (var i = 0 in obj)`. Isto não é
 permitido em laços for-in em modo estrito. Além disso, declarações léxicas com inicializadores como `for (const i = 0 in obj)` também não são permitidas fora do modo estrito.

Mensagem
--------
```

SyntaxError: for-in loop variable declaration may not have an initializer. (V8-based)
SyntaxError: for-in loop head declarations may not have initializers (Firefox)
SyntaxError: a lexical declaration in the head of a for-in loop can't have an initializer (Firefox)
SyntaxError: Cannot assign to the loop variable inside a for-in loop header. (Safari)
```

Tipo de erro
------------

`SyntaxError` (en-US).

O que ocorreu errado?
---------------------

 A cabeça de um laço for...in contém uma expressão inicializadora.
 Ou seja, uma variável é declarada e atribuída um valor `for (var i = 0 in obj)`.
 No modo não estrito, esta declaração de cabeça é silenciosamente ignorada e comporta-se como `for (var i in obj)`.
 No modo estrito, contudo, é lançado um `SyntaxError`. Além disso, declarações léxicas com inicializadores como `for (const i = 0 in obj)` também não são permitidas fora do modo estrito, e produzirão sempre um `SyntaxError`.

Exemplos
--------

Esse exemplo lança um `SyntaxError`:


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

for (const i = 0 in obj) {
  console.log(obj[i]);
}

// SyntaxError: for-in loop head declarations may not have initializers
```

### Laço for-in válido

Pode remover o inicializador (`i = 0`) na cabeça do laço de entrada.


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

for (const i in obj) {
  console.log(obj[i]);
}
```

### Iteração de array

 O laço for...in não deve ser usado para iteração de Array.
 Pretendia utilizar um laço `for`
 em vez de um laço `for-in` para iterar um `Array`? O
 laço `for` permite também definir um inicializador então:


```js
const arr = ["a", "b", "c"];

for (let i = 2; i < arr.length; i++) {
  console.log(arr[i]);
}

// "c"
```

Veja também
-----------

* `for...in`
* `for...of`
 – also disallows an initializer in both strict and non-strict mode.
* `for` –
 preferred for array iteration, allows to define an initializer.
RangeError: repeat count must be non-negative
=============================================

Mensagem
--------
```

RangeError: argument out of range
RangeError: repeat count must be non-negative (Firefox)
RangeError: Invalid count value (Chrome)
```

Tipo de Erro
------------

`RangeError` (en-US)O que está errado?
------------------

O método `String.prototype.repeat()` foi usado. Ele tem um parâmetro `count` indicando o número de vezes para repetir a string. Esse contador deve ser maior ou igual à 0 menor que `Infinity` (infinito positivo). O intervalo de vaores permitidos pode ser descrito por: [0, +∞).

Exemplos
--------

### Errado


```js
"abc".repeat(-1); // RangeError
```

### Certo


```js
"abc".repeat(0); // ''
"abc".repeat(1); // 'abc'
"abc".repeat(2); // 'abcabc'
"abc".repeat(3.5); // 'abcabcabc' (count será convertido para inteiro)
```

Veja também
-----------

* `String.prototype.repeat()`