Object.setPrototypeOf() - JavaScript

Object.setPrototypeOf()
=======================

O método **`Object.setPrototypeOf()`** configura o 'prototype' (i.e., a propriedade interna `[[Prototype]]`) de um objeto específico para outro objeto ou `null`.

**Aviso:** **Atenção:** Mudar o `[[Prototype]]` de um objeto é, pela natureza de como os modernos mecanismos JavaScript otimizam os acessos de propriedade, uma operação muito lenta, em ***todos*** navegadores e mecanismos JavaScript. O efeito sobre o desempenho de alterar a herança são sutis e vastas e não se limitam simplesmente ao tempo gasto em `obj.__proto__ = ...` statement, mas pode estender a ***qualquer*** código que tem acesso a ***qualquer*** objeto cujo `[[Prototype]]` foi alterado. Se você se preocupa com desempenho, você deveria evitar configurar o `[[Prototype]]` de um objeto. Em vez disso, crie um novo objeto com o `[[Prototype]] desejado usando` `Object.create()`.

Sintaxe
-------
```

Object.setPrototypeOf(obj, prototype);
```

### Parâmetros

`obj`

O objeto que deve ter seu 'prototype' definido.

`prototype`

O novo 'prototype' do objeto (um objeto ou `null`).

### Valor de retorno

O objeto especificado.

Descrição
---------

Gera uma exceção `TypeError` se o objeto cujo `[[Prototype]]` é para ser modificado não for extensível de acordo com `Object.isExtensible()`. Não faz nada se o parâmetro '`prototype'` não for um objeto ou `null` (ex., número, texto, boleano, ou `undefined`). Caso contrário, este método muda o `[[Prototype]]` do `obj` para um novo valor.

`Object.setPrototypeOf() é uma especificação` ECMAScript 2015. É geralmente considerada a maneira correta de definir o 'prototype' de um objeto, em relação à propriedade mais controversa `Object.prototype.__proto__`.

Exemplos
--------

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

Polyfill
--------

Usando a propriedade mais antiga `Object.prototype.__proto__`, nós podemos facilmente definir `Object.setPrototypeOf` se já não estiver disponível:

```js
// Funciona somente no Chrome e FireFox, não funciona no IE:
Object.setPrototypeOf =
  Object.setPrototypeOf ||
  function (obj, proto) {
    obj.__proto__ = proto;
    return obj;
  };
```

Adicionando 'Prototype' em cadeia
---------------------------------

Uma combinação de `Object.getPrototypeOf()` e `Object.prototype.__proto__` permite anexar toda uma cadeia de 'prototype' a um novo objeto 'prototype':

```js
/\*\*
 \*\*\* Object.appendChain(@object, @prototype)
 \*
 \* Acrescente o primeiro 'prototype' não nativo de uma cadeia a um novo 'prototype'.
 \* Retorna @object (se for um valor primitivo, será transformado em um objeto).
 \*
 \*\*\* Object.appendChain(@object [, "@arg\_name\_1", "@arg\_name\_2", "@arg\_name\_3", "..."], "@function\_body")
 \*\*\* Object.appendChain(@object [, "@arg\_name\_1, @arg\_name\_2, @arg\_name\_3, ..."], "@function\_body")
 \*
 \* Adicione o primeiro 'prototype' não nativo de uma cadeia ao objeto nativo Function.prototype, então anexar a nova função
 \* Function(["@arg"(s)], "@function\_body") àquela cadeia.
 \* Retorna a função.
 \*
 \*\*/

Object.appendChain = function (oChain, oProto) {
  if (arguments.length < 2) {
    throw new TypeError("Object.appendChain - Argumentos insuficientes");
  }
  if (typeof oProto !== "object" && typeof oProto !== "string") {
    throw new TypeError(
      "segundo argumento de Object.appendChain deve ser um objeto ou uma string",
    );
  }

  var oNewProto = oProto,
    oReturn =
      (o2nd =
      oLast =
        oChain instanceof this ? oChain : new oChain.constructor(oChain));

  for (
    var o1st = this.getPrototypeOf(o2nd);
    o1st !== Object.prototype && o1st !== Function.prototype;
    o1st = this.getPrototypeOf(o2nd)
  ) {
    o2nd = o1st;
  }

  if (oProto.constructor === String) {
    oNewProto = Function.prototype;
    oReturn = Function.apply(null, Array.prototype.slice.call(arguments, 1));
    this.setPrototypeOf(oReturn, oLast);
  }

  this.setPrototypeOf(o2nd, oNewProto);
  return oReturn;
};
```

### Exemplos

#### Primeiro exemplo: Adicionar uma cadeia a um 'prototype'

```js
function Mammal() {
  this.isMammal = "yes";
}

function MammalSpecies(sMammalSpecies) {
  this.species = sMammalSpecies;
}

MammalSpecies.prototype = new Mammal();
MammalSpecies.prototype.constructor = MammalSpecies;

var oCat = new MammalSpecies("Felis");

console.log(oCat.isMammal); // 'yes'

function Animal() {
  this.breathing = "yes";
}

Object.appendChain(oCat, new Animal());

console.log(oCat.breathing); // 'yes'
```

#### Segundo exemplo: Transformar um valor primitivo em uma instância de seu construtor e anexar sua cadeia a um 'prototype'

```js
function MySymbol() {
  this.isSymbol = "yes";
}

var nPrime = 17;

console.log(typeof nPrime); // 'number'

var oPrime = Object.appendChain(nPrime, new MySymbol());

console.log(oPrime); // '17'
console.log(oPrime.isSymbol); // 'yes'
console.log(typeof oPrime); // 'object'
```

#### Terceiro exemplo: Anexar uma cadeia ao objeto Function.prototype e anexar uma nova função a essa cadeia

```js
function Person(sName) {
  this.identity = sName;
}

var george = Object.appendChain(
  new Person("George"),
  'console.log("Hello guys!!");',
);

console.log(george.identity); // 'George'
george(); // 'Hello guys!!'
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.setprototypeof |

Compatibilidade com navegadores
-------------------------------

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

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

* `Reflect.setPrototypeOf()` (en-US)
* `Object.prototype.isPrototypeOf()`
* `Object.getPrototypeOf()`
* `Object.prototype.__proto__`


Object.preventExtensions() - JavaScript

Object.preventExtensions()
==========================

O método **`Object.preventExtensions()`** impede que novas propriedades sejam adicionadas a um objeto (isto é, impede futuras extensões ao objeto).

Syntax
------
```

Object.preventExtensions(obj)
```

### Parâmetros

`obj`

O objeto a tornar-se não-extensível.

### Valor de retorno

Um objeto tornado não-extensível.

Descrição
---------

Um objeto é extensível se novas propriedades puderem der adicionadas ao mesmo. `Object.preventExtensions()` marca um objeto como não mais extensível, de forma que este nunca terá novas propriedades além daquelas que o objeto tinha quando foi marcado como não-extensível. Note que as propriedades de um objeto não-extensível, em geral, ainda poderão ser *apagadas*. Tentativas de adicionar novas propriedades a um objeto não-extensível falharão, tanto silenciosamente ou lançando uma exceção `TypeError` (mais comumente, mas não exclusivamente, quando em strict mode (en-US)).

`Object.preventExtensions()` evita apenas a adição de novas propriedades diretas. Proprieades ainda poderão ser adicionadas ao protótipo do objeto.

É impossível tornar um objeto extensível novamente uma vez que o mesmo tenha se tornado não-extensível.

Exemplos
--------

```js
// Object.preventExtensions retorna o objeto
// tornado não-extensível.
var obj = {};
var obj2 = Object.preventExtensions(obj);
obj === obj2; // verdadeiro

// Objetos são extensíveis por padrão...
var empty = {};
Object.isExtensible(empty); // === verdadeiro

// ...mas isso pode ser mudado.
Object.preventExtensions(empty);
Object.isExtensible(empty); // === falso

// Object.defineProperty lança erro quando adiciona-se
// uma nova propriedade a um objeto não-extensível.
var nonExtensible = { removable: true };
Object.preventExtensions(nonExtensible);
Object.defineProperty(nonExtensible, "new", {
  value: 8675309,
}); // lança um TypeError

// No modo restrito, tentar adicionar novas propriedades a
// um objeto não-extensível lança um TypeError.
function fail() {
  "use strict";
  // lança um TypeError
  nonExtensible.newProperty = "FAIL";
}
fail();
```

O protótipo não-extensível de um objeto é imutável:

```js
var fixed = Object.preventExtensions({});
// lança um 'TypeError'.
fixed.__proto__ = { oh: "hai" };
```

Notas
-----

No ES5, se o argumento atribuído a este método não for um objeto (for um primitivo), isso causará um erro de tipo `TypeError`. No ES2015, um argumento não-objeto será tratado como se o mesmo fosse um objeto não-extensível comum, simplesmente retornando-o.

```js
Object.preventExtensions(1);
// TypeError: 1 não é um objeto (código ES5)

Object.preventExtensions(1);
// 1 (código ES2015)
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.preventextensions |

Compatibilidade com navegadores
-------------------------------

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

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

* `Object.isExtensible()`
* `Object.seal()`
* `Object.isSealed()`
* `Object.freeze()`
* `Object.isFrozen()`
* `Reflect.preventExtensions()` (en-US)


RegExp.prototype.ignoreCase - JavaScript

RegExp.prototype.ignoreCase
===========================

O atributo **`ignoreCase`** indica se a flag "i" foi ou não utilizada com a expressão regular.`ignoreCase` é um atributo somente leitura de uma instância individual de expressãoregular.Experimente
-----------

| Property attributes of `RegExp.prototype.ignoreCase` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | yes |

Descrição
---------

O valor de `ignoreCase` é um `Boolean` e`true` se a flag "`i`" foi usada; `false` caso contrário. A flag "i" indica que maiúsculas e minúsculas são equivalentes ao se tentar casar uma string com a expressão regular.

Você não pode alterar essa propriedade diretamente.

Exemplos
--------

### Usando `ignoreCase`

```js
var regex = new RegExp("foo", "i");

console.log(regex.ignoreCase); // true
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.ignorecase |

Compatibilidade com navegadores
-------------------------------

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

See also
--------

* `RegExp.lastIndex` (en-US)
* `RegExp.prototype.global` (en-US)
* `RegExp.prototype.multiline` (en-US)
* `RegExp.prototype.source` (en-US)
* `RegExp.prototype.sticky`


RegExp.prototype.sticky - JavaScript

RegExp.prototype.sticky
=======================

A propriedade **`sticky`** indica se a busca é "pegajosa" (percorre a string somente a partir do índice indicado pela propriedade `lastIndex` (en-US) desta expressão regular). A propriedade `sticky` em um objeto de expressão regular é somente para leitura.

Experimente
-----------

| Property attributes of `RegExp.prototype.sticky` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | yes |

Descrição
---------

O valor de `sticky` é do tipo `Boolean` e será *true* quando a flag "`y`" for utilizada; senão, será *false*. A flag "`y`" indica que as correspondências ocorrerão apenas a partir do indice indicado pela propriedade `lastIndex` (en-US) desta expressão regular na string alvo (e não buscará correspondência em nenhum índice anterior). Uma expressão regular definida como `sticky` e `global` ignora a flag `global`.

Você não pode alterar essa propriedade diretamente. Ela é somente para leitura.

Exemplos
--------

### Uilizando uma expressão regular com a flag *sticky*

```js
var str = "#foo#";
var regex = /foo/y;

regex.lastIndex = 1;
regex.test(str); // true
regex.lastIndex = 5;
regex.test(str); // false (lastIndex é levado em conta com a flag sticky)
regex.lastIndex; // 0 (reinicia quando não ocorre correspondência)
```

### Flag sticky ancorada

Por diversas versões, a engine SpiderMonkey do Firefox apresentou um bug na asserção de `^` com a flag *sticky* que fazia expressões iniciando com `^` e usando a flag *sticky* encontrarem correspondências onde não deveriam. O bug foi introduzido algum tempo após o Firefox 3.6 (que possuía a flag sticky mas não apresentava o bug) e corrigido em 2015. Talvez por este motivo, a especificação ES2015 destaca especificamente que:

>
> Quando a flag `y` for usada em um padrão, ^ indica que a correspondência ocorrerá apenas no início da entrada, ou (se `multiline` for `true`) no início de uma linha.
>
>
>

Exemplos de comportamento esperado:

```js
var regex = /^foo/y;
regex.lastIndex = 2;
regex.test("..foo"); // false - índice 2 não é o início da string

var regex2 = /^foo/my;
regex2.lastIndex = 2;
regex2.test("..foo"); // false - índice 2 não é o início da string nem da linha
regex2.lastIndex = 2;
regex2.test(".\nfoo"); // true - índice 2 é o início da linha
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.sticky |

Compatibilidade com navegadores
-------------------------------

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

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

* `RegExp.lastIndex` (en-US)
* `RegExp.prototype.global` (en-US)
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.multiline` (en-US)
* `RegExp.prototype.source` (en-US)


RegExp.prototype.exec() - JavaScript

RegExp.prototype.exec()
=======================

O método **`exec()`** executa a busca por um padrão em uma determinada string. Retorna um array, ou `null`.

Se você está precisa somente de um retorno verdadeiro/falso, use o método `RegExp.prototype.test()` ou `String.prototype.search()`.

Sintaxe
-------
```

regexObj.exec(string)
```

### Parâmetros

`string`

A string para comparar com a expressão regular

### Valor retornado

Se a combinação acontecer, o método `exec()` o método retorna um array e atualiza as propriedades do objeto da expressão regular. Esse array retornado possui o texto combinado como primeiro item e depois um item para cada captura contendo o respectivo texto.

Se falhar, o retorno do método `exec()` será `null`.

Descrição
---------

Considere o exemplo abaixo:

```js
// Encontra combinações "quick brown" seguido de "jumps", ignorando caracteres entre eles
// Relembra "brown" e "jumps"
// Ignora caixa (maiúsculo e minúsculo)
var re = /quick\s(brown).+?(jumps)/gi;
var result = re.exec("The Quick Brown Fox Jumps Over The Lazy Dog");
```

A tabela a seguir provê os resultados do script:

|  |  |  |  |
| --- | --- | --- | --- |
| Objeto | Propriedade/Índice | Descrição | Exemplo |
| `result` | `[0]` | A string completa dos caracteres encontrados | `Quick Brown Fox Jumps` |
| `[1], ...[*n* ]` |
 As combinações de substrings parametrizadas encontradas, se existir. A
 quantidade de possíveis substrings parametrizadas é ilimitado.
  | `[1] = Brown[2] = Jumps` |
| `index` | O índice base 0 do valor encontrado na string. | `4` |
| `input` | String original | `The Quick Brown Fox Jumps Over The Lazy Dog` |
| `re` | `lastIndex` |
 O índice que começa a próxima combinação encontrada. Quando
 "`g`" não é definido, este valor será sempre 0.
  | `25` |
| `ignoreCase` |
 Indica se a flag "`i`" foi usada para ignorar caixa
 alta/baixa.
  | `true` |
| `global` |
 Indica se a flag "`g`" foi usada para encontrar combinações
 de forma global.
  | `true` |
| `multiline` |
 Indica se a flag "`m`" foi usada para pesquisar em strings de
 diversas linhas.
  | `false` |
| `source` | Texto do padrão. | `quick\s(brown).+?(jumps)` |

Exemplos
--------

### Procurando combinações sucessivas

If your regular expression uses the "`g`" flag, you can use the `exec()` method multiple times to find successive matches in the same string. When you do so, the search starts at the substring of `str` specified by the regular expression's `lastIndex` (en-US) property (`test()` will also advance the `lastIndex` (en-US) property). For example, assume you have this script:

```js
var myRe = /ab\*/g;
var str = "abbcdefabh";
var myArray;
while ((myArray = myRe.exec(str)) !== null) {
  var msg = "Found " + myArray[0] + ". ";
  msg += "Next match starts at " + myRe.lastIndex;
  console.log(msg);
}
```

This script displays the following text:
```

Found abb. Next match starts at 3
Found ab. Next match starts at 9
```

Nota: Do not place the regular expression literal (or `RegExp` constructor) within the `while` condition or it will create an infinite loop if there is a match due to the `lastIndex` (en-US) property being reset upon each iteration. Also be sure that the global flag is set or a loop will occur here also.

### Usando `exec()` com `RegExp` literais

You can also use `exec()` without creating a `RegExp` object:

```js
var matches = /(hello \S+)/.exec("This is a hello world!");
console.log(matches[1]);
```

This will log a message containing 'hello world!'.

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype.exec |

Compatibilidade com navegadores
-------------------------------

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

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

* O capítulo de Expressões Regulares no Guia de Javascript.
* `RegExp`


RegExp.prototype.compile() - JavaScript

RegExp.prototype.compile()
==========================

**Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

O método **`compile()`** está depreciado, é usado para (re-)compilar uma expressão regular durante a execução de um script. É basicamente o mesmo que o construtor `RegExp`.

Sintaxe
-------
```

regexObj.compile(pattern, flags)
```

### Parâmetros

`pattern`

É o texto da expressão regular.

`flags`

Se especificado, as flags podem ter qualquer combinação dos seguintes valores:

`g`

global.

`i`

ignorar caso.

`m`

multilinha; trata os caracteres iniciais e finais como (^ e $), trabalhando sobre várias linhas (isto é, corresponde ao início ou ao final de cada linha (delimitado por \n ou \r), não apenas o começo, ou o final de toda a cadeia de entrada).

`y`

sticky; corresponde apenas ao índice indicado pela propriedade `lastIndex` dessa expressão regular na cadeia de destino (e não tenta corresponder a partir de índices posteriores).

Descrição
---------

O método de `compilação` é obsoleto. Você pode simplesmente usar o construtor `RegExp` para obter o mesmo efeito.

Exemplos
--------

### Usando `compile()`

O exemplo a seguir mostra como recompilar uma expressão regular com um novo padrão e um nova flag.

```js
var regexObj = new RegExp("foo", "gi");
regexObj.compile("new foo", "g");
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype.compile |

Browser compativeis
-------------------

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

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

* `RegExp`


RegExp.prototype.test() - JavaScript

RegExp.prototype.test()
=======================

O método **test()** executa uma busca por uma correspondência entre uma expressão regular e uma string. Retorna `true` ou `false`.Sintaxe
-------
```

regexObj.test(str)
```

### Parâmetros

`str`

A string que confrontará a expressão regular. Todos os valores são convertidos em strings, portanto, omiti-lo ou passar undefined faz com que test() procure a string "undefined".

### Retorno

Boolean.

`true` se a string `str` corresponde com o que está descrito na expressão regular.

Caso contrário, retorna `false`.

Descrição
---------

Use test() sempre que você quiser saber se um padrão está dentro de uma string( similar ao método `String.prototype.search()`); Para mais informações (porém com execução mais lenta) use o método `exec()` (similar ao método `String.prototype.match()`). Assim como `exec()` (ou em combinação com ele), test() quando chamado várias vezes dentro da mesma instância de expressão regular irá avançar seu ponteiro para a correspondência anterior.

Exemplos
--------

### Usando `test()`

Exemplo simples que verifica se `"hello"` está presente no início de uma string, retornando um booleano como resultado.
```

const str = 'hello world!';
const result = /^hello/.test(str);

console.log(result); // true
```

O exemplo a seguir mostra uma mensagem dependendo do sucesso do teste.

```js
function testinput(re, str) {
  var midstring;
  if (re.test(str)) {
    midstring = " Contém ";
  } else {
    midstring = " não contém ";
  }
  console.log(str + midstring + re.source);
}
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype.test |

Compatibilidade com navegadores
-------------------------------

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

Gecko-specific notes
--------------------

A priori no Grecko 8.0, `test()` foi implementado incorretamente; quando chamado sem parâmetros, ele encontrária uma correspondência com o valor de entrada anterior (`RegExp.input` property) no lugar de uma correspondência com `"undefined"`. Isso está conrrigido; agora `/undefined/.test()` resultará em `true`, no lugar de um erro.

See also
--------

* Regular Expressions chapter in the JavaScript Guide
* `RegExp`


RegExp.prototype.toString() - JavaScript

RegExp.prototype.toString()
===========================

O método **`toString()`** retorna uma string que representa uma expressão regular.

Experimente
-----------

Sintaxe
-------

```js
toString();
```

### Valor retornado

Uma string representando o objeto dado.

Descrição
---------

 O objeto `RegExp` subscreve o método `toString()` do objeto
 `Object`; ele não herda `Object.prototype.toString()`.
 Para objetos `RegExp`, o método `toString()` retorna uma
 representação da expressão regular como string.

Exemplos
--------

### UsandotoString()

O exemplo a seguir exibe o valor em string de um objeto `RegExp`

```js
const myExp = new RegExp("a+b+c");
console.log(myExp.toString()); // logs '/a+b+c/'
const foo = new RegExp("bar", "g");
console.log(foo.toString()); // logs '/bar/g'
```

### Expressões regulares vazias e escape

 Introduzindo o ECMAScript 5, uma expressão regular vazia retorna a string "/(?:)/" e
 terminadores de linha como "\n" são utilizados

```js
new RegExp().toString(); // "/(?:)/"
new RegExp("\n").toString() === "/\n/"; // verdadeiro, antes do ES5
new RegExp("\n").toString() === "/\\n/"; // verdadeiro, introduzindo o ES5
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype.tostring |

Browsers compativeis
--------------------

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

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

* `Object.prototype.toString()`


Boolean.prototype.toString() - JavaScript

Boolean.prototype.toString()
============================

O método **`toString()`** retorna uma string representando o objeto Boolean específico.

Sintaxe
-------
```

bool.toString()
```

### Valor retornado

Uma string representando o objeto `Boolean` específico.

Descrição
---------

O objeto `Boolean` sobrepõe o método `toString` do objeto `Object`; ele não herda `Object.prototype.toString()`. Para objetos Boolean, o método `toString` retorna uma representação do objeto como string.

O JavaScript chama o método `toString` automaticamente quando uma `Boolean` deve ser representado como texto ou quando uma `Boolean` é referenciada como uma concatenação de string.

Para objetos e valores `Boolean`, o método nativo `toString` retorna a string "`true`" ou "`false`", dependendo do valor do objeto boleano.

Exemplos
--------

### Usando `toString`

No código a seguir, `flag.toString()` retorna "`true`":

```js
var flag = new Boolean(true);
var myVar = flag.toString();
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-boolean.prototype.tostring |

Compatibilidade com navegadores
-------------------------------

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

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

* `Object.prototype.toString()`


Boolean.prototype.valueOf() - JavaScript

Boolean.prototype.valueOf()
===========================

O método **`valueOf()`** retorna o valor primitivo de um objeto `Boolean`.

Sintaxe
-------
```

bool.valueOf()
```

### Parâmetros

Nenhum.

Descrição
---------

O método `valueOf` do `Boolean` retorna o valor primitivo de um objeto `Boolean` ou um literal `Boolean` como tipo de dado Boolean.

Esse método é geralmente chamado internamente pelo JavaScript e não explicitamente no código.

Exemplos
--------

### Usando `valueOf`

```js
x = new Boolean();
myVar = x.valueOf(); // atribui o valor false à variável myVar
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-boolean.prototype.valueof |

Compatibilidade com navegadores
-------------------------------

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

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

* `Object.prototype.valueOf()`


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

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

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

Tipo do erro: "x" é (não é) "y"

Exemplos:
Tipo do erro: "x" é indefinido
Tipo do erro: "x" é nulo
Tipo do erro: "x" indefinido" não é um objeto
Tipo do erro: "x" não é um objeto ou é nulo
Tipo do erro: "x" não é um símbolo
```

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

`TypeError`.

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

Houve um tipo inesperado. Isso ocorre muitas vezes com valores `undefined` ou `null`.

Além disso, certos métodos, tais como `Object.create()` ou `Symbol.keyFor()` (en-US), requerem um tipo específico, que deve ser fornecido.

Exemplos
--------

### Casos inválidos

```js
// casos undefined e null nos quais o método substring não vai funcionar
var foo = undefined;
foo.substring(1); // TypeError: foo is undefined

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

// Certos métodos podem precisar de um tipo específico
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
```

### Consertando o problema

Para consertar o pointeiro nulo para valores `undefined` ou `null`, você pode utilizar o operador typeof , por exemplo.

```js
if (typeof foo !== "undefined") {
  // Agora nós sabemos que foo está definido, então podemos prosseguir.
}
```

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

* `undefined`
* `null`


SyntaxError: missing variable name - JavaScript

SyntaxError: missing variable name
==================================

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

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

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

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

O nome de uma variável está faltando. Isto é provavelmente devido a um erro de sintaxe no seu código. Provavelmente uma vírgula está errada em algum lugar. Totalmente compreensível! Nomear as coisas é tão difícil.

Exemplos
--------

### Falta um nome de variável

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

É difícil chegar com bons nomes de variáveis. Nós todos estivemos lá.

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

### Palavras-chave reservadas não podem ser nomes de variáveis

Existem alguns nomes de variáveis que são palavras-chave resevadas. Você não pode usar isso. Desculpa :(

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

### Declarando múltiplas variáveis

Preste especial atenção às vírgulas ao declarar múltiplas variáveis. Existe um excesso de vírgula? Você acidentalmente adicionou vírgulas em vez de ponto e vírgula?

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

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

// SyntaxError: missing variable name
```

A versão corrigida:

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

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

### Arrays

`Array` literais em JavaScript precisam de colchetes ao redor dos valores. Isso não funcionará:

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

Isso seria correto:

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

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

* Bons nomes de variáveis
* `var`
* Declarações de variáveis no Guia JavaScript


RangeError: invalid date - JavaScript

RangeError: invalid date
========================

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

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

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

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

Uma string apontando para uma data inválida foi disponibilizada para `Date` ou `Date.parse()`.

Exemplos
--------

### Casos inválidos

Strings irreconhecíveis ou data contendo elementos de strings formatadas com valores ISO ilegais, geralmente retornam `NaN`. No entanto, dependendo da implementação, strings com formatos em não conformidade ISO, também podem disparar `RangeError: invalid date`, como os seguintes casos no Firefox:

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

Isto, no entanto, retorna `NaN` no Firefox:

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

Para mais detalhes, veja a documentação `Date.parse()`.

### Casos válidos

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

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

* `Date`
* `Date.prototype.parse()`
* `Date.prototype.toISOString()`


ReferenceError: "x" não está definido - JavaScript

ReferenceError: "x" não está definido
=====================================

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

ReferenceError: "x" is not defined
```

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

`ReferenceError`O que deu errado?
-----------------

Há uma variavel inexistente referenciada em algum lugar. Essa variável precisa ser declarada ou você precisa ter certeza que ela está disponível no seu atual script ou escopo.

**Nota:** Quando carregar uma biblioteca (como o JQuery) tenha certeza que ela está carregada antes que você acesse as variáveis dela, como "$". Coloque na tag `<script>` para carregar a biblioteca antes do seu código usá-lo.

Exemplos
--------

### Variável não declarada

```js
foo.substring(1); // ReferenceError: foo is not defined
```

A variável "foo" não está definida em lugar nenhum. Ela precisa ser uma string e assim o método `String.prototype.substring()` irá funcionar.

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

### Escopo Errado

Uma variável precisa estar disponível no atual contexto de execução. Variáveis definidas dentro de uma function não podem ser acessadas de outros lugares fora da função, porque a variável é definida apenas no escopo da função

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

console.log(num1); // ReferenceError num1 is not defined.
```

Entretanto, uma função pode acessar todas as variáveis e funções definidas dentro do escopo no qual elas estão definidas. Em outras palavras, uma função definida no escopo global pode acessar todas as variáveis no escopo global.

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

function numbers() {
  return num1 + num2;
}

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

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

* Scope
* Declarando variáveis no JavaScript
* Escopo de função no JavaScript


SyntaxError: unterminated string literal - JavaScript

SyntaxError: unterminated string literal
========================================

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

SyntaxError: unterminated string literal
```

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

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

Há uma `String` não finalizada em algum lugar do código. String literais devem se fechadas com aspas simples (`'`) ou duplas (`"`) . O JavaScript não faz distinção entre strings com aspas simples ou aspas duplas. As sequências de escape trabalham com strings criadas tanto com aspas simples, quanto com aspas duplas. Para consertar este erro, verifique se:

* você abriu e fechou sua string literal com aspas (simples ou duplas),
* você escapou sua string literal corretamente,
* sua string funciona corretamente em várias linhas, se houver.
Exemplos
--------

### Múltiplas linhas

Você não pode dividir sua string em múltiplas linhas em Javascript:

```js
var longString = "This is a very long string which needs
                  to wrap across multiple lines because
                  otherwise my code is unreadable.";
// SyntaxError: unterminated string literal
```

Ao invés disso, você deve utilizar o operador + operator (en-US), uma barra invertida(\), ou modelos literais. Uma forma de uso do operador `+`, seria assim:

```js
var longString =
  "This is a very long string which needs " +
  "to wrap across multiple lines because " +
  "otherwise my code is unreadable.";
```

Ou você pode usar uma barra invertida ("\") ao final de cada linha para indicar que a string continuará na próxima linha. Certifique-se de que não há espaço ou qualquer outro caractere após a barra invertida (excento quando for uma quebra de linha), ou como indentação; caso contrário, não funcionará. Esta forma ficaria assim:

```js
var longString =
  "This is a very long string which needs \
to wrap across multiple lines because \
otherwise my code is unreadable.";
```

Uma outra possibilidade é usar um modelo literal, que é suportado pelos ambientes ECMAScript 2015:

```js
var longString = `This is a very long string which needs
 to wrap across multiple lines because
 otherwise my code is unreadable.`;
```

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

* `String`
* Modelos literais


SyntaxError: uma declaração na cabeça de um laço for-of não pode ter um inicializador - JavaScript

SyntaxError: uma declaração na cabeça de um laço for-of não pode ter um inicializador
=====================================================================================

A exceção JavaScript "a declaration in the head of a for-of loop can't have an initializer" ocorre quando a cabeça de um for...of loop contém uma expressão inicializadora tal como `for (const i = 0 of iteravel)`. Isto não é permitido no laço `for-of`.

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

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

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

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

The head of a for...of loop contains an initializer expression. That is, a variable is declared and assigned a value `for (const i = 0 of iterable)`. This is not allowed in for-of loops. You might want a `for` loop that does allow an initializer.

A cabeça de um laço for...of contém uma expressão inicializadora. Ou seja, uma variável é declarada e atribuída um valor `for (const i = 0 in iteravel)`. Isto não é permitido no laço for-of. Vocẽ pode querer utilizar um laço `for` que permita um inicializador.

Exemplos
--------

### Laços for-of inválidos

```js
const iteravel = [10, 20, 30];

for (const valor = 50 of iteravel) {
  console.log(valor);
}

// SyntaxError: a declaration in the head of a for-of loop can't
// have an initializer
```

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

É necessário remover o inicializador (`valor = 50`) na cabeça do laço `for-of`. Talvez pretendesse fazer de 50 um valor de offset, nesse caso poderia adicioná-lo ao corpo do laço, por exemplo.

```js
const iteravel = [10, 20, 30];

for (let valor of iteravel) {
  valor += 50;
  console.log(valor);
}
// 60
// 70
// 80
```

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

* `for...of`
* `for...in` – disallows an initializer in strict mode as well (SyntaxError: for-in loop head declarations may not have initializers)
* `for` – allows to define an initializer when iterating.


ReferenceError: Atribuição à variável não declarada "x" - JavaScript

ReferenceError: Atribuição à variável não declarada "x"
=======================================================

Message
-------
```

ReferenceError: Atribuição à variável não declarada "x"(Firefox)
ReferenceError: "x" não está definido (Chrome)
ReferenceError: Variável indefinida em strict mode (Edge)
```

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

`ReferenceError` aviso em *strict mode* somente.

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

Um valor foi atribuído a uma variável não declarada. Em outras palavras, houve uma atribuição sem a palavra-chave var. Existem algumas diferenças entre as variáveis declaradas e não declaradas, o que pode levar a resultados inesperados e é por isso que o JavaScript apresenta um erro no modo estrito.

Três coisas a observar sobre as variáveis declaradas e não declaradas:

* Variáveis declaradas são limitadas no contexto de execução em que são declarados. Variáveis não declaradas são sempre globais.
* Variáveis declaradas são criados antes de qualquer código ser executado. Variáveis não declaradas não existem até que o código atribuido for executado.
* Variáveis declaradas são uma propriedade não-configurável de seu contexto de execução (função ou global). Variáveis não declaradas são configuráveis (por exemplo, pode ser excluído).

Para mais exemplos, veja a página de referência `var`.

Erros sobre atribuições de variáveis não declaradas ocorrem apenas em código de modo estrito. Em código não-estrito, eles são silenciosamente ignorados.

Exemplos
--------

### Casos inválidos

neste caso, a variavel "bar" é uma variavel não declarada.

```js
function foo() {
  "use strict";
  bar = true;
}
foo(); // ReferenceError: assignment to undeclared variable bar
```

### Casos válidos

Para fazer uma variável declarada "bar", você pode adicionar a palavra-chave var na frente dele.

```js
function foo() {
  "use strict";
  var bar = true;
}
foo();
```

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

* *Strict mode*


TypeError: property "x" is non-configurable and can't be deleted - JavaScript

TypeError: property "x" is non-configurable and can't be deleted
================================================================

 A exceção do Javascript "property is non-configurable and can't be deleted" ocorre
 quando é feita a tentativa de deletar uma propriedade, mas a propriedade não é configurável.

Mensagem
--------

```js
TypeError: Calling delete on 'x' is not allowed in strict mode (Edge)
TypeError: property "x" is non-configurable and can't be deleted. (Firefox)
TypeError: Cannot delete property 'x' of #<Object> (Chrome)
```

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

`TypeError` apenas no modo strict.

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

 Foi feita a tentativa de deletar uma propriedade, mas esta propriedade não é configurável. O
 atributo `configurable` controla se a propriedade pode ser deletada do
 objeto e se seus atributos (Exceto `writable`) podem ser alterados.

 Este erro acontece apenas no modo strict. No
 modo de código não estrito, a operação retorna `false`.

Exemplos
--------

### Tentando excluir uma propriedade não configurável

 Propriedades não configuráveis não são comuns, mas podem ser criadas usando
 `Object.defineProperty()` ou `Object.freeze()`.

```js
"use strict";
var obj = Object.freeze({ name: "Elsa", score: 157 });
delete obj.score; // TypeError

("use strict");
var obj = {};
Object.defineProperty(obj, "foo", { value: 2, configurable: false });
delete obj.foo; // TypeError

("use strict");
var frozenArray = Object.freeze([0, 1, 2]);
frozenArray.pop(); // TypeError
```

 Também existem algumas propriedades não configuráveis embutidas no Javascript. Talvez você tenha
 tentado deletar uma constante matemática.

```js
"use strict";
delete Math.PI; // TypeError
```

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

* Operador delete (en-US)
* `Object.defineProperty()`
* `Object.freeze()`


SyntaxError: JSON.parse: bad parsing - JavaScript

SyntaxError: JSON.parse: bad parsing
====================================

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

SyntaxError: JSON.parse: unterminated string literal
SyntaxError: JSON.parse: bad control character in string literal
SyntaxError: JSON.parse: bad character in string literal
SyntaxError: JSON.parse: bad Unicode escape
SyntaxError: JSON.parse: bad escape character
SyntaxError: JSON.parse: unterminated string
SyntaxError: JSON.parse: no number after minus sign
SyntaxError: JSON.parse: unexpected non-digit
SyntaxError: JSON.parse: missing digits after decimal point
SyntaxError: JSON.parse: unterminated fractional number
SyntaxError: JSON.parse: missing digits after exponent indicator
SyntaxError: JSON.parse: missing digits after exponent sign
SyntaxError: JSON.parse: exponent part is missing a number
SyntaxError: JSON.parse: unexpected end of data
SyntaxError: JSON.parse: unexpected keyword
SyntaxError: JSON.parse: unexpected character
SyntaxError: JSON.parse: end of data while reading object contents
SyntaxError: JSON.parse: expected property name or '}'
SyntaxError: JSON.parse: end of data when ',' or ']' was expected
SyntaxError: JSON.parse: expected ',' or ']' after array element
SyntaxError: JSON.parse: end of data when property name was expected
SyntaxError: JSON.parse: expected double-quoted property name
SyntaxError: JSON.parse: end of data after property name when ':' was expected
SyntaxError: JSON.parse: expected ':' after property name in object
SyntaxError: JSON.parse: end of data after property value in object
SyntaxError: JSON.parse: expected ',' or '}' after property value in object
SyntaxError: JSON.parse: expected ',' or '}' after property-value pair in object literal
SyntaxError: JSON.parse: property names must be double-quoted strings
SyntaxError: JSON.parse: expected property name or '}'
SyntaxError: JSON.parse: unexpected character
SyntaxError: JSON.parse: unexpected non-whitespace character after JSON data
```

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

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

`JSON.parse()` converte uma string para JSON. A string precisa ser um JSON válido e retornará esse erro caso a sintaxe esteja errada.

Exemplos
--------

### `JSON.parse()` não permite vírgulas à direita

As duas linhas retornarão um SyntaxError:

```js
JSON.parse("[1, 2, 3, 4,]");
JSON.parse('{"foo": 1,}');
// SyntaxError JSON.parse: unexpected character
// at line 1 column 14 of the JSON data
```

Retire as virgulas sobrando para converter o JSON corretamente:

```js
JSON.parse("[1, 2, 3, 4]");
JSON.parse('{"foo": 1}');
```

### Propriedades precisão ser escritas com aspas duplas

Você não pode usar aspas simples em propriedades, exemplo: 'foo'.

```js
JSON.parse("{'foo': 1}");
// SyntaxError: JSON.parse: expected property name or '}'
// at line 1 column 2 of the JSON data
```

Em vez disso use "foo":

```js
JSON.parse('{"foo": 1}');
```

### Zeros à esquerda e pontos decimais

Você não pode usar zeros à esquerda, como 01, e pontos decimais precisam ser seguidos de pelo menos um digito.

```js
JSON.parse('{"foo": 01}');
// SyntaxError: JSON.parse: expected ',' or '}' after property value
// in object at line 1 column 2 of the JSON data

JSON.parse('{"foo": 1.}');
// SyntaxError: JSON.parse: unterminated fractional number
// at line 1 column 2 of the JSON data
```

Em vez disso, use o 1 sem o zero, e pelo menos um digito após um ponto decimal:

```js
JSON.parse('{"foo": 1}');
JSON.parse('{"foo": 1.0}');
```

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

* `JSON`
* `JSON.parse()`
* `JSON.stringify()`


SyntaxError: missing } after property list - JavaScript

SyntaxError: missing } after property list
==========================================

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

SyntaxError: missing } after property list
```

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

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

Aconteceu um engano na sintaxe do inicializador do objeto em algum lugar. Pode ser que você esqueceu de colocar uma chave, mas também pode ser uma vírgula que foi esquecida, por exemplo. Verifique também se alguma chave de finalização ou parêntesis estão em algum lugar que não deveriam estar. Indente ou formate o código de uma maneira legível pode te ajudar a enxergar no meio dessa selva.

Exemplos
--------

### Vírgula esquecida

Muitas vezes esquecemos uma vígula no inicializador de objeto:

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

O código correto deve ser:

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

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

* Inicializador de objeto


TypeError: atribuição inválida para const "x" - JavaScript

TypeError: atribuição inválida para const "x"
=============================================

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

TypeError: invalid assignment to const "x" (Firefox)
TypeError: Assignment to constant variable. (Chrome)
TypeError: Assignment to const (Edge)
TypeError: Redeclaration of const 'x' (IE)
```

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

`TypeError`O que deu errado?
-----------------

Uma constante é um valor que não pode ser alterado pelo programa durante a execução normal. Ele não pode mudar através de reatribuição e não pode ser redeclarado. Em JavaScript, as constantes são declaradas usando a palavra-chave `const`.

Exemplos
--------

### Redeclaração inválida

Atribuir um valor ao mesmo nome de constante no mesmo escopo de bloco lançará o erro.

```js
const COLUNAS = 80;

// ...

COLUNAS = 120; // TypeError: invalid assignment to const `COLUNAS'
```

### Corrigindo o erro

Existem várias opções para corrigir esse erro. Verifique o que se pretendia alcançar com a constante em questão.

#### Renomear

Se você quis declarar outra constante, escolha outro nome e renomeie. Esse nome de constante já está sendo usado nesse escopo.

```js
const COLUNAS = 80;
const COLUNAS\_LARGAS = 120;
```

#### `const`, `let` ou `var`?

Não use const se você não quis declarar uma constante. Talvez você quisesse declarar uma variável com escopo de bloco com `let` ou uma variável global com `var`.

```js
let colunas = 80;

// ...

let colunas = 120;
```

#### Escopo

Verifique se você está no escopo correto. Essa constante deve aparecer nesse escopo ou deveria aparecer em uma função, por exemplo?

```js
const COLUNAS = 80;

function configurarAmbienteTelaGrande() {
  const COLUNAS = 120;
}
```

### `const` e imutabilidade

A declaração `const` cria uma referência somente leitura para um valor. Isso **não significa** que o valor que ela contém é imutável, apenas que o identificador da variável não pode ser reatribuído. Por exemplo, caso o conteúdo seja um objeto, isso significa que o objeto em si ainda pode ser alterado. Isso significa que você não pode alterar o valor armazenado em uma variável:

```js
const obj = { foo: "bar" };
obj = { foo: "baz" }; // TypeError: invalid assignment to const `obj'
```

Mas você pode alterar as propriedades em uma variável:

```js
obj.foo = "baz";
obj; // Object { foo: "baz" }
```

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

* `const`
* `let`
* `var`


Erro de Sintaxe: faltando : depois da propriedade id - JavaScript

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


RangeError: invalid array length - JavaScript

RangeError: invalid array length
================================

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

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

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

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

Um comprimento inválido de array pode aparecer nas seguintes situações:

* Quando criamos um `Array` ou um `ArrayBuffer` que tem um comprimento que ou é negativo ou é maior ou igual a 232, ou
* quando configuramos a propriedade `Array.length` a um valor que é negativo, ou maior ou igual a 232.

Porque `Array` e `ArrayBuffer` tem um comprimento limitado? A propriedade `length` de um `Array` ou um `ArrayBuffer` é representado por um inteiro 32-bit unsigned, que pode apenas armazenar valores que estão no intervalo de 0 a 232-1.

Se você está criando um `Array`, utilizando o construtor, você provavelmente quer usar a notação literal, onde o primeiro argumento é interpretado como o comprimento do `Array`.

Ao contrário, você poderia querer travar o comprimento antes de ajustar a propriedade do comprimento, ou utilizá-lo com um argumento do construtor.

Exemplos
--------

### 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; // define -1 à propriedade length

let b = new Array(Math.pow(2, 32) - 1);
b.length = b.length + 1; // define 2^32 à propriedade length
```

### 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 é a notação hexadecimal de 2^32 - 1
// que também pode ser escrito como (-1 >>> 0)
```

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

* `Array`
* `Array.length`
* `ArrayBuffer`


Warning: unreachable code after return statement - JavaScript

Warning: unreachable code after return statement
================================================

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

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

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

Warning

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

Codigo inacessível depois da declaração de retorno pode ocorrer nas seguintes situações:

* Quando usado em uma expressão após a declaração de um `return` , ou
* quando usado em uma expressão **return** sem ponto e vírgula porém incluindo uma expressão diretamente depois.

Quando existe uma expressão após uma declaração válida de `return`, um warning é dado para indicar que o código depois da declaração `return` é inacessível, significando que ele pode nunca ser executado.

Porque eu devo usar ponto-e-virgula após declarações `return`? No caso de declarações `return` sem ponto-e-vírgula, ele pode deixar obscuro se o desenvolvedor quis usar o return na proxima linha, ou parar a execução e retornar. O warning indica que há uma ambiguidade no modo que a declaração `return` foi escrita.

Warnings não serão mostrado para declarações return sem ponto-e-vírgula nas seguintes situações:

* `throw`
* `break`
* `var`
* `function`
Exemplos
--------

### Casos Inválidos

```js
function f() {
  var x = 3;
  x += 4;
  return x; // return exits the function immediately
  x -= 3; // so this line will never run; it is unreachable
}

function f() {
  return; // this is treated like `return;`
  3 + 4; // so the function returns, and this line is never reached
}
```

### Casos Válidos

```js
function f() {
  var x = 3;
  x += 4;
  x -= 3;
  return x; // OK: return after all other statements
}

function f() {
  return 3 + 4; // OK: semicolon-less return with expression on the same line
}
```

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

* Automatic Semicolon Insertion


TypeError: invalid Array.prototype.sort argument - JavaScript

TypeError: invalid Array.prototype.sort argument
================================================

A exceção JavaScript "invalid Array.prototype.sort argument" ocorre quando o argumento de `Array.prototype.sort()` não é `undefined` ou uma função que compara os seus operandos.

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

TypeError: The comparison function must be either a function or undefined (V8-based)
TypeError: invalid Array.prototype.sort argument (Firefox)
TypeError: Array.prototype.sort requires the comparator argument to be a function or undefined (Safari)
```

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

`TypeError`O que ocorreu de errado?
------------------------

Espera-se que o argumento de `Array.prototype.sort()` seja `undefined` ou uma função que compare os seus operandos.

Exemplos
--------

### Casos inválidos

```js
[1, 3, 2].sort(5); // TypeError

const cmp = { asc: (x, y) => x >= y, dsc: (x, y) => x <= y };
[1, 3, 2].sort(cmp[this.key] || "asc"); // TypeError
```

### Casos válidos

```js
[1, 3, 2].sort(); // [1, 2, 3]

const cmp = { asc: (x, y) => x >= y, dsc: (x, y) => x <= y };
[1, 3, 2].sort(cmp[this.key || "asc"]); // [1, 2, 3]
```

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

* `Array.prototype.sort()`


TypeError: "x" is read-only - JavaScript

TypeError: "x" is read-only
===========================

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

TypeError: "x" is read-only (Firefox)
TypeError: 0 is read-only (Firefox)
TypeError: Cannot assign to read only property 'x' of #<Object> (Chrome)
TypeError: Cannot assign to read only property '0' of [object Array] (Chrome)
```

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

`TypeError`O que deu errado?
-----------------

A variável global ou propriedade do objeto foi definida como propriedade somente-leitura. (Tecnicamente, esse é um dado de não-escrita.)

Esse erro ocorre apenas em código no strict mode. No modo não strict mode, essa atribuição é ignorada silenciosamente.

Exemplos
--------

### Casos inválidos

Propriedades somente-leitura não são super comuns, mas elas podem ser criadas utilizando `Object.defineProperty()` ou `Object.freeze()`.

```js
"use strict";
var obj = Object.freeze({ nome: "Elsa", pontuacao: 157 });
obj.pontuacao = 0; // TypeError

("use strict");
Object.defineProperty(this, "CONTADOR\_PULMAO", { value: 2, writable: false });
CONTADOR\_PULMAO = 3; // TypeError

("use strict");
var frozenArray = Object.freeze([0, 1, 2]);
frozenArray[0]++; // TypeError
```

Existem também algumas propriedades somente-leitura nativas do Javascript. Talvez você já tentou redefinir um constante matemática.

```js
"use strict";
Math.PI = 4; // TypeError
```

Desculpe, você não pode fazer isso.

A variável global `undefined` também é somente-leitura, então você não pode silenciar o infame erro "undefined is not a function" fazendo isso:

```js
"use strict";
undefined = function () {}; // TypeError: "undefined" is read-only
```

### Casos válidos

```js
"use strict";
var obj = Object.freeze({ nome: "Score", pontos: 157 });
obj = { nome: obj.nome, pontos: 0 }; // substituindo com o novo objeto funciona

("use strict");
var CONTADOR\_PULMAO = 2; // uma `var` funciona, porque ela não é somente-leitura
CONTADOR\_PULMAO = 3; // ok (anatomicamente improvável, porém...)
```

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

* `Object.defineProperty()`
* `Object.freeze()`
* "Quais animais tem três pulmões?" no answers.com
* Klingons (uma outra resposta para essa pergunta)


TypeError: can't define property "x": "obj" is not extensible - JavaScript

TypeError: can't define property "x": "obj" is not extensible
=============================================================

 A exceção de modo strict do Javascript "can't define property "x": "obj" is not extensible" ocorre
 quando `Object.preventExtensions()` marcou um objeto como não extensível,
 de modo que ele não terá propriedades além das que ele tinha no momento em que foi marcado
 como não extensível.

Mensagem
--------

```js
TypeError: Cannot create property for a non-extensible object (Edge)
TypeError: can't define property "x": "obj" is not extensible (Firefox)
TypeError: Cannot define property: "x", object is not extensible. (Chrome)
```

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

`TypeError`O que deu errado?
-----------------

 Geralmente, um objeto é extensível e novas propriedades podem ser adicionadas a ele. Contudo,
 neste caso `Object.preventExtensions()` marcou o objeto como não extensível,
 de modo que ele não terá propriedades além das que ele tinha no momento em que foi marcado
 como não extensível.

Exemplos
--------

### Adicionando uma nova propriedade para um objeto não extensível

 No modo strict,
 a tentativa de adicionar uma nova propriedade em um objeto não extensível
 lança um `TypeError`. No modo sloppy, a adição da propriedade "x" é
 silenciosamente ignorada.

```js
"use strict";

var obj = {};
Object.preventExtensions(obj);

obj.x = "foo";
// TypeError: can't define property "x": "obj" is not extensible
```

 Em ambos os casos, modo strict e
 modo sloppy, chamar `Object.defineProperty()`
 lança uma exceção quando é adicionada uma nova propriedade em um objeto não extensível.

```js
var obj = {};
Object.preventExtensions(obj);

Object.defineProperty(obj, "x", { value: "foo" });
// TypeError: can't define property "x": "obj" is not extensible
```

 Para corrigir este erro, você precisa remover todas as chamadas para `Object.preventExtensions()`,
 ou movê-las para uma posição para que a propriedade seja adicionada antes e apenas depois o objeto seja marcado
 como não extensível. Naturalmente, você pode remover a tentativa de adicionar a propriedade, se você não
 precisar dela.

```js
"use strict";

var obj = {};
obj.x = "foo"; // adiciona a propriedade antes e só então previne extensões

Object.preventExtensions(obj);
```

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

* `Object.preventExtensions()`


TypeError: can't assign to property "x" on "y": not an object - JavaScript

TypeError: can't assign to property "x" on "y": not an object
=============================================================

 A exceção do modo strict do Javascript "can't assign to property" ocorre quando é feita
 a tentativa de criar uma propriedade em um valor primitivo
 como um symbol, uma string, um number ou um boolean.
 Valores primitivos nâo podem ter nenhuma propriedade.

Mensagem
--------

```js
TypeError: can't assign to property "x" on {y}: not an object (Firefox)
TypeError: Cannot create property 'x' on {y} (Chrome)
```

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

`TypeError`.

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

 No `Strict_mode`, um `TypeError` é gerado quando é feita a tentativa de
 criar uma propriedade em um valor primitivo como
 um symbol, uma string, um number ou um boolean.
 Valores primitivos não podem ter nenhuma propriedade.

 O problema pode ser que um valor inesperado está em um lugar inesperado, ou
 que uma variante de objeto de uma `String` ou um `Number` é esperado.

Exemplos
--------

### Casos inválidos

```js
"use strict";

var foo = "minha string";
// A linha a seguir não faz nada se não estiver em modo strict.
foo.bar = {}; // TypeError: can't assign to property "bar" on "my string": not an object
```

### Corrigindo o problema

Corrija o código para evitar que um primitivo seja usado em tais lugares, ou corrija o problema criando o objeto homólogo `Object`.

```js
"use strict";

var foo = new String("minha string");
foo.bar = {};
```

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

* `Strict_mode`
* Primitivo


Warning: -file- is being assigned a //# sourceMappingURL, but already has one - JavaScript

Warning: -file- is being assigned a //# sourceMappingURL, but already has one
=============================================================================

O aviso "-file- is being assigned a //# sourceMappingURL, ocorre quando um source map foi especificado mais de uma vez para uma determinada origem JavaScript.

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

Warning: -file- is being assigned a //# sourceMappingURL, but already has one.
```

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

Um aviso. A execução do JavaScript não será interrompida.

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

Um source map foi especificado mais de uma vez para uma determinada origem JavaScript.

As fontes JavaScript são frequentemente combinadas e minificadas para tornar a entrega mais eficiente do servidor. Com source maps, o depurador pode mapear o código que está sendo executado para os arquivos de origem originais. Há duas maneiras de atribuir um source map, usando um comentário ou definindo um cabeçalho para o arquivo JavaScript.

Exemplos
--------

### Configurando source maps

Configurando um source map usando um comentário no arquivo:

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

Ou, alternativamente, você pode definir um cabeçalho para seu arquivo JavaScript:

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

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

* Como usar um source map– Documentação do Firefox Tools
* Introdução aos source maps (2012)


TypeError: setting getter-only property "x" - JavaScript

TypeError: setting getter-only property "x"
===========================================

A exceção apenas do modo strict do Javascript "setting getter-only property" ocorre quando é feita a tentativa de definir um novo valor para uma propriedade para qual apenas um getter está especificado.

Mensagem
--------

```js
TypeError: Assignment to read-only properties is not allowed in strict mode (Edge)
TypeError: setting getter-only property "x" (Firefox)
TypeError: Cannot set property "prop" of #<Object> which has only a getter (Chrome)
```

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

`TypeError` no modo strict apenas.

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

 Tem uma tentativa de definir um novo valor para uma propriedade para qual apenas um getter está especificado.
 Isto será silenciosamente ignorado no modo non-strict, enquanto vai lançar um `TypeError` no modo strict.

Exemplos
--------

### Propriedades sem setter

 O exemplo abaixo mostra como definir um getter para uma propriedade. Isso não especifica um setter, então um
 `TypeError` vai ser lançado quando for feita a tentativa de definir a propriedade `temperatura` para `30`. Para mais detalhes veja também a página `Object.defineProperty()`.

```js
"use strict";

function Arquivo() {
  var temperatura = null;
  Object.defineProperty(this, "temperatura", {
    get: function () {
      console.log("get!");
      return temperatura;
    },
  });
}

var arq = new Arquivo();
arq.temperatura; // 'get!'

arq.temperatura = 30;
// TypeError: setting getter-only property "temperatura"
```

 Para corrigir este erro, você vai ter que remover a linha 16, onde é feita a tentativa de definir a propriedade temperatura,
 ou você vai precisar implementar um setter para a propriedade, desta forma, por exemplo:

```js
"use strict";

function Arquivo() {
  var temperatura = null;
  var arquivo = [];

  Object.defineProperty(this, "temperatura", {
    get: function () {
      console.log("get!");
      return temperatura;
    },
    set: function (value) {
      temperatura = value;
      arquivo.push({ val: temperatura });
    },
  });

  this.getArquivo = function () {
    return arquivo;
  };
}

var arq = new Arquivo();
arq.temperatura; // 'get!'
arq.temperatura = 11;
arq.temperatura = 13;
arq.getArquivo(); // [{ val: 11 }, { val: 13 }]
```

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

* `Object.defineProperty()`
* `Object.defineProperties()`


SyntaxError: illegal character - JavaScript

SyntaxError: illegal character
==============================

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

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

Tipo do erro
------------

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

Há um token inválido ou inesperado que não pertence a esta posição no código. Utilize um editor que realce a sintaxe e cuidadosamente verifique seu código em relação a desajustes como um sinal de menos (`-`) no lugar de um travessão (`–`) ou aspas simples (`"`) no lugar de aspas não padronizadas(`“`).

Exemplos
--------

### Caracteres desajustados

Alguns carateres parecem similares, mas irão impedir que o analisador interprete seu código. Exemplos famosos disso são as aspas, o sinal de menos ou o ponto e vírgula (o ponto de interrogação grego (U+37e) é quase igual)

```js
“Isso parece uma string”;
// SyntaxError: illegal character

42 – 13;
// SyntaxError: illegal character
```

Isto deve funcionar:

```js
"Isso é realmente uma string";

42 - 13;
```

### Caracteres esquecidos

É fácil esquecer um caractere aqui ou ali.

```js
var colors = ['#000', #333', '#666'];
// SyntaxError: illegal character
```

Adicione as aspas que faltam no `'#333'`.

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

### Caracteres escondidos

Quando copiamos e colamos código de fontes externas, pode haver caracteres inválidos. Cuidado!

```js
var foo = 'bar';
// SyntaxError: illegal character
```

Quando inspeciona-se este código em um editor como o Vim, você pode ver que, na verdade, há um caractere zero-width space (ZWSP) (U+200B).

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

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

* Lexical grammar


ReferenceError: invalid assignment left-hand side - JavaScript

ReferenceError: invalid assignment left-hand side
=================================================

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

ReferenceError: invalid assignment left-hand side
```

Tipo do erro
------------

`ReferenceError`.

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

Ouve uma declaração inesperada em algum lugar. Isso pode ocorrer devido a uma confusão entre um Operador de atribuição (en-US) e um Operador de comparação (en-US), por exemplo. Enquanto um `"="` define uma variavel, `"=="` ou `"==="` são usados para fazer uma comparação entre valores.

Exemplos
--------

```js
if (Math.PI = 3 || Math.PI = 4) {
  console.log('de modo algum!');
}
// ReferenceError: invalid assignment left-hand side

var str = 'Olá, '
+= 'sou eu '
+= 'que você está procurando?';
// ReferenceError: invalid assignment left-hand side
```

Na declaração `if` você deve usar um operador de comparação ("=="), e para a atribuição da string, apenas o operador mais ("+") é necessario

```js
if (Math.PI == 3 || Math.PI == 4) {
  console.log("de modo algum!");
}

var str = "Olá, " + "do " + "outro lado!";
```

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

* Operadores de atribuição (en-US)
* Operadores de comparação (en-US)


TypeError: "x" is not a function - JavaScript

TypeError: "x" is not a function
================================

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

TypeError: Object doesn't support property or method {x} (Edge)
TypeError: "x" is not a function
```

Tipo do erro
------------

`TypeError`.

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

Houve a tentativa de obter um valor de uma função, mas o valor não é exatamente uma função. Algum código espera que você forneça uma função, mas não foi o que acontenceu.

Talvez exista um erro de digitação no nome da função? Talvez o objeto no qual você está chamando o método não tenha essa função? Por exemplo, objetos no JavaScript não tem a função `map`, mas o objeto Array tem.

Existem várias funções internas que precisam de uma função (callback). Você terá que prover uma função para obter esses métodos funcionando corretamente:

* Quando estiver trabalhando com os objetos `Array` ou `TypedArray` (en-US):
    + `Array.prototype.every()`, `Array.prototype.some()`, `Array.prototype.forEach()`, `Array.prototype.map()`, `Array.prototype.filter()`, `Array.prototype.reduce()`, `Array.prototype.reduceRight()`, `Array.prototype.find()`
* Quando estiver trabalhando com os objetos `Map` ou `Set`:
    + `Map.prototype.forEach()` e `Set.prototype.forEach()` (en-US)
Exemplos
--------

### Um erro de digitação no nome da função

Nesse caso, que ocorre com bastante frequência, existe um erro de digitação no nome do método:

```js
var x = document.getElementByID("foo");
// TypeError: document.getElementByID is not a function
```

O nome correto da função é `getElementById`:

```js
var x = document.getElementById("foo");
```

### Função chamada no objeto errado

Para alguns métodos, é necessário fornecer a função (callback) que irá funcionar apenas em objetos específicos. Nesse exemplo, é utilizado `Array.prototype.map()` que irá funcionar apenas em objetos `Array`.

```js
var obj = { a: 13, b: 37, c: 42 };

obj.map(function (num) {
  return num \* 2;
});

// TypeError: obj.map is not a function
```

Ao invés disso, use uma array:

```js
var numbers = [1, 4, 9];

numbers.map(function (num) {
  return num \* 2;
});

// Array [2, 8, 18]
```

### Função compartilha o nome com uma propriedade pré-existente

Algumas vezes, ao criar uma classe, pode haver uma propriedade e função com os mesmos nomes. Ao chamar a função, o compilador não consegue identificar a função.

```js
var Dog = function () {
  this.age = 11;
  this.color = "black";
  this.name = "Ralph";
  return this;
};

Dog.prototype.name = function (name) {
  this.name = name;
  return this;
};

var myNewDog = new Dog();
myNewDog.name("Cassidy"); //Uncaught TypeError: myNewDog.name is not a function
```

Então, use um nome diferente para a propriedade

```js
var Dog = function () {
  this.age = 11;
  this.color = "black";
  this.dogName = "Ralph"; //Using this.dogName instead of .name
  return this;
};

Dog.prototype.name = function (name) {
  this.dogName = name;
  return this;
};

var myNewDog = new Dog();
myNewDog.name("Cassidy"); //Dog { age: 11, color: 'black', dogName: 'Cassidy' }
```

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

* Funções


TypeError: can't redefine non-configurable property "x" - JavaScript

TypeError: can't redefine non-configurable property "x"
=======================================================

 A exceção do Javascript "can't redefine non-configurable property" ocorre quando é
 feita a tentativa de redefinir uma propriedade, mas essa propriedade não é configurável.

Mensagem
--------

```js
TypeError: Cannot modify non-writable property {x} (Edge)
TypeError: can't redefine non-configurable property "x" (Firefox)
TypeError: Cannot redefine property: "x" (Chrome)
```

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

`TypeError`O que deu errado?
-----------------

 Foi feita a tentativa de redefinir uma propriedade, mas essa propriedade não é configurável. O
 atributo `configurable` controla se a propriedade pode ser deletada do
 objeto e se seus atributos (Exceto `writable`) podem ser alterados.
 Geralmente, propriedades de um objeto criado por um inicializador de objeto
 são configuráveis. Contudo, por exemplo, ao usar `Object.defineProperty()`, a propriedade não é configurável por padrão.

Exemplos
--------

### Propriedades não configuráveis criadas por `Object.defineProperty`

`Object.defineProperty()` cria uma propriedade não configurável se você
 não especificá-las como configurável.

```js
var obj = Object.create({});
Object.defineProperty(obj, "foo", { value: "bar" });

Object.defineProperty(obj, "foo", { value: "baz" });
// TypeError: can't redefine non-configurable property "foo"
```

 Você vai precisar alterar a propriedade "foo" para configurável, se você pretende redefini-la
 posteriormente no código.

```js
var obj = Object.create({});
Object.defineProperty(obj, "foo", { value: "bar", configurable: true });
Object.defineProperty(obj, "foo", { value: "baz", configurable: true });
```

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

* [[Configurable]]
* `Object.defineProperty()`


Parâmetros Rest - JavaScript

Parâmetros Rest
===============

A sintaxe de **rest parameter (parâmetros rest)** nos permite representar um número indefinido de argumentos como um array.

Sintaxe
-------

```js
function(a, b, ...theArgs) {
  // ...
}
```

Descrição
---------

Se o último argumento nomeado de uma função tiver prefixo com `...`, ele irá se tornar um array em que os elemento de 0 (inclusive) até theArgs.length (exclusivo) são disponibilizados pelos argumentos atuais passados à função.

No exemplo acima, `theArgs` irá coletar o terceiro argumento da função (porquê o primeiro é mapeado para `a`, e o segundo para `b`) e assim por diante em todos os argumentos consecutivos.

### Diferença entre *rest parameters* e *`arguments` object*

Há três diferenças principais entre *rest parameters* e os `arguments` objects:

* *rest parameters* são os únicos que não foram atribuidos a um nome separado, enquanto os `arguments` object contêm todos os argumentos passados para a função;
* o objeto `arguments` não é um array, enquanto rest parameters são instâncias `Array`, isso significa que métodos como `sort`, `map`, `forEach` ou `pop` podem ser aplicados diretamente;
* o objeto `arguments` possui a funcionalidade adicional de especificar ele mesmo (como a propriedade `callee`).
### De arguments para array

Rest parameters foram criados para reduzir o código padrão que foi induzida pelos argumentos

```js
// Antes rest parameters, o seguinte codigo pode ser encontrado
function f(a, b){
  var args = Array.prototype.slice.call(arguments, f.length);

  // ...
}

// esse é o equivalente

function(a, b, ...args) {

}
```

Exemplos
--------

Como `theArgs` é um array, você pode pegar número de elementos usando a propriedade `length`:

```js
function fun1(...theArgs) {
  console.log(theArgs.length);
}

fun1(); // 0
fun1(5); // 1
fun1(5, 6, 7); // 3
```

No próximo exemplo, nós usamos o rest parâmetro para buscar argumentos do segundo parâmetro para o fim. Nós multiplicamos eles pelo primeiro parâmetro:

```js
function multiply(multiplier, ...theArgs) {
  return theArgs.map(function (element) {
    return multiplier \* element;
  });
}

var arr = multiply(2, 1, 2, 3);
console.log(arr); // [2, 4, 6]
```

O próximo exemplo mostra como você pode usar metodos do Array em rest params, mas não no objeto `arguments`:

```js
function sortRestArgs(...theArgs) {
  var sortedArgs = theArgs.sort();
  return sortedArgs;
}

console.log(sortRestArgs(5, 3, 7, 1)); // Exibe 1,3,5,7

function sortArguments() {
  var sortedArgs = arguments.sort();
  return sortedArgs; // isso nunca irá ocorrer
}

// throws a TypeError: arguments.sort is not a function
console.log(sortArguments(5, 3, 7, 1));
```

a fim de usar o objeto `arguments`, você precisará converte-lo para um array antes.

Especificações
--------------

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

Compatibilidade
---------------

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

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

* Arguments object
* Array
* Functions
* Spread Operator (en-US)
* Original proposal at ecmascript.org
* JavaScript arguments object and beyond