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

Resumo
------

O método **Number.parseFloat()** converte a string recebida como argumento e a retorna como um número de ponto flutuante. Este método se comporta de maneira idêntica a da função global `parseFloat` e é parte da especificação ECMAScript 6 (seu propósito é a modularização dos objetos globais).

Sintaxe
-------
```

Number.parseFloat(string)
```

### Parâmetros

`string`

Uma string que represente o valor que se deseja converter.

### Retorno

`string`

Um número de ponto flutuante a partir da string dada. Se a string não puder ser convertida em para um número, `NaN` é retornado.

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

Este método tem a mesma funcionalidade do método global: `parseFloat()`
```

Number.parseFloat === parseFloat; // true
```


Por favor veja `parseFloat()` para mais detalhes e exemplos.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.parsefloat |

Compatibilidade dos Navegadores
-------------------------------

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

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

* O objeto `Number` ao qual o método parseFloat pertence.
* O método global `parseFloat()`.
Number.isNaN()
==============

Resumo
------

O método **`Number.isNaN()`** determina se o valor passado é `NaN`. Versão mais robusta do original global `isNaN`.

Sintaxe
-------
```

Number.isNaN(testValue)
```

### Parâmetros

`testValue`

O valor a ser testado por `NaN`.

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

Devido a ambos os operadores de igualdade, == and ===, avaliar a `false` quando está verificando se `NaN` *é* NaN, a função `Number.isNaN` se torna necessária. Esta situação é diferente de todas as outras comparações de valor possível em JavaScript.

Em comparação a função global `isNaN`, Number.isNaN não sofre do problema de forçar a conversão do parâmetro para um número. Isso significa que ele é seguro para passar valores que, normalmente, se convertem em NaN, mas na verdade não são o mesmo valor que NaN. Isto também significa que apenas os valores do número do tipo, que são também NaN, retorna `true`.

Exemplos
--------


```js
Number.isNaN(NaN); // true
Number.isNaN(Number.NaN); // true
Number.isNaN(0 / 0); // true

// everything else: false
Number.isNaN(undefined);
Number.isNaN({});

Number.isNaN(true);
Number.isNaN(null);
Number.isNaN(37);

Number.isNaN("37");
Number.isNaN("37.37");
Number.isNaN("");
Number.isNaN(" ");
Number.isNaN("NaN");
Number.isNaN("blabla"); // e.g. este teria sido true com isNaN
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.isnan |

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

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

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

* O `Number` objeto pertence a.
Number.isFinite()
=================

O método **`Number.isFinite()`** determina se o valor passado é um número finito.

Sintaxe
-------
```

Number.isFinite(valor)
```

### Parâmetros

`valor`

O valor a ser testado.

### Retorno

Um `Boolean` indicando se o valor passado é ou não um número finito.

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

Em comparação com a função global `isFinite()`, esse método não força a conversão do parâmetro para número. Isso significa que só valores do tipo número, que são também finitos, retornam `true`.

Exemplos
--------


```js
Number.isFinite(Infinity); // false
Number.isFinite(NaN); // false
Number.isFinite(-Infinity); // false

Number.isFinite(0); // true
Number.isFinite(2e64); // true

Number.isFinite("0"); // false, teria sido true com a função
// global isFinite('0')
Number.isFinite(null); // false, teria sido true com a função
// global isFinite(null)
```

Polyfill
--------


```js
Number.isFinite =
  Number.isFinite ||
  function (value) {
    return typeof value === "number" && isFinite(value);
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.isfinite |

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

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

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

* O objeto `Number` ao qual pertence.
Number.EPSILON
==============

A propriedade **`Number.EPSILON`** representa a diferença entre 1 e o menor ponto flutuante maior que 1.

Você não tem que criar um objeto `Number` para acessar esta propriedade estática (use `Number.EPSILON`).

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

| Property attributes of `Number.EPSILON` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

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

A propriedade `EPSILON` tem o valor de aproximadamente `2.2204460492503130808472633361816E-16`, ou `2-52`.

Polyfill
--------


```js
if (Number.EPSILON === undefined) {
  Number.EPSILON = Math.pow(2, -52);
}
```

Exemplos
--------

### Testando igualdade


```js
x = 0.2;
y = 0.3;
z = 0.1;
equal = Math.abs(x - y + z) < Number.EPSILON;
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.epsilon |

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

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

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

* O objeto `Number` que esta propriedade pertence.
Number.MIN\_SAFE\_INTEGER
=========================

A constante **`Number.MIN_SAFE_INTEGER`** representa o menor inteiro seguro no JavaScript (`-(253 - 1)`).

Para representar inteiros menores do que isso, considere usar `BigInt`.

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

| Property attributes of `Number.MIN_SAFE_INTEGER` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

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

A constante `MIN_SAFE_INTEGER` tem o valor de `-9007199254740991` (-9,007,199,254,740,991 ou -9 quadrilhões). A razão por trás deste número é que o JavaScript usa o formato de número de ponto-flutuante de precisão-dupla como especificado na IEEE 754 e pode seguramente representar número entre `-(253 - 1)` e `253 - 1`. Veja `Number.isSafeInteger()` para mais informações.

Por `MIN_SAFE_INTEGER` ser uma propriedade estática de `Number`, você sempre deve usar como `Number.MIN_SAFE_INTEGER`, ao invés de uma propriedade do objeto `Number` que você criou.

Exemplos
--------

### Usando MIN\_SAFE\_INTEGER


```js
Number.MIN\_SAFE\_INTEGER; // -9007199254740991
-(Math.pow(2, 53) - 1); // -9007199254740991
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.min\_safe\_integer |

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

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

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

* `Number.MAX_SAFE_INTEGER`
* `Number.isSafeInteger()`
* `BigInt`
WeakMap.prototype.set()
=======================

O método **`set()`** adiciona um novo elemento com a `chave` e o `valor` especificados em um objeto `WeakMap`.

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

Sintaxe
-------
```

wm.set(chave, valor);
```

### Parâmetros

chave

Obrigatório. A chave do elemento a ser adicionado no objeto `WeakMap`.

valor

Obrigatório. O valor do elemento a ser adicionado no objeto `WeakMap`.

### Valor de retorno

O objeto `WeakMap`.

Exemplos
--------

### Utilizando o método `set`


```js
var wm = new WeakMap();
var obj = {};

// Adicionar novos elementos ao WeakMap
wm.set(obj, "foo").set(window, "bar"); // encadeável

// Atualizar um elemento no WeakMap
wm.set(obj, "baz");
```

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

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

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

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

Notas específicas ao Firefox
----------------------------

* Antes do Firefox 33, `WeakMap.prototype.set` retornava `undefined` e, portanto, não era encadeável. Isso foi resolvido (Erro do Firefox 1031632). O comportamento também podia ser encontrado no Chrome/v8 (issue).
Ver também
----------

* `WeakMap`
* `WeakMap.prototype.get()`
* `WeakMap.prototype.has()`
WeakMap.prototype.delete()
==========================

O método **`delete()`** remover o elemento especificado ou setado a partir de um objeto instanciado do `WeakMap`.

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

Sintaxe
-------
```

wm.delete(key);
```

### Parâmetros

chave(key)

Requerido. A chave(`key`) do elemento a ser removido do objeto instanciado do `WeakMap`.

### Valores retornados

`true` se o emento do objeto do `WeakMap` tenha sido removido com sucesso. `false` se a chave(`key`) não for encontrada no `WeakMap` ou se a chave(`key`) não for um objeto.

Exemplos
--------

### Usando o método `delete`


```js
var wm = new WeakMap();
wm.set(window, "foo");

console.log(wm.delete(window)); // Retorna true. Removido com sucesso.

wm.has(window); // Retorna false. O objeto window não é mais pertecente ao WeakMap.
```

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

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

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

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

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

* `WeakMap`
WeakMap.prototype.has()
=======================

O método **`has()`** retorna um booleano indicando se um elemento com a chave especificada existe no objeto `WeakMap` ou não.

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

Sintaxe
-------
```

wm.has(chave);
```

### Parameters

chave

Obrigatório. A chave do elemento cuja presença deve ser verificada no objeto `WeakMap`.

### Valor de retorno

Boolean

Retorna `true` se um elemento com a chave especificada existir no objeto `WeakMap`. Caso contrário, retorna `false`.

Exemplos
--------

### Utilizando o método `has`


```js
var wm = new WeakMap();
wm.set(window, "foo");

wm.has(window); // retorna true
wm.has("baz"); // retorna false
```

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

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

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

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

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

* `WeakMap`
* `WeakMap.prototype.set()`
* `WeakMap.prototype.get()`
WeakMap.prototype.get()
=======================

O método **`get()`** retorna um elemento especificado de um objeto `WeakMap`.

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

Sintaxe
-------
```

wm.get(chave);
```

### Parâmetros

chave

Obrigatório. A chave do elemento a ser retornado pelo objeto `WeakMap`.

### Valor de retorno

O elemento associado à chave especificada no objeto `WeakMap`. Se a chave não for encontrada, retorna-se `undefined`.

Exemplos
--------

### Utilizando o método `get`


```js
var wm = new WeakMap();
wm.set(window, "foo");

wm.get(window); // Retorna "foo".
wm.get("baz"); // Retorna undefined.
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.get |

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

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

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

* `WeakMap`
* `WeakMap.set()`
* `WeakMap.has()`
Atomics.add()
=============

O método estátitico **`Atomics.add()`** adiciona um dado valor em uma determinada posição no array e retorna o valor antigo daquela posição. Esta operação atômica garante que nenhuma outra escrita ocorra até que o valor modificado seja escrito de volta.

Sintaxe
-------
```

Atomics.add(typedArray, index, value)
```

### Parâmetros

`typedArray`

Um array tipado de inteiros compartilhado. Pode ser `Int8Array` (en-US), `Uint8Array` (en-US), `Int16Array`, `Uint16Array` (en-US), `Int32Array` (en-US), ou `Uint32Array` (en-US).

`index`

A posição no `typedArray` onde o `value` será adicionado.

`value`

Número que será adicionado.

### Valor de retorno

O valor antigo na determinada posição (`typedArray[index]`).

### Exceções

* Lança uma exceção `TypeError`, se o `typedArray` não for um dos tipos de inteiro permitidos.
* Lança uma exceção `TypeError`, se o `typedArray` não for tipo array tipado compartilhado.
* Lança uma exceção `RangeError` (en-US), se o `index` estiver fora dos limites no `typedArray`.
Exemplos
--------


```js
var sab = new SharedArrayBuffer(1024);
var ta = new Uint8Array(sab);

Atomics.add(ta, 0, 12); // retorna 0, o valor antigo
Atomics.load(ta, 0); // 12
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.add |

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

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

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

* `Atomics`
* `Atomics.sub()` (en-US)
Error.prototype.name
====================

A propriedade **`name`** representa o nome do tipo do erro. O valor inicial é "Error".

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

Por padrão, instâncias `Error` recebem o nome "Error". A propriedade `name`, em adição na propriedade `message`, é usado pelo método `Error.prototype.toString()` para criar a string de representação do erro.

Exemplos
--------

### Disparando um erro personalizado


```js
const e = new Error("Malformed input"); // e.name é 'Error'

e.name = "ParseError";
throw e;
// e.toString() vai retornar 'ParseError: Malformed input'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-error.prototype.name |

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

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

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

* `Error.prototype.message`
* `Error.prototype.toString()`
Error.prototype.cause
=====================

A propriedade **`cause`** indica a causa original específica de um erro.

É usado quando captura e relança um erro com uma mensagem mais específica ou útil para ter acesso ao erro original.

Valor
-----

Este é o valor que foi passado para o construtor `Error()` (en-US) no argumento `options.cause`.

O valor pode ser de qualquer tipo. Você não deve criar suposições que o erro que você apanhou tem um `Error` como sua `cause`, e da mesma forma você não pode ter certeza que a variável vinculada na declaração `catch` e um `Error` qualquer. O exemplo abaixo "Forncenendo dados estruturados é a causa do erro" mostra uma casa onde um não erro é deliberadamente fornecido como causa

Exemplos
--------

### Relançando um erro com a causa

 Isso é útil algumas vezes para capturar um erro e relançá-lo com uma nova mensagem.
 E nesse caso você deve passar o erro original no construtor para o novo `Error` aparecer.


```js
try {
  connectToDatabase();
} catch (err) {
  throw new Error("Falha na comunicação com o banco de dados.", { cause: err });
}
```


Para exemplos mais detalhados veja Erro > Diferenciar entre erros semelhantes.

### Fornecendo dados estruturados como a causa de erro

Mensagens de erro escritas para o humano consumir pode ser inapropriado para a análise de máquina, já que estão sujetos a mudanças de reformulação ou pontuação ele pode parar qualquer análise de escrita existente para consumi-los. Então quando um erro é disparado de uma função, é uma alternativa para a leitura humana da mensagem de erro, você pode em vez disso fornecer a causa com dados estruturados, para análise de máquina.


```js
function makeRSA(p, q) {
  if (!Number.isInteger(p) || !Number.isInteger(q)) {
    throw new Error("RSA key generation requires integer inputs.", {
      cause: { code: "NonInteger", value: [p, q] },
    });
  }
  if (!areCoprime(p, q)) {
    throw new Error("RSA key generation requires two co-prime integers.", {
      cause: { code: "NonCoprime", values: [p, q] },
    });
  }
  // rsa algorithm…
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-installerrorcause |

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

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

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

* `Error.prototype.message`
* `Error.prototype.toString()`
Error.prototype.toString()
==========================

O método **`toString()`** retorna uma string representando o objeto `Error`.

Sintaxe
-------
```

e.toString()
```

### Valor de retorno

A string representando o objeto `Error` especificado.

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

O objeto `Error` sobrescreve o método `Object.prototype.toString()` herdado por todos os objetos. Sua semântica é a seguinte (assumindo que `Object` e `String` tem seus valores originais):


```js
Error.prototype.toString = function () {
  "use strict";

  var obj = Object(this);
  if (obj !== this) {
    throw new TypeError();
  }

  var name = this.name;
  name = name === undefined ? "Error" : String(name);

  var msg = this.message;
  msg = msg === undefined ? "" : String(msg);

  if (name === "") {
    return msg;
  }
  if (msg === "") {
    return name;
  }

  return name + ": " + msg;
};
```

Exemplos
--------

### Usando toString()


```js
var e = new Error("fatal error");
console.log(e.toString()); // 'Error: fatal error'

e.name = undefined;
console.log(e.toString()); // 'Error: fatal error'

e.name = "";
console.log(e.toString()); // 'fatal error'

e.message = undefined;
console.log(e.toString()); // ''

e.name = "hello";
console.log(e.toString()); // 'hello'
```

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

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

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

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

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

* `Error.prototype.toSource()`
Error.prototype.message
=======================

A propriedade **`message`** é a descrição legível para humanos de um erro.

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

Esta propriedade contém uma breve descrição do erro se ele estiver disponível ou foi definido. A propriedade `message` combinada com a propriedade `name` é usada pelo metodo `Error.prototype.toString()` para criar a string de representação do erro.

Por padrão, a propriedade `message` é uma string vazia, mas esse comportamento pode ser substituído por uma instância especificando uma mensagem como o primeiro argumento para o construtor `Error` (en-US).

Exemplos
--------

### Disparando um erro personalizado


```js
const e = new Error("Não foi possível analisar a entrada");
// e.message é 'Não foi possível analisar a entrada'
throw e;
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-error.prototype.message |

Compatibilidade de Browser
--------------------------

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

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

* `Error.prototype.name`
* `Error.prototype.toString()`
Math.trunc()
============

O método **`Math.trunc()`** retorna a parte inteira de um número, descartando suas casas decimais.

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

Sintaxe
-------
```

Math.trunc(x)
```

### Parâmetros

`x`

Um número.

### Valor de retorno

A parte inteira de um dado número.

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

Diferente dos demais métodos em Math: `Math.floor()`, `Math.ceil()` e `Math.round()`, o retorno esperado da função `Math.trunc()` é simples e direto, ela apenas trunca o número passado a ela como parâmetro, removendo todas as casas decimais dele, não importando se o número é positivo ou negativo.

Portanto, se o argumento passado for um número positivo, `Math.trunc()` será equivalente a `Math.floor()`, caso contrário `Math.trunc()` será equivalente a `Math.ceil()`.

O argumento passado a esse método será convertido a um tipo numérico implicitamente.

Já que `trunc()` é um método estático em `Math`, sempre utilize `Math.trunc()`, ao invés de um método existente no objeto que você criou (`Math` não é um construtor).

Exemplos
--------

### Usando `Math.trunc()`


```js
Math.trunc(13.37); // 13
Math.trunc(42.84); // 42
Math.trunc(0.123); // 0
Math.trunc(-0.123); // -0
Math.trunc("-1.123"); // -1
Math.trunc(NaN); // NaN
Math.trunc("foo"); // NaN
Math.trunc(); // NaN
```

Polyfill
--------

(um*Polyfill* é um pedaço de código que o desenvolvedor pode colocar na sua página para garantir compatilibilidade do método. No exemplo abaixo, caso o navegador não tiver o método `trunc` na classe `Math`, ele será criado);


```js
Math.trunc =
  Math.trunc ||
  function (x) {
    return x < 0 ? Math.ceil(x) : Math.floor(x);
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.trunc |

Navegadores compatíveis
-----------------------

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

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

* `Math.abs()`
* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()` 
Experimental
Math.sign()
===========

A função **`Math.sign()`** retorna o sinal de um número, indicando se o número é positivo, negativo ou zero.

Sintaxe
-------
```

Math.sign(x)
```

### Parâmetros

`x`

Se o parametro passado ao for numerico, a função irá converter o parametro em Um número.

### Valor retornado

Um número representando o sinal do argumento fornecido.

Se o argumento é um número positivo, o retorno será 1;

Se o numero passado for negativo, o retorno será -1

Se o argumento for um zero positivo , o retorno será +0

Se o argumento for 0 negativo , o retorno será -0

. Qualquer outro valor que não seja numérico (string transformada em numero por ex.), o retorno será `NaN`

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

Pela razão de `sign()` ser um método estático de `Math`, você sempre deve usá-lo como `Math.sign()`, e não como um método do objeto `Math` que você criou (`Math` não é um construtor).

Esta função possui 5 tipos de valores retornados, `1`, `-1`, `0`, `-0`, `NaN`, que representam "número positivo", "número negativo", "zero positivo", "zero negativo" e `NaN`, respectivamente.

O argumento passado para esta função será implicitamente convertido para o tipo `numérico`.

Exemplos
--------

### Usando `Math.sign()`


```js
Math.sign(3); // 1
Math.sign(-3); // -1
Math.sign("-3"); // -1
Math.sign(0); // 0
Math.sign(-0); // -0
Math.sign(NaN); // NaN
Math.sign("foo"); // NaN
Math.sign(); // NaN
```

Polyfill
--------


```js
if (!Math.sign) {
  Math.sign = function (x) {
    // Se x é NaN, o resultado é NaN.
    // Se x é -0, o resultado é -0.
    // Se x é +0, o resultado é +0.
    // Se x é negativo e não -0, o resultado é -1.
    // Se x é positivo e não +0, o resultado é +1.
    return (x > 0) - (x < 0) || +x;
    // Uma representação mais estética é mostrada abaixo
    //
    // ( (x > 0) ? 1 : 0 ) // se x é positivo então mais um
    // + // senão (porque não poder ser - e +)
    // ( (x < 0) ? -1 : 0 ) // se x é negativo então menos um
    // || // se x é 0, -0, NaN, ou não é um número,
    // +x // Então o resultado será x, (ou) se x não é
    // // um número, então converte x para número
  };
}
```


No polyfill acima, nenhuma coerção de tipo extra é necessária para tornar numéricos as expressões `(x > 0) ou (x < 0)` , porque subtraindo-as um do outro força uma conversão de tipo de booleano para numérico.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sign |

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

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

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

* `Math.abs()`
* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.trunc()`