recursal/MDN huggingface dataset:
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()
===========================

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

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

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

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

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

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

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

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

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

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

 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: 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"
=============================================

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`