recursal/MDN huggingface dataset:
parseFloat()
============

A função `parseFloat` analisa um argumento (convertendo-o para uma string primeiro caso necessário) e retorna um número de ponto flutuante (número decimal).

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

Sintaxe
-------


```js
parseFloat(string);
```

### Parâmetros

`string`

O valor para analisar. Se este argumento não é uma string, então ele é convertido para uma, usando a operação abstrata `ToString`. Espaços em branco são ignorados.

### Retorna

Um número de ponto flutuante da `string` dada. Ou `NaN` quando o primeiro carácter, diferente de um espaço em branco, não pôde ser convertido para um número

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

`parseFloat` é uma função top-level e não está associada a nenhum objeto.

`parseFloat` analisa um argumento string, e retorna um numero de ponto flutuante. Se ele encontrar um carácter diferente de um sinal (+ ou -), numeral (0-9), um ponto decimal, ou um expoente, ele retorna o valor até esse ponto e ignora esse caractere e todos os caracteres seguintes. Espaços a direita e a esquerda são permitidos.

Se o primeiro carácter não puder ser convertido para um número, `parseFloat` retorna `NaN`.

Para propósitos aritméticos, o valor `NaN` não é um número de qualquer raiz. Você pode chamar a função `isNaN` para determinar se o resultado do `parseFloat` é `NaN`. Se `NaN` for passado em operações aritméticas, a operação também retornará `NaN`.

`parseFloat` também pode analisar e retornar o valor `Infinity`. Você pode usar a função `isFinite` para determinar se a função é um número finito (not `Infinity`, `-Infinity`, ou `NaN`).

Exemplos
--------

### `parseFloat` retornando um número

O exemplo a seguir sempre retorna `3.14`:


```js
parseFloat("3.14");
parseFloat("314e-2");
parseFloat("0.0314E+2");
parseFloat("3.14more non-digit characters");
```

### `parseFloat` retornando `NaN`

O exemplo a seguir retorna `NaN`


```js
parseFloat("FF2");
```

### Uma função de análise estrita

As vezes é útil ter uma maneira mais rigorosa para analisar valores float, expressões regulares podem ajudar:


```js
var filterFloat = function (value) {
  if (/^(\-|\+)?([0-9]+(\.[0-9]+)?|Infinity)$/.test(value))
    return Number(value);
  return NaN;
};

console.log(filterFloat("421")); // 421
console.log(filterFloat("-421")); // -421
console.log(filterFloat("+421")); // 421
console.log(filterFloat("Infinity")); // Infinity
console.log(filterFloat("1.61803398875")); // 1.61803398875
console.log(filterFloat("421e+0")); // NaN
console.log(filterFloat("421hop")); // NaN
console.log(filterFloat("hop1.61803398875")); // NaN
```


Observe que este código é somente um exemplo; ele não aceita números válidos, tais como 1. ou 0,5.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-parsefloat-string |

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

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

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

* `parseInt()`
* `Number.parseFloat()`
* `Number.parseInt()`
* `isNaN()`
TypeError
=========

O objeto **`TypeError`** representa um erro de quando um valor não é do tipo esperado.

Sintaxe
-------
```

new TypeError([message[, fileName[, lineNumber]]])
```

### Parâmetros

`message`

Opcional. Mensagem, descrição do erro

`fileName` 
Non-standard

Opcional. O nome do arquivo contendo o código que causou a exceção

`lineNumber` 
Non-standard

Opcional. O número da linha do código que causou a exeção

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

O `TypeError` é ativado quando um operador ou argumento passado para uma função é incompativel com o tipo esperado por esse operador ou função.

Propriedades
------------

`TypeError.prototype` (en-US)

Permite a adição de propriedades para o objeto `TypeError`.

Métodos
-------

O TypeError global não contém métodos por si só, no entanto, ele herda alguns métodos através da cadeia prototype.

`Instâncias TypeError`
----------------------

### Propriedades

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/TypeError/prototype', 'Properties')}}### Métodos

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/TypeError/prototype', 'Methods')}}Exemplos
--------

### Capturando um `TypeError`


```js
try {
  null.f();
} catch (e) {
  console.log(e instanceof TypeError); // true
  console.log(e.message); // "null has no properties"
  console.log(e.name); // "TypeError"
  console.log(e.fileName); // "Scratchpad/1"
  console.log(e.lineNumber); // 2
  console.log(e.columnNumber); // 2
  console.log(e.stack); // "@Scratchpad/2:2:3\n"
}
```

### Criando um `TypeError`


```js
try {
  throw new TypeError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof TypeError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "TypeError"
  console.log(e.fileName); // "someFile.js"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // "@Scratchpad/2:2:9\n"
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-native-error-types-used-in-this-standard-typeerror |

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

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

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

* `Error`
* `TypeError.prototype` (en-US)
NaN
===

Resumo
------

A propriedade global **`NaN`** é um valor especial que significa *Not-A-Number* (não é um número).

| Property attributes of `NaN` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Sintaxe
-------
```

NaN
```

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

`NaN` é uma propriedade do *objeto global*.

O valor inicial de `NaN` é Not-A-Number - o mesmo valor de `Number.NaN`. Nos navegadores modernos, o `NaN` é uma propriedade somente leitura e não configurável. Mesmo quando não for este o caso, evite sobrescrevê-lo.

Não é usual a utilização do `NaN`. Ele é retornado quando uma operação matemática falha (Math.sqrt(-1)) ou quando uma função tenta transformar uma string em inteiro (parseInt("blabla")).

### Testando um valor `NaN`

Os operadores de igualdade (`==` e `===`) não podem ser usados para testar um valor NaN. Ao invés disso, utilize `Number.isNaN()` ou `isNaN()`.


```js
NaN === NaN; // falso
Number.NaN === NaN; // falso
isNaN(NaN); // verdadeiro
isNaN(Number.NaN); // verdadeiro
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-value-properties-of-the-global-object-nan |

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

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

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

* `Number.NaN`
* `Number.isNaN()`
* `isNaN()`
escape()
========

A função obsoleta `escape() retorna uma nova string com` certos caracteres substituídos por sua sequência hexadecial. Use `encodeURI` ou `encodeURIComponent` em seu lugar.Sintaxe
-------
```

escape(str)
```

### Parâmetros

`str`

Uma string para ser codificada.

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

A função **`escape`** é uma propriedade do *global object*. Caracteres especiais são codificados, com a exceção de: `@*_+-./`

O formato hexadecimal de caracteres, que o valor unitário do código é **0xFF or less,** é uma sequência de escape de 2 digitos: %xx. Para caracteres com um código unitário maior, uma sequência de 4 digitos %**u**xxxx é usada.

Exemplos
--------


```js
escape("abc123"); // "abc123"
escape("äöü"); // "%E4%F6%FC"
escape("ć"); // "%u0107"

// Caracteres Especiais
escape("@\*\_+-./"); // "@\*\_+-./"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-escape-string |

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

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

Veja Também
-----------

* `encodeURI`
* `encodeURIComponent`
WeakSet
=======

O objeto **WeakSet** pertmite que você armazene objetos mantidos "fracamente" na coleção.Syntaxe
-------
```

 new WeakSet([iterable]);
```

### Parâmetros

iterable

Se umobjeto interagível é passado, todos os seus elementos serão adicionados ao novo `WeakSet`.

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

Objetos `WeakSet` são coleções de objetos. Um objeto no `WeakSet` pode ocorrer uma vez; é único na coleção do `WeakSet`.

As principais diferenças para o objeto `Set` são:

* Em contraste ao `Sets`, `WeakSets` são **coleções apenas de objetos** e não de valores arbitrários de qualquer tipo.
* O `WeakSet` é *fraco*. Referências aos objetos nas coleções são mantidas "fracamente". Se não há outra referência para um objeto mantido na `WeakSet`, eles pode ser coletados pelo gerenciamento de memória (*garbage collection*).
Propriedades
------------

`WeakSet.length`

O valor da propriedade de comprimento é 0.

`WeakSet.prototype` (en-US)

Representa o protóripo para o construtos `Set`. Permite a adição de propriedades para todos os objetos do `WeakSet`.

`Instâncias WeakSet`
--------------------

Todas as instâncias do `WeakSet` herdam do `WeakSet.prototype` (en-US).

### Propriedades

{{page('en-US/Web/JavaScript/Reference/Global\_Objects/WeakSet/prototype','Properties')}}### Métodos

{{page('en-US/Web/JavaScript/Reference/Global\_Objects/WeakSet/prototype','Methods')}}Exemplos
--------

### Usando o objeto do `WeakSet`


```js
var ws = new WeakSet();
var obj = {};
var foo = {};

ws.add(window);
ws.add(obj);

ws.has(window); // true
ws.has(foo); // false, foo não foi adicionado ao set

ws.delete(window); // remove window do set
ws.has(window); // false, window foi removido
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakset-objects |

Compatilidade de Browser
------------------------

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

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

* `Map`
* `Set`
* `WeakMap`
Infinity
========

Sumário
-------

A propriedade global **`Infinity`** é um valor numérico que representa infinito.

| Property attributes of `Infinity` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Sintaxe
-------
```

Infinity
```

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

`Infinity` é uma propriedade do *objeto global*, ou seja, é uma varíavel no escopo global.

O valor inicial de `Infinity` é `Number.POSITIVE_INFINITY`. O valor `Infinity` (positivo) é maior do que qualquer outro número. Este valor se comporta matematicamente como infinito; por exemplo, qualquer número positivo multiplicado por `Infinity` é `Infinity`, e qualquer coisa dividida por `Infinity` é 0.

Pela especificação ECMAScript 5, `Infinity` é somente leitura (implementado no JavaScript 1.8.5 / Firefox 4).

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-value-properties-of-the-global-object-infinity |

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

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

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

* `Number.NEGATIVE_INFINITY`
* `Number.POSITIVE_INFINITY`
Generator
=========

O objeto **`Generator`** é retornado por generator function e conforme iterable protocol e o iterator protocol.

Síntaxe
-------
```

function* gen() {
  yield 1;
  yield 2;
  yield 3;
}

var g = gen(); // "Generator { }"
```

Métodos
-------

`Generator.prototype.next()` (en-US)

Retorna o valor fornecido pela expressão `yield`.

`Generator.prototype.return()` (en-US)

Retorna o valor fornecido a finaliza o generator.

`Generator.prototype.throw()` (en-US)

Lança um erro no generator.

Example
-------

### An infinite iterator


```js
function\* idMaker() {
  var index = 0;
  while (true) yield index++;
}

var gen = idMaker(); // "Generator { }"

console.log(gen.next().value); // 0
console.log(gen.next().value); // 1
console.log(gen.next().value); // 2
// ...
```

Objeto legacy generator
-----------------------

Firefox (SpiderMonkey) também implementa a versão anterior do generator em JavaScript 1.7, onde o asterisco (\*) na declaração da função não era necessário (somente era necessário usar a palavra reservada `yield` no corpo da função). Contudo, legacy generators estão obsoletos. Não os use, eles serão removidos (Erro do Firefox 1083482).

### Métodos legacy generator

`Generator.prototype.next()` 
Non-standard

Retorna o valor fornecido pela expressão `yield`. Isto corresponde ao `next()` do ES6.

`Generator.prototype.close()` 
Non-standard

Fecha o generator, então quando chamar `next()` um erro `StopIteration` será lançado. Isto corresponde ao método `return()` do ES6.

`Generator.prototype.send()` 
Non-standard

Usado para enviar um valor para o generator. Este valor é retordo pela expressão `yield`, e retorna o valor fornecido pelo pelo next `yield`. `send(x)` corresponde ao `next(x)` do ES6.

`Generator.prototype.throw()` 
Non-standard

Lança um erro no generator. Isto corresponde ao método `throw() do ES6.`

### Exemplo do Legacy generator


```js
function\* fibonacci() {
  var a = yield 1;
  yield a \* 2;
}

var it = fibonacci();
console.log(it); // "Generator { }"
console.log(it.next()); // 1
console.log(it.send(10)); // 20
console.log(it.close()); // undefined
console.log(it.next()); // throws StopIteration (Como o generator está fechado)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator-objects |

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

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

Veja Também
-----------

### Legacy generators

* The legacy generator function (en-US)
* The legacy generator function expression (en-US)
* `StopIteration`
* The legacy Iterator protocol (en-US)
### ES6 generators

* Functions
* `function`
* `function expression`
* `Function`
* `function*`
* `function* expression`
* `GeneratorFunction` (en-US)
* The Iterator protocol (en-US)
Set.prototype.clear()
=====================

O método **`clear()`** remove todos os elementos de um objeto `Set`.

Sintaxe
-------
```

mySet.clear();
```

Exemplos
--------

### Usando o método `clear`


```js
var mySet = new Set();
mySet.add(1);
mySet.add("foo");

mySet.size; // 2
mySet.has("foo"); // true

mySet.clear();

mySet.size; // 0
mySet.has("bar"); // false
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.clear |

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

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

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

* `Set`
* `Set.prototype.delete()`
Set.prototype.entries()
=======================

O método **`entries()`** retorna um novo objeto Iterador (`Iterator`) que contém **um array de [valor, valor]** para cada elemento de um objeto `Set`em ordem de inserção. Os objetos `Set` não possuem `chaves (key)` como objetos do tipo `Map`. Entretanto, para manter a API similar a objetos `Map`, cada entrada (*entry*) tem o mesmo valor para sua chave (`key`) e valor (`value`), então uma matriz `array [valor, valor]` é retornado.

Sintaxe
-------
```

mySet.entries()
```

Exemplos
--------

### Usando `entries()`


```js
var mySet = new Set();
mySet.add("foobar");
mySet.add(1);
mySet.add("baz");

var setIter = mySet.entries();

console.log(setIter.next().value); // ["foobar", "foobar"]
console.log(setIter.next().value); // [1, 1]
console.log(setIter.next().value); // ["baz", "baz"]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.entries |

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

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

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

* `Set.prototype.keys()` (en-US)
* `Set.prototype.values()`
Set.prototype.has()
===================

O método **`has()`** retorna um valor booleano indicando se um elemento com o valor especificado existe em um objecto `Set` ou não.

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

Sintaxe
-------
```

mySet.has(valor);
```

### Parâmetros

`valor`

O valor para testar a existência no objeto `Set`.

### Valor de retorno

Retorna `true` se um elemento com o valor especificado existe no objeto `Set`; `false` caso contrário.

> 
> \*\*Nota:\*\*Tecnicamente falando, `has()` usa o algorítimo `sameValueZero` para determinar quando o elemento dado é encontrado.
> 
> 
> 

Exemplos
--------

### Usando o método `has`


```js
var mySet = new Set();
mySet.add("foo");

mySet.has("foo"); // retorna true
mySet.has("bar"); // retorna false

var set1 = new Set();
var obj1 = { key1: 1 };
set1.add(obj1);

set1.has(obj1); // retorna true
set1.has({ key1: 1 }); // retorna false porque obj1 e {'key': 1} fazem referência a objetos diferentes.
set1.add({ key1: 1 }); // agora set1 contém 2 registros
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.has |

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

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

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

* `Set`
* `Set.prototype.add()`
* `Set.prototype.delete()`
Set.prototype.add()
===================

O método **`add()`** acrescenta um novo elemento com o valor especificado no final de um objeto `Set`.

Sintaxe
-------
```

mySet.add(value);
```

### Parâmetros

value

Requerido. O valor de um elemento a ser adicionado ao objeto Set.

### Valor de retorno

O objeto `Set`.

Exemplos
--------

### Usando o método `add`


```js
var mySet = new Set();

mySet.add(1);
mySet.add(5).add("some text"); // pode ser encadeado

console.log(mySet);
// Set [1, 5, "some text"]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.add |

Compatilidade de Navegadores (Browser)
--------------------------------------

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

Notas específicas para Firefox
------------------------------

* Antes do Firefox 33, `Set.prototype.add retornava` `undefined` e não era possível encadear chamadas. Isto foi resolvido (Erro do Firefox 1031632). O comportamento pode ser encontrado no Chrome/v8 (issue).
Veja também
-----------

* `Set`
* `Set.prototype.delete()`
* `Set.prototype.has()`
Set.prototype.values()
======================

O método **`values()`** retorna um novo objeto `Iterator` que contem os valores para cada elemento dentro do objeto `Set` por ordem de inserção.

O método **`keys()`** é um alias desse método (por similaridade com os objetos `Map`); ele se comporta exatamente da mesma forma e retorna os **valores** dos elementos do `Set`.

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

Sintaxe
-------
```

mySet.values();
```

### Valor retornado

Um novo objeto **`Iterator`** condendo os valores de cada elemento contido no `Set`, por ordem de inserção.

Exemplos
--------

### Usando `values()`


```js
var mySet = new Set();
mySet.add("foo");
mySet.add("bar");
mySet.add("baz");

var setIter = mySet.values();

console.log(setIter.next().value); // "foo"
console.log(setIter.next().value); // "bar"
console.log(setIter.next().value); // "baz"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.values |

Browsers compatíveis
--------------------

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

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

* `Set.prototype.entries()`
Set.prototype.delete()
======================

O método **`delete()`** remove o elemento especificado de um objeto `Set`.

Sintaxe
-------
```

mySet.delete(value);
```

### Parâmetros

value

Requerido. O valor do elemento a ser removido do objeto Set.

### Return value

Retorna `true` se um elemento contido no objeto Set foi removido com sucesso; caso contrário `false`.

Exemples
--------

### Uso do método `delete`


```js
var mySet = new Set();
mySet.add("foo");

mySet.delete("bar"); // Retorna false. Nenhum elemento "bar" foi encontrado para deletar.
mySet.delete("foo"); // Retorna true. remoção bem sucedida.

mySet.has("foo"); // Retorna false. O elemento "foo" não está mais presente.
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.delete |

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

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

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

* `Set`
* `Set.prototype.clear()`
Symbol.iterator
===============

O símbolo conhecido **`Symbol.iterator`** especifíca o iterador padrão para um objeto. Usado por `for...of`.

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

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

Sempre que um objeto precisa ser iterado (como um começo de um `for..of` loop), o método `@@iterator` é chamado sem argumentos, e o **iterador** retornado é usado para obter os valores para serem iterados.

Alguns tipos built-in tem um comportamento padrão de iteração, enquanto outros tipos (assim como `Object`) não tem. O tipo built-in com um método `@@iterator` são:

* `Array.prototype[@@iterator]()`
* `TypedArray.prototype[@@iterator]()` (en-US)
* `String.prototype[@@iterator]()`
* `Map.prototype[@@iterator]()`
* `Set.prototype[@@iterator]()` (en-US)

Veja também Iteration protocols para mais informação.

| Property attributes of `Symbol.iterator` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Exemplos
--------

### Iteráveis definidos pelo usuário

Podemos fazer nosso próprio iterável dessa forma:


```js
var myIterable = {};
myIterable[Symbol.iterator] = function\* () {
  yield 1;
  yield 2;
  yield 3;
};
[...myIterable]; // [1, 2, 3]
```


Ou iteráveis podem ser definidos diretamente dentro de uma classe ou um objeto usando computed property:


```js
class Foo {
  \*[Symbol.iterator] () {
    yield 1;
    yield 2;
    yield 3;
  }
}

const someObj = {
  \*[Symbol.iterator] () {
    yield 'a';
    yield 'b';
  }
}

[...new Foo] // [ 1, 2, 3 ]
[...someObj] // [ 'a', 'b' ]
```

### Iteráveis não bem formados

Se um método `@@iterator` não retornar um objeto iterador, então é um iterável não bem formado. Usando dessa forma é resultará em uma excessão de tempo ou comportamentos com erros:


```js
var nonWellFormedIterable = {}
nonWellFormedIterable[Symbol.iterator] = () => 1
[...nonWellFormedIterable] // TypeError: [] is not a function
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.iterator |

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

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

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

* Iteration protocols
* `Array.prototype[@@iterator]()`
* `TypedArray.prototype[@@iterator]()` (en-US)
* `String.prototype[@@iterator]()`
* `Map.prototype[@@iterator]()`
* `Set.prototype[@@iterator]()` (en-US)