Symbol.prototype.description - JavaScript

Symbol.prototype.description
============================

A propriedade leitura somente **`description`** é uma string que retorna a descrição opcional de objetos `Symbol`.

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

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

`Symbol` objetos podem ser criados com uma uma descrição opcional na qual podem ser usados para debbuging mas não para acessar o próprio símbolo. A `Symbol.prototype.description` propriedade pode ser usada para ler essa descrição. É diferente do `Symbol.prototype.toString()` pois não contém a string incluida "`Symbol()`". Veja os exemplos.

Exemplos
--------

### Usando descrição

```js
Symbol("desc").toString(); // "Symbol(desc)"
Symbol("desc").description; // "desc"
Symbol("").description; // ""
Symbol().description; // undefined

// símbolos conhecidos
Symbol.iterator.toString(); // "Symbol(Symbol.iterator)"
Symbol.iterator.description; // "Symbol.iterator"

// símbolos globais
Symbol.for("foo").toString(); // "Symbol(foo)"
Symbol.for("foo").description; // "foo"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.prototype.description |

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

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

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

* `Symbol.prototype.toString()` (en-US)
* Polyfill: https://npmjs.com/symbol.prototype.description


Symbol.split - JavaScript

Symbol.split
============

O **`Symbol.split`** é um símbolo conhecido que especifica o método que divide uma string nos índices correspondentes a uma expressão regular. Essa função é chamada pelo método `String.prototype.split()`.

Para mais informações, veja `RegExp.prototype[@@split]()` (en-US) e `String.prototype.split()`.

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

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

Exemplos
--------

### Divisão reversa personalizada

```js
class ReverseSplit {
  [Symbol.split](string) {
    const array = string.split(" ");
    return array.reverse();
  }
}

console.log("Another one bites the dust".split(new ReverseSplit()));
// resultado esperado: [ "dust", "the", "bites", "one", "Another" ]
```

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

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

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

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

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

* `Symbol.match`
* `Symbol.replace`
* `Symbol.search`
* `RegExp.prototype[@@split]()` (en-US)


Symbol.species - JavaScript

Symbol.species
==============

O símbolo **`Symbol.species`** especifica uma propriedade valor-função que a função construtora usa para criar objetos derivados.

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

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

A propriedade acessora de espécies permite que subclasses substituam o construtor padrão para objetos.

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

Exemplos
--------

### Usando espécies

Você pode querer que retorne objetos `Array` em sua class derivada de array `MyArray`. Por exemplo, quando usar métodos tais como `map()` que retorna o construtor padrão, você quer que esses métodos retornem um objeto `Array` pai, em vez do objeto `MyArray`. Esses símbolos espécies permitem que você fala isso:

```js
class MyArray extends Array {
  // Substitui espécies para a Array pai construtora
  static get [Symbol.species]() {
    return Array;
  }
}
let a = new MyArray(1, 2, 3);
let mapped = a.map((x) => x \* x);

console.log(mapped instanceof MyArray); // false
console.log(mapped instanceof Array); // true
```

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

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

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

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

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

* `Map[@@species]`
* `Set[@@species]` (en-US)


Symbol.unscopables - JavaScript

Symbol.unscopables
==================

O símbolo **`Symbol.unscopables`** é usado para específicar um valor objeto cujo os nomes de propriedade próprio e herdados são excluídos das associações do ambiente `with` o objeto associado.

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

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

O `@@unscopables` símbolo (`Symbol.unscopables`) pode ser definido em qualquer objeto para impedir que os nomes da propriedade sejam expostos como variavéis lexicais `with` ligações de ambiente. Note que se usar o Strict mode, `with` as declarações não estão disponíveis e provavelmente não haverá necessidade desse símbolo.

Configurando a propriedade para `true` em um objeto `unscopables` tornará ele não *unscopable* e portanto não irá apareer nas variavéis de escopo lexicais. Configurando uma propriedade para `false` o tornará `scopable` e portanto irá aparecer no escopo de variavéis lexicais.

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

Exemplos
--------

### Escopo com declarações

O seguinte código funciona normalmente no ES5 e anteriores. Entretanto, no ECMAScript 2015 e superiores, o método `Array.prototype.keys()` foi introduzido. Isso significa que dentro do ambiente `with` "chaves" seria agora o método e não as variavéis. Isso qunado os símbolos `unscopable`s foram introduzidos. Uma confiração built-in `unscopables` é implementada como `Array.prototype[@@unscopables]` para prevenir que alguns métodos de Array tenham escopo definido na desclaração `with`.

```js
var keys = [];

with (Array.prototype) {
  keys.push("something");
}

Object.keys(Array.prototype[Symbol.unscopables]);
// ["copyWithin", "entries", "fill", "find", "findIndex",
// "includes", "keys", "values"]
```

### Objetos não escopáveis

Você também pode configurar `unscopables` para seu próprio objeot.

```js
var obj = {
  foo: 1,
  bar: 2,
};

obj[Symbol.unscopables] = {
  foo: false,
  bar: true,
};

with (obj) {
  console.log(foo); // 1
  console.log(bar); // ReferenceError: bar is not defined
}
```

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

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

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

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

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

* `Array.prototype[@@unscopables]`
* `with` statement (not available in Strict mode)


Symbol.toPrimitive - JavaScript

Symbol.toPrimitive
==================

O **`Symbol.toPrimitive`** é um símbolo que específica uma propriedade com valor função que é chamada para converter um ojbeto para um valor primitivo correspondente.

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

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

Com a ajuda da propriedade **`Symbol.toPrimitive`** (usada como uma função valor), um objeto pode ser convertido para um valor primitivo. a função é chamada com um argumento string **`hint`**, que espcífica o tipo de preferência do resultado do valor primitivo. O argumento **`hint`** pode ser um `"number"`, `"string"`, e `"default"`.

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

Exemplos
--------

### Modificando valores primitivos convertendo para um objeto

O exemplo a seguir descreve que a propriedade **`Symbol.toPrimitive`** pode ser modificar o valor primitivo convertendo para um objeto.

```js
// Um objeto sem propriedade Symbol.toPrimitive.
var obj1 = {};
console.log(+obj1); // NaN
console.log(`${obj1}`); // "[object Object]"
console.log(obj1 + ""); // "[object Object]"

// Um objeto com propriedade Symbol.toPrimitive
var obj2 = {
  [Symbol.toPrimitive](hint) {
    if (hint == "number") {
      return 10;
    }
    if (hint == "string") {
      return "hello";
    }
    return true;
  },
};
console.log(+obj2); // 10 -- dica é "number"
console.log(`${obj2}`); // "hello" -- dica é "string"
console.log(obj2 + ""); // "true" -- dica é "default"
```

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

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

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

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

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

* `Date.prototype[@@toPrimitive]`
* `Symbol.prototype[@@toPrimitive]` (en-US)
* `Object.prototype.toString()`
* `Object.prototype.valueOf()`


Symbol.hasInstance - JavaScript

Symbol.hasInstance
==================

O symbol bem-conhecido **`Symbol.hasInstance`** é usado para determinar se um objeto construtor reconhece um objeto como de sua instância. O comportamento do operador `instanceof` pode ser customizado por este symbol.

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

Exemplos
--------

Você pode implementar o comportamento customizado do seu `instanceof` deste jeito; por exemplo:

```js
class MyArray {
  static [Symbol.hasInstance](instance) {
    return this.prototype.isPrototypeOf(instance) || Array.isArray(instance);
  }
}

console.log([] instanceof MyArray); // true
console.log(new MyArray() instanceof MyArray); // true
console.log(new Image() instanceof MyArray); // false

class MySubArray extends MyArray {}
console.log(new MySubArray() instanceof MySubArray); // true
console.log(new MySubArray() instanceof MyArray); // true
console.log(new MyArray() instanceof MySubArray); // false
```

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

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

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

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

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

* `instanceof`
* `isPrototypeOf()`


Symbol.search - JavaScript

Symbol.search
=============

O símbolo **`Symbol.search`** é um método conhecido por retornar o índice com uma string que corresponde a expressão regular. Essa função é chamada pelo método `String.prototype.search()`.

Para mais informação, veja `RegExp.prototype[@@search]()` (en-US) e `String.prototype.search()`.

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

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

Exemplos
--------

### Pesquisa de string personalizada

```js
class caseInsensitiveSearch {
  constructor(value) {
    this.value = value.toLowerCase();
  }
  [Symbol.search](string) {
    return string.toLowerCase().indexOf(this.value);
  }
}

console.log("foobar".search(new caseInsensitiveSearch("BaR")));
// resultado esperado: 3
```

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

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

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

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

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

* `Symbol.match`
* `Symbol.replace`
* `Symbol.split`
* `RegExp.prototype[@@search]()` (en-US)


Symbol.toStringTag - JavaScript

Symbol.toStringTag
==================

O símbolo **`Symbol.toStringTag`** é uma propriedade com valor string que é usada para a criação de uma descrição de string de um objeto padrão. É acessado internalmente pelo método `Object.prototype.toString()`.

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

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

Exemplos
--------

### Tags padrões

```js
Object.prototype.toString.call("foo"); // "[object String]"
Object.prototype.toString.call([1, 2]); // "[object Array]"
Object.prototype.toString.call(3); // "[object Number]"
Object.prototype.toString.call(true); // "[object Boolean]"
Object.prototype.toString.call(undefined); // "[object Undefined]"
Object.prototype.toString.call(null); // "[object Null]"
// ... e mais
```

### Símbolos built-in toStringTag

```js
Object.prototype.toString.call(new Map()); // "[object Map]"
Object.prototype.toString.call(function\* () {}); // "[object GeneratorFunction]"
Object.prototype.toString.call(Promise.resolve()); // "[object Promise]"
// ... e mais
```

### Classes personalizadas para objeto tag

Quando cria sua própria classe, o JavaScript padroniza para "Object" tag:

```js
class ValidatorClass {}

Object.prototype.toString.call(new ValidatorClass()); // "[object Object]"
```

### Tag costumizada com toStringTag

Agora, com a ajuda do `toStringTag`, você é capaz de costumizar sua própria tag:

```js
class ValidatorClass {
  get [Symbol.toStringTag]() {
    return "Validator";
  }
}

Object.prototype.toString.call(new ValidatorClass()); // "[object Validator]"
```

### toStringTag disponível em todos os objetos protótipos da DOM

Devido a uma mudança nas especificações WebIDL spec change em meados de 2020, navegadores estão adicionando uma propriedade `Symbol.toStringTag` para todos os objetos protótipos da DOM . Por exemplo, para acessar a propriedade `Symbol.toStringTag` no `HTMLButtonElement` (en-US):

```js
let test = document.createElement("button");
test.toString(); // Retorna [object HTMLButtonElement]
test[Symbol.toStringTag]; // Retona HTMLButtonElement
```

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

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

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

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

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

* `Object.prototype.toString()`


Symbol.replace - JavaScript

Symbol.replace
==============

O símbolo **`Symbol.replace`** é conhecido por especificar o método que substitui as substrings conrrespondentes de uma string. Essa função é chamada pelo método `String.prototype.replace()`.

Para mais informações, veja `RegExp.prototype[@@replace]()` (en-US) e `String.prototype.replace()`.

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

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

Exemplos
--------

### Usando Symbol.replace

```js
class CustomReplacer {
  constructor(value) {
    this.value = value;
  }
  [Symbol.replace](string) {
    return string.replace(this.value, "#!@?");
  }
}

console.log("football".replace(new CustomReplacer("foo")));
// resultado esperado: "#!@?tball"
```

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

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

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

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

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

* `Symbol.match`
* `Symbol.search`
* `Symbol.split`
* `RegExp.prototype[@@replace]()` (en-US)


Symbol.match - JavaScript

Symbol.match
============

O símbolo **`Symbol.match`** é conhecido por especificar a compatibilidade de uam expressão regular contra uma string. Essa função é chamada pelo método `String.prototype.match()`.

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

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

Essa função também é usada para identificar se um objeto tem o comportamento de uma expressão regular. Por exemplo, os métodos `String.prototype.startsWith()`, `String.prototype.endsWith()` e `String.prototype.includes()`, verificar se o primeiro agumento é uma expressão regular e irá lançar um `TypeError` se eles forém. Agora, se o símbolo `match` é configurado para `false` (ou um valor Falsy ), ele indica que o objeto não tem intensão de ser usado como um ojbeto de expressão regular

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

Exemplos
--------

### Desativando a verificação `isRegExp`

O seguinte código vai lançar um `TypeError`:

```js
"/bar/".startsWith(/bar/);

// Lança um TypeError, como /bar/ é uma expressão regular
// não Symbol.match não é modificado.
```

Entretanto, se você configurar `Symbol.match` para `false`, a verificação `isRegExp` (que usa a propriedade `match` ) que o objeto não é uma expressão regular. O método `startsWith` e `endsWith` não vão lançar um `TypeError` como consequência.

```js
var re = /foo/;
re[Symbol.match] = false;
"/foo/".startsWith(re); // true
"/baz/".endsWith(re); // false
```

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

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

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

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

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

* `Symbol.replace`
* `Symbol.search`
* `Symbol.split`
* `RegExp.prototype[@@match]()` (en-US)


Symbol.isConcatSpreadable - JavaScript

Symbol.isConcatSpreadable
=========================

O **`Symbol.isConcatSpreadable`** é um símbolo conhecido que é usado para configurar se um objeto deve ser achatado para um elemento da array quando usado o método `Array.prototype.concat()`.

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

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

O `@@isConcatSpreadable` símbolo (`Symbol.isConcatSpreadable`) pode também ser definido como uma propriedade própria ou herdada e seu valor é um booleano. Ele consegue controlar o comportamento das arrays e objetos semelhantes a array:

* For array objects, the default behavior is to spread (flatten) elements. `Symbol.isConcatSpreadable` can avoid flattening in these cases.
* For array-like objects, the default behavior is no spreading or flattening. `Symbol.isConcatSpreadable` can force flattening in these cases.

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

Exemplos
--------

### Arrays

Por padrão, o `Array.prototype.concat()` espalha (alinha) arrays no seus resultados:

```js
let alpha = ['a', 'b', 'c'],
let numeric = [1, 2, 3]

let alphaNumeric = alpha.concat(numeric)

console.log(alphaNumeric)  // Resultado: ['a', 'b', 'c', 1, 2, 3]
```

Quando configurando o `Symbol.isConcatSpreadable` para `false`, o comportamento padrão dele:

```js
let alpha = ['a', 'b', 'c'],
let numeric = [1, 2, 3]

numeric[Symbol.isConcatSpreadable] = false
let alphaNumeric = alpha.concat(numeric)

console.log(alphaNumeric)  // Resultado: ['a', 'b', 'c', [1, 2, 3] ]
```

### Objetos de array semelhantes

Para objetos de array semelhantes, o padrão não é espalhado. `Symbol.isConcatSpreadable`precisa ser configurado para `true` para poder conseguir um a array alinhada:

```js
let x = [1, 2, 3];

let fakeArray = {
  [Symbol.isConcatSpreadable]: true,
  length: 2,
  0: "hello",
  1: "world",
};

x.concat(fakeArray); // [1, 2, 3, "hello", "world"]
```

**Nota:** A propriedade `length` é usada para controlar o número de propriedade dos objetos para ser adicionado. No exemplo acima, `length:2` indica que duas propriedades tem de ser adicionado.

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

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

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

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

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

* `Array.prototype.concat()`


Number.prototype.toPrecision() - JavaScript

Number.prototype.toPrecision()
==============================

O método **`toPrecision()`** retorna uma string que representa o valor do objeto `Number` com uma precisão específica.

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

Sintaxe
-------
```

numObj.toPrecision([precisão])
```

### Parâmetros

`precisão`

Opcional. Um inteiro especificando o número de algarismos significativos.

### Retorno

Uma string representando um objeto `Number` em notação de ponto fixo ou exponencial arredondada segundo o parâmetro `precisão`. Veja a discussão sobre arredondamento feita na documentação do método `Number.prototype.toFixed()`, que também se aplica ao método `toPrecision()`.

Se o parâmetro `precisão` for omitido, este método terá o mesmo comportamento de `Number.prototype.toString()`. Se o parâmetro `precisão` for um valor não inteiro, ele será arredondado para a sua representação mais próxima em inteiro.

### Exceções

`RangeError` (en-US)

Se o valor de `precisão` não estiver compreendido entre 1 e 100 (inclusive), um `RangeError` (en-US) será lançado. É permitido às implementações suportar valores menores e maiores que esses, sendo um requisito do ECMA-262 que seja dado suporte a uma precisão de até 21 algarismos significativos.

Exemplos
--------

### Utilizando `toPrecision`

```js
var numObj = 5.123456;

console.log(numObj.toPrecision()); // logs '5.123456'
console.log(numObj.toPrecision(5)); // logs '5.1235'
console.log(numObj.toPrecision(2)); // logs '5.1'
console.log(numObj.toPrecision(1)); // logs '5'

numObj = 0.000123;

console.log(numObj.toPrecision()); // logs '0.000123'
console.log(numObj.toPrecision(5)); // logs '0.00012300'
console.log(numObj.toPrecision(2)); // logs '0.00012'
console.log(numObj.toPrecision(1)); // logs '0.0001'

// observe que a notação exponencial pode ser retornado em alguns casos
console.log((1234.5).toPrecision(2)); // logs '1.2e+3'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.toprecision |

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

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

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

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


Number.NEGATIVE_INFINITY - JavaScript

Number.NEGATIVE\_INFINITY
=========================

A propriedade **`Number.NEGATIVE_INFINITY`** representa o valor Infinito negativo.

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

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

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

O valor de `Number.NEGATIVE_INFINITY` é o mesmo que o valor negativo da propriedade do objeto global `Infinity`.

O valor se comporta um pouco diferente do que o infinito matemático:

* Qualquer valor positivo, incluindo `POSITIVE_INFINITY`, mutiplicado por `NEGATIVE_INFINITY` é `NEGATIVE_INFINITY`.
* Qualquer valor negativo, incluindo `NEGATIVE_INFINITY`, multiplicado por `NEGATIVE_INFINITY` é `POSITIVE_INFINITY`.
* Qualquer valor positivo dividido por `NEGATIVE_INFINITY` é zero negativo.
* Qualquer valor negativo dividido por `NEGATIVE_INFINITY` é zero positivo.
* Zero multiplicado por `NEGATIVE_INFINITY` é `NaN`.
* `NaN` multiplicado por `NEGATIVE_INFINITY` é `NaN`.
* `NEGATIVE_INFINITY`, dividido por qualquer valor negativo exceto `NEGATIVE_INFINITY`, é `POSITIVE_INFINITY`.
* `NEGATIVE_INFINITY`, divido por qualquer valor positivo exceto `POSITIVE_INFINITY`, é `NEGATIVE_INFINITY`.
* `NEGATIVE_INFINITY`, divido por ou `NEGATIVE_INFINITY` ou `POSITIVE_INFINITY`, é `NaN`.

Você pode usar a propriedade `Number.NEGATIVE_INFINITY` para indicar uma condição de erro que retorna um número finito em caso de sucesso. Nota que, usar `isFinite` seria mais apropriado neste caso.

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

Exemplos
--------

### Usando `NEGATIVE_INFINITY`

No seguinte exemplo, a variável `smallNumber` é atribuída um valor que é menor que o valor mínimo. Quando o `if` executa, `smallNumber` tem o valor `-Infinity`, então é colocado em `smallNumber` um valor mais manejável antes de continuar.

```js
var smallNumber = -Number.MAX\_VALUE \* 2;

if (smallNumber === Number.NEGATIVE\_INFINITY) {
  smallNumber = returnFinite();
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.negative\_infinity |

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

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

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

* `Number.POSITIVE_INFINITY`
* `Number.isFinite()`
* `Infinity`
* `isFinite()`


Number.MAX_VALUE - JavaScript

Number.MAX\_VALUE
=================

A propriedade **`Number.MAX_VALUE`** representa o maior valor numérico representável em JavaScript.

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

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

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

A propriedade `MAX_VALUE` tem o valor de aproximadamente `1.79E+308`, ou 21024. Valores maiores que `MAX_VALUE` são representados como `Infinity`.

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

Exemplos
--------

### Usando `MAX_VALUE`

O código a seguir multiplica dois valores numéricos. Se o resultado é menor ou igual a `MAX_VALUE`, a função `func1` é chamada; caso contrário, a função `func2` é chamada.

```js
if (num1 \* num2 <= Number.MAX\_VALUE) {
  func1();
} else {
  func2();
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.max\_value |

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

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

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

* `Number.MIN_VALUE`
* O objeto `Number` a qual ela pertence


Number.prototype.toFixed() - JavaScript

Number.prototype.toFixed()
==========================

O método **`toFixed()`** formata um número utilizando notação de ponto fixo.

Sintaxe
-------
```

numObj.toFixed([dígitos])
```

### Parâmetros

`dígitos`

Opcional. O número de dígitos que aparecem depois do ponto decimal; este pode ser um valor entre 0 e 20, inclusive, e algumas implementacões podem suportar uma variação de números maiores. Se este argumento for omitido, será tratado como 0.

### Retorno

Uma string representando o número usando notação em ponto fixo.

### Throws

`RangeError` (en-US)

Se `dígitos` for muito pequeno ou muito grande. Valores entre 0 e 20, inclusive, não irão causar o `RangeError` (en-US). É permitido às implementações suportar valores maiores e menores.

`TypeError`

Se este método for chamado em um objeto que não é `Number`.

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

Uma string representando `numObj` que não usa notação exponencial e tem exatamente `dígitos` dígitos depois da casa decimal. O número será arredondado se necessário, e será adicionado zeros a parte após a virgula para que este tenha o tamanho que foi especificado. Se o `numObj` for maior que `1e+21`, entao será invocado o método `Number.prototype.toString()` e será retornado uma string em notação exponencial.

Exemplos
--------

### Utilizando `toFixed`

```js
var numObj = 12345.6789;

numObj.toFixed(); // Retorna '12346': note o arredondamento, não possui nenhuma parte fracionária
numObj.toFixed(1); // Retorna '12345.7': note o arredondamento
numObj.toFixed(6); // Retorna '12345.678900': note que adicionou zeros
(1.23e20).toFixed(2); // Retorna '123000000000000000000.00'
(1.23e-10).toFixed(2); // Retorna '0.00'
(2.34).toFixed(1); // Retorna '2.3'
(2.35).toFixed(1); // Retorna '2.4'. Note que arredonda para cima neste caso.
-(2.34).toFixed(1); // Retorna -2.3 (devido à precedência do operador, literais de números negativos não retornam uma string...)
(-2.34).toFixed(1); // Retorna '-2.3' (...a menos que se utilize parênteses)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.tofixed |

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

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

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

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


Number.isInteger() - JavaScript

Number.isInteger()
==================

O método **`Number.isInteger()`** determina se o valor passado é um inteiro.

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

Sintaxe
-------
```

Number.isInteger(value)
```

### Parâmetros

`value`

O valor a testar se é um inteiro.

### Valor retornado

Um `Boolean` indicando se o valor é inteiro ou não.

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

Se o alvo for um inteiro, retorna `true`, senão retorna `false`. Se o valor é `NaN` ou infinito, retorna `false`.

Exemplos
--------

```js
Number.isInteger(0); // true
Number.isInteger(1); // true
Number.isInteger(-100000); // true

Number.isInteger(0.1); // false
Number.isInteger(Math.PI); // false

Number.isInteger(Infinity); // false
Number.isInteger(-Infinity); // false
Number.isInteger("10"); // false
Number.isInteger(true); // false
Number.isInteger(false); // false
Number.isInteger([1]); // false
```

Polyfill
--------

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

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

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

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

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

Ver tabém
---------

* O objeto `Number` a qual este método pertence.


Number.prototype.valueOf() - JavaScript

Number.prototype.valueOf()
==========================

O método **`valueOf()`** retorna o valor primitivo contido no objeto `Number`.

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

Sintaxe
-------
```

numObj.valueOf()
```

### Valor retornado

Um número representando o valor primitivo do objeto `Number`.

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

Este método normalmente é invocado internamente pelo JavaScript e não explicitamente em um código web.

Exemplos
--------

### Utilizando `valueOf`

```js
var numObj = new Number(10);
console.log(typeof numObj); // object

var num = numObj.valueOf();
console.log(num); // 10
console.log(typeof num); // number
```

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

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

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

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

See also
--------

* `Number.prototype.toSource()`


Number.NaN - JavaScript

Number.NaN
==========

A propriedade **`Number.NaN`** representa Not-A-Number (Não-Número). Equivalente a `NaN`.

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

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

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

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

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

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

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

* O objeto global `NaN`.
* O objeto `Number` ao qual ele pertence.


Number.isSafeInteger() - JavaScript

Number.isSafeInteger()
======================

O método **`Number.isSafeInteger()`** determina se o valor fornecido é seja um número seguro.

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

Um inteiro seguro é um inteiro que:

* pode ser representando exatamente como um número IEEE-754 de dupla precisão e
* pode ser representando exatamente como um número IEEE-754
 de precisão dupla e
* cuja representação IEEE-754 não pode ser o resultado do arrendodamento de qualquer outro número inteiro para se ajustar ao IEEE-754.

Exemplo, `253 - 1` é um inteiro seguro: pode ser exatamente representado, e nenhum outro numero arredondado existe para ele na represetanção IEEE-754. Em contexto, `253` *não* é um inteiro seguro: pode ser representado em IEEE-754, mas um inteiro `253 + 1` não pode ser diretamente representado em IEEE-754 mas instanciado do arrendamento de `253` sob arrendamento para o mais próximo e do arrendamento de zero a zero. Os inteiros seguros consistem em todos os inteiros de `-(253 - 1)` inclusive para `253 - 1` (sendo ± `9007199254740991` ou ± 9,007,199,254,740,991).

A manipulação de valores entre ~9 quadrilhões com precisão total requer o uso de arbitrary precision arithmetic library (biblioteca aritmética de precisão arbitrária). Veja What Every Programmer Needs to Know about Floating Point Arithmetic (o que todo programador precisa saber sobre aritmética de ponto flutuante) para mais informações sobre represetanções de número de ponto flutuante.

Para números inteiros maiores, considere o uso do tipo `BigInt`.

Sintaxe
-------
```

Number.isSafeInteger(valorTest)
```

### Parâmetros

`valorTest`

O valor a ser testado pode ser um número inteiro seguro.

### Retorno

Um `Boolean` indica se o valor fornecido é um número seguro ou não.

Exemplos
--------

```js
Number.isSafeInteger(3); // true
Number.isSafeInteger(Math.pow(2, 53)); // false
Number.isSafeInteger(Math.pow(2, 53) - 1); // true
Number.isSafeInteger(NaN); // false
Number.isSafeInteger(Infinity); // false
Number.isSafeInteger("3"); // false
Number.isSafeInteger(3.1); // false
Number.isSafeInteger(3.0); // true
```

Polyfill (caso não exista suporte)
----------------------------------

```js
Number.isSafeInteger =
  Number.isSafeInteger ||
  function (value) {
    return (
      Number.isInteger(value) && Math.abs(value) <= Number.MAX\_SAFE\_INTEGER
    );
  };
```

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

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

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

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

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

* O objeto pertence a `Number`
* `Number.MIN_SAFE_INTEGER`
* `Number.MAX_SAFE_INTEGER`
* `BigInt`


Number.prototype.toString() - JavaScript

Number.prototype.toString()
===========================

Resumo
------

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

Sintaxe
-------
```

numObj.toString([radix])
```

### Parâmetros

`radix`

Opcional. Um inteiro entre 2 e 36 especificando a base utilizada para representar os valores numéricos.

### Exceções

`RangeError` (en-US)

se `toString()` receber um valor de radix fora do intervalo entre 2 e 36, uma exceção `RangeError` (en-US) é lançada.

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

O objeto `Number` sobrescreve o método `toString()` do objeto `Object`; ele não herda de `Object.prototype.toString()`. Para objetos `Number`, o método `toString()` retorna uma representação string do objeto na base especificada.

O método `toString()` analisa seu primeiro argumento e tenta retornar uma representação string na raiz (base) especificada. Para raizes maiores que 10, as letras do alfabeto indicam valores maiores que 9. Por exemplo, para números hexadecimais (base 16), letras entre `a` e `f` são utilizadas.

Se o `radix` não for especificado, a raiz assumida como preferencial é a 10.

Se o `numObj` for negativo, o sinal é preservado. Isto acontece mesmo se a raiz for 2; a string retornada é a representação binária positiva de `numObj` precedida por um sinal `- e` **não** o complemento de dois do `numObj`.

Exemplos
--------

### Exemplo: Usando `toString`

```js
var count = 10;

console.log(count.toString()); // displays '10'
console.log((17).toString()); // displays '17'

var x = 6;

console.log(x.toString(2)); // displays '110'
console.log((254).toString(16)); // displays 'fe'

console.log((-10).toString(2)); // displays '-1010'
console.log((-0xff).toString(2)); // displays '-11111111'
```

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

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

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

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

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

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


Number.prototype.toLocaleString() - JavaScript

Number.prototype.toLocaleString()
=================================

O método **`toLocaleString()`** retorna uma string com uma representação sensível a linguagem deste número.

Os novos argumentos `locales` e `options` permitem às aplicações especificar a linguagem cujas convenções de formatações serão utilizadas e personalizar o comportamento da função. Nas implementações anteriores, que ignorava os argumentos `locales` e `options` arguments, a localização utilizada e a forma de retornar a string erão totalmente dependente da implementação.

Sintaxe
-------
```

numObj.toLocaleString([locales [, options]])
```

### Parâmetros

Dê uma olhada na seção Compatibilidade do Navegador para verificar quais navegadores suportam os argumentos `locales` e `options`, e o Exemplo: Verificando o suporte dos argumentos `locales` e `options` para detecção desta característica.

**Nota:** ECMAScript Internationalization API, implementada com o Firefox 29, incluiu o argumento `locales` ao método `Number.toLocaleString()`. Se o argumento for `undefined`, este método retorna os dígitos de localização especificados pelo SO, enquanto que as versões anteriores doFirefox retornavam os dígitos Árabe Ocidental. Esta mudança foi relatada como uma regressão que afeta a retrocompatibilidade que será corrigida em breve. (Erro do Firefox 999003)

`locales`

Opcional. Uma string com uma tag de linguagem BCP 47 ou uma matriz delas. Para a forma geral e interpretação do argumento `locales`, veja Intl page. A seguinte chave extendida Unicode é permitida:

`nu`

O sistema de numeração que será usado. Os valores permitidos são: `"arab"`, `"arabext"`, `"bali"`, `"beng"`, `"deva"`, `"fullwide"`, `"gujr"`, `"guru"`, `"hanidec"`, `"khmr"`, `"knda"`, `"laoo"`, `"latn"`, `"limb"`, `"mlym"`, `"mong"`, `"mymr"`, `"orya"`, `"tamldec"`, `"telu"`, `"thai"`, `"tibt"`.

`options`

Opcional. Um objeto com alguns ou todas as seguintes propriedades:

`localeMatcher`

O algoritmo de comparação de localização para utilizar. Os valores permitidos são `"lookup"` e `"best fit"`; o padrão é `"best fit"`. Para mais informações sobre esta opção, veja Intl page.

`style`

O estilo do formato a ser utilizado. Os valores permitidos são `"decimal"` para formato de número simples, `"currency"` para formato monetário e `"percent"` para formato percentual; o padrão é `"decimal"`.

`currency`

A moeda para usar na formatação monetária. Os valores permitidos são os códigos de moedas da ISO 4217, como `"USD"` para dólar estadunidense, `"EUR"` para euro, ou `"CNY"` para RMB chinês — veja a Lista de códigos de moedas e fundos atuais. Não há valor padrão; se o `style` for `"currency"`, a propriedade `currency` deverá ser informada.

`currencyDisplay`

Como será mostrada a moeda na formatação monetária. Os valores permitidos são `"symbol"` para usar um símbolo de moeda localizado como €, `"code"` para usar o código de moeda ISO, `"name"` para usar o nome da moeda localizado como `"dollar"`; o padrão é `"symbol"`.

`useGrouping`

Se usar separadores de agrupamento, como separadores de milhares ou milhares/cem mil/dez milhões. Os valores permitidos são `true` e `false`; o padrão é `true`.

As próximas propriedades se dividem em dois grupos: `minimumIntegerDigits`, `minimumFractionDigits`, e `maximumFractionDigits` no primeiro grupo, `minimumSignificantDigits` and `maximumSignificantDigits` em outro. Se pelo menos uma propriedade do segundo grupo for informado, então o primeiro grupo é ignorado.

`minimumIntegerDigits`

A quantidade mínima de dígitos inteiros para utilizar. É possível usar valores de 1 a 21; o padrão é 1.

`minimumFractionDigits`

A quantidade mínima de dígitos fracionados para utilizar. É possível usar valores de 0 a 20; o padrão para formatos de números simples e percentuais é 0; o padrão para formatos monetários é a menor unidade de dígitos fornecidos pela lista de códigos de moedas ISO 4217 (2 se a lista não fornecer a informação).

`maximumFractionDigits`

O número máximo de dígitos fracionados para utilizar. É possível usar valores de 0 a 20; o padrão para a formatação de número simples é o maior entre `minimumFractionDigits` e 3; o padrão para formatos monetários é o maior número de dígitos entre `minimumFractionDigits` e o fornecido pela lista de códigos de moedas ISO 4217 (2 se a lista não fornecer a informação); o padrão para a formatação percentual é o maior número entre `minimumFractionDigits` e 0.

`minimumSignificantDigits`

A quantidade mínima de dígitos significantes para usar. Os valores permitidos são de 1 a 21; o padrão é 1.

`maximumSignificantDigits`

A quantidade máxima de dígitos significantes para usar. Os valores permitidos são de 1 a 21; o padrão é `minimumSignificantDigits`.

Exemplos
--------

### Usando `toLocaleString`

No uso básico sem a especificação de uma localização, o método retornará uma string formatada com a localização e as opções padrão.

```js
var numero = 3500;

console.log(numero.toLocaleString()); // Mostra "3,500" se a localização for U.S. English
```

### Verificando o suporte dos argumentos `locales` e `options`

Os argumentos `locales` e `options` não são suportados por todos os navegadores ainda. Para verificar pelo suporte das implementações do ES5.1 e posteriores, a requisição de tags de linguagem ilegais são rejeitadas com uma exceção `RangeError` (en-US) pode ser usada da seguinte forma:

```js
function toLocaleStringSupportsLocales() {
  var numero = 0;
  try {
    numero.toLocaleString("i");
  } catch (e) {
    return e.name === "RangeError";
  }
  return false;
}
```

Antes da ES5.1, implementações que não exigiam um tratamento de erro se `toLocaleString` fosse chamada com argumentos.

Uma verificação que funciona em todos os casos, incluindo aqueles que suportam ECMA-262 antes da edição 5.1, é testar pelas especificações de característicadas da ECMA-402 que exigem suporte de opções regionais para `Number.prototype.toLocaleString` diretamente:

```js
function toLocaleStringSupportsOptions() {
  return !!(
    typeof Intl == "object" &&
    Intl &&
    typeof Intl.NumberFormat == "function"
  );
}
```

Estes testes para um objeto `Intl` global, verifica se ele não é `null` e se uma propriedade `NumberFormat` é uma função.

### Usando `locales`

Este exemplo mostra algumas variações de formatos de números localizados. A fim de obter o formato da linguagem utilizada na interface do usuário da sua aplicação, tenha certeza de especificar a língua (e possivelmente algumas línguas reservas) usando o argumento `locales`:

```js
var numero = 123456.789;

// O alemão usa vírgula como separador de decimal e ponto para milhares
console.log(numero.toLocaleString("de-DE"));
// → 123.456,789

// O árabe usa dígitos Árabes Orientais em muitos países que falam árabe
console.log(numero.toLocaleString("ar-EG"));
// → ١٢٣٤٥٦٫٧٨٩

// A Índia usa separadores de milhares/cem mil/dez milhões
console.log(numero.toLocaleString("en-IN"));
// → 1,23,456.789

// A chave de extensão nu requer um sistema de numeração, ex. decimal chinês
console.log(numero.toLocaleString("zh-Hans-CN-u-nu-hanidec"));
// → 一二三,四五六.七八九

// Quando informada uma língua sem suporte, como balinês,
// inclua uma língua reseva, neste caso indonésio
console.log(numero.toLocaleString(["ban", "id"]));
// → 123.456,789
```

### Usando `options`

Os resultados obtidos por `toLocaleString` pode ser personalizado usando o argumento `options`:

```js
var numero = 123456.789;

// informando um formato de moeda
console.log(
  numero.toLocaleString("de-DE", { style: "currency", currency: "EUR" }),
);
// → 123.456,79 €

// o yen japonês não tem uma unidade menor
console.log(
  numero.toLocaleString("ja-JP", { style: "currency", currency: "JPY" }),
);
// → ￥123,457

// limitando a três dígitos significativos
console.log(numero.toLocaleString("en-IN", { maximumSignificantDigits: 3 }));
// → 1,23,000
```

Desempenho
----------

Quando formatar uma grande quantidade de números, é melhor criar um objeto `NumberFormat` e usar a função fornecida pela propriedade `NumberFormat.format` (en-US).

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.tolocalestring |
| ECMAScript Internationalization API Specification # sup-number.prototype.tolocalestring |

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

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

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

* `Number.prototype.toString()`


Number.POSITIVE_INFINITY - JavaScript

Number.POSITIVE\_INFINITY
=========================

A propriedade **`Number.POSITIVE_INFINITY`** representa o valor positivo infinito.

Você não precisa criar um objeto `Number` para utilizar a propriedade estática (use `Number.POSITIVE_INFINITY`).

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

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

O valor de `Number.POSITIVE_INFINITY` é o mesmo valor da propriedade `Infinity` do objeto global.

Esse valor se comporta ligeiramente diferente do infinito matemático:

* Qualquer valor positivo, incluindo `POSITIVE_INFINITY`, multiplicado por `POSITIVE_INFINITY` é `POSITIVE_INFINITY`.
* Qualquer valor negativo, incluindo, `NEGATIVE_INFINITY`, multiplicado por `POSITIVE_INFINITY` é `NEGATIVE_INFINITY`.
* Qualquer número positivo dividido por `POSITIVE_INFINITY` é Zero positivo.
* Qualquer número negativo dividido por `POSITIVE_INFINITY` é Zero negativo.
* Zero multiplicado por `POSITIVE_INFINITY` é `NaN`.
* `NaN` multiplicado por `POSITIVE_INFINITY` é `NaN`.
* `POSITIVE_INFINITY`, dividido por qualquer valor negativo exceto `NEGATIVE_INFINITY`, é `NEGATIVE_INFINITY`.
* `POSITIVE_INFINITY`, dividido por qualquer valor positivo exceto `POSITIVE_INFINITY`, é `POSITIVE_INFINITY`.
* `POSITIVE_INFINITY`, dividido por `NEGATIVE_INFINITY` ou `POSITIVE_INFINITY`, é `NaN`.

Você pode usar a propriedade `Number.POSITIVE_INFINITY` para indicar uma condição de erro que retorna um número finito no caso de sucesso. Sobretudo, `isFinite` seria mais apropriado nesse caso.

Exemplos
--------

### Usando `POSITIVE_INFINITY`

No exemplo a seguir, a variável `bigNumber` recebe um valor maior que o valor máximo. Quando as declarações `if` executam, `bigNumber` tem o valor `Infinity`, então `bigNumber` recebe um valor mais gerenciável antes de continuar.

```js
var bigNumber = Number.MAX\_VALUE \* 2;

if (bigNumber == Number.POSITIVE\_INFINITY) {
  bigNumber = returnFinite();
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.positive\_infinity |

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

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

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

* `Number.NEGATIVE_INFINITY`
* `Number.isFinite()`
* `Infinity`
* `isFinite()`


Number.parseInt() - JavaScript

Number.parseInt()
=================

O método **`Number.parseInt()`** converte um argumento de *string* e retorna um inteiro da raiz ou base específica.

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

Sintaxe
-------
```

Number.parseInt(string,[ radix])
```

### Parâmetros

`string`

O valor a ser convertido. Se este argumento não for uma *string*, então ele é convertido a um usando a operação abstrata `ToString`. O espaço em branco inicial neste argumento é ignorado.

`radix`\_ Optional\_

Um inteiro entre `2` e `36` que representa a *raiz* (a base no sistema numérico matemático) de uma `string`. Tome cuidado—o padrão ***não*** é `10`!

### Valor de retorno

Um inteiro convertido de uma dada `string`.

Se a `radix` é menor que `2` ou maior que `36`, e o primeiro caracter que não é um espaço em branco não puder ser convertido para um número, `NaN` é retornado.

Polyfill
--------

```js
if (Number.parseInt === undefined) {
  Number.parseInt = window.parseInt;
}
```

Exemplos
--------

### Number.parseInt vs parseInt

Este método tem a mesma funcionalidade que o método global `parseInt()`:

```js
Number.parseInt === parseInt; // true
```

e é parte do ECMAScript 2015 (sua proposta é a modularização dos globais). Por favor veja `parseInt()` para mais detalhes e exemplos.

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

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

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

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

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

* O objeto `Number` a qual ela pertence.
* O método global `parseInt()`.


Number.MAX_SAFE_INTEGER - JavaScript

Number.MAX\_SAFE\_INTEGER
=========================

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

Para inteiros maiores, considere usar `BigInt`.

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

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

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

A constante `MAX_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`.

Seguro neste contexto se refere a habilidade de representar inteiros exatamente e corretamente compará-los. Por exemplo, `Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2` será avaliado para verdadeiro, que é matematicamente incorreto. Veja `Number.isSafeInteger()` para mais informação.

Este campo não existe em navegadores antigos. Usando ele sem checar sua existência, como `Math.max(Number.MAX_SAFE_INTEGER, 2)`, irá gerar resultados indesejados como NaN.

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

Polyfill
--------

```js
if (!Number.MAX\_SAFE\_INTEGER) {
  Number.MAX\_SAFE\_INTEGER = 9007199254740991; // Math.pow(2, 53) - 1;
}
```

Exemplos
--------

### Retorno do valor de MAX\_SAFE\_INTEGER

```js
Number.MAX\_SAFE\_INTEGER; // 9007199254740991
```

### Números maiores que o inteiro seguro

Isso retorna 2 por quê em pontos flutuantes, o valor é na verdade o final decimal "1" exceto em casos subnormais de precisão como zero.

```js
Number.MAX\_SAFE\_INTEGER \* Number.EPSILON; // 2
```

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

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

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

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

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

* `Number.MIN_SAFE_INTEGER`
* `Number.isSafeInteger()`
* `BigInt`


Number.MIN_VALUE - JavaScript

Number.MIN\_VALUE
=================

A propriedade **`Number.MIN_VALUE`** representa o menor valor positivo numérico representável em JavaScript.

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

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

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

A propriedade `MIN_VALUE` é o número mais próximo de 0, não o número mais negativo, que o JavaScript pode representar.

`MIN_VALUE` tem o valor de aproximadamente `5e-324`. Valores menores que `MIN_VALUE` ("valores de underflow") são convertidos para 0.

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

Exemplos
--------

### Usando `MIN_VALUE`

O seguinte código divide dois valores numéricos. Se o resultado é maior ou igual a `MIN_VALUE`, a função `func1` é chamada; caso contrário, a função `func2` é chamada.

```js
if (num1 / num2 >= Number.MIN\_VALUE) {
  func1();
} else {
  func2();
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.min\_value |

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

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

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

* `Number.MAX_VALUE`


Number.parseFloat() - JavaScript

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


Math.clz32() - JavaScript

Math.clz32()
============

A função Math.clz32 () retorna o número de zero bit inicial na representação binária de 32 bits de um número.

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

Sintaxe
-------
```

Math.clz32(x)
```

### Parâmetros

*x*

Um número.

### Valor de retorno

O número de zero bits à esquerda na representação binária de 32 bits do número fornecido.

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

"`clz32`" é short para`CountLeadingZeroes32`.

Se x não for um número, ele será convertido em um número primeiro e depois convertido em um número inteiro não assinado de 32 bits.

Se o número inteiro não assinado de 32 bits convertido for 0, retorne 32, porque todos os bits são 0.

Essa função é particularmente útil para sistemas que são compilados para JS, como o Emscripten.

Exemplos
--------

### Usando `Math.clz32()`

```js
Math.clz32(1); // 31
Math.clz32(1000); // 22
Math.clz32(); // 32

var stuff = [NaN, Infinity, -Infinity, 0, -0, null, undefined, "foo", {}, []];
stuff.every((n) => Math.clz32(n) == 32); // true

Math.clz32(true); // 31
Math.clz32(3.5); // 30
```

Contagem dos principais e mais além
-----------------------------------

No momento, não há Math.clon para "Count Leading Ones" (chamado "clon", não "clo", porque "clo" e "clz" são muito semelhantes, especialmente para pessoas que não falam inglês). No entanto, uma função clon pode ser criada facilmente, invertendo os bits de um número e passando o resultado para Math.clz32. Fazer isso funcionará porque o inverso de 1 é 0 e vice-versa. Assim, a inversão dos bits inverterá a quantidade medida de 0s (de Math.clz32), fazendo com que Math.clz32 conte o número de unidades em vez de contar o número de zeros.

Considere a seguinte palavra de 32 bits:

```js
var a = 32776; // 00000000000000001000000000001000 (16 zeros à esquerda)
Math.clz32(a); // 16

var b = ~32776; // 11111111111111110111111111110111 (32776 inverso, 0 zeros à esquerda)
Math.clz32(b); // 0 (isso é igual a quantos líderes existem em um)
```

Usando essa lógica, uma função clon pode ser criada da seguinte maneira:

```js
var clz = Math.clz32;
function clon(integer) {
  return clz(~integer);
}
```

Além disso, essa técnica pode ser estendida para criar funções inumeráveis "Contagem de zeros à direita" e funções de contagem de zeros, como mostrado abaixo. A função ctrz abaixo preenche todos os bits altos com o bit mais baixo preenchido e depois os anula para apagar todos os bits mais altos definidos, de modo que o clz possa ser usado.

```js
var clz = Math.clz32;
function ctrz(integer){ // contar zeros à direita
   // 1. preencha todos os bits mais altos após o primeiro
    integer |= integer << 16;
    integer |= integer << 8;
    integer |= integer << 4;
    integer |= integer << 2;
    integer |= integer << 1;
// 2. Agora, a inversão dos bits revela os bits mais baixos
    return 32 - clz(~integer) |0; // `|0`garante coerção inteira
}
function ctron(integer){ // conta os que estão à direita
     // Nenhum operador shift-fill-in-with-ones está disponível em
     // JavaScript, portanto, o código abaixo é o mais rápido
    return ctrz(~integer);
/ \* Implementação alternativa para fins demonstrativos:
        // 1. apaga todos os bits mais altos após o primeiro zero
       integer &= (integer << 16) | 0xffff;
       integer &= (integer << 8 ) | 0x00ff;
       integer &= (integer << 4 ) | 0x000f;
       integer &= (integer << 2 ) | 0x0003;
       integer &= (integer << 1 ) | 0x0001;
      // 2. Agora, reverter os bits revela os zeros mais baixos
       return 32 - clon(~integer) |0;
    \*/
}
```

Transforme essas funções auxiliares no módulo ASM.JS; então, você tem uma verdadeira obra-prima de desempenho. Situações como essas são exatamente para o que o ASM.JS foi projetado.

```js
var countTrailsMethods = (function (stdlib, foreign, heap) {
  "use asm";
  var clz = stdlib.Math.clz32;
  function ctrz(integer) {
    // count trailing zeros
    integer = integer | 0; // coerce to an integer
    // 1. preencha todos os bits mais altos após o primeiro
    // ASM js, por algum motivo, não permite ^ =, & = ou | =
    integer = integer | (integer << 16);
    integer = integer | (integer << 8);
    integer = integer | (integer << 4);
    integer = integer | (integer << 2);
    integer = integer | (integer << 1);
    // 2. Agora, a inversão dos bits revela os bits mais baixos
    return (32 - clz(~integer)) | 0;
  }
  function ctron(integer) {
    //contar os últimos
    integer = integer | 0; // coagir a um número inteiro
    return ctrz(~integer) | 0;
  }
  // infelizmente, o ASM.JS exige objetos compactos lentos:
  return { a: ctrz, b: ctron };
})(window, null, null);
var ctrz = countTrailsMethods.a;
var ctron = countTrailsMethods.b;
```

Polyfill-"Trecho de código"
---------------------------

O seguinte polyfill é o mais eficiente.

```js
if (!Math.clz32)
  Math.clz32 = (function (log, LN2) {
    return function (x) {
      // Seja n ToUint32 (x).
      // Seja p o número de zero bits iniciais em
      // a representação binária de 32 bits de n.
      // Retornar p.
      var asUint = x >>> 0;
      if (asUint === 0) {
        return 32;
      }
      return (31 - ((log(asUint) / LN2) | 0)) | 0; // the "| 0" acts like math.floor
    };
  })(Math.log, Math.LN2);
```

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

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

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

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

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

* `Math`
* `Math.imul` (en-US)


Math.atan2() - JavaScript

Math.atan2()
============

A função **`Math.atan2()`** retorna o arco tangente do coeficiente dos argumentos passado.

Sintaxe
-------
```

Math.atan2(y, x)
```

### Parâmentros

`y`

Primeiro numero.

`x`

Segundo numero.

### Retorno

O arco tagente do coegiente dos parâmetros

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

O `Math.atan2()` método retorna um valor numérico entre -π e π representando o ângulo teta entre (x, y). Assim indo no sentido anti-horario ao ângulo, medido em radianos, entre o eixo X positivo, e o ponto`(x, y)`.Nota os argumentos para essa função: primeiro o eixo Y(ordenadas) e o eixo X(absissas) como segundo parâmetro.

![A simple diagram showing the angle returned by atan2(y, x)](/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2/atan2.png)

`Math.atan2()os argumentos são passados separados x e y enquanto no Math.atan() é passado a razão entre esses argumentos.`

Porque `atan2()` é um método estático de `Math`, você sempre usará `Math.atan2()`, ao inves de um objeto Math criado (`Math` não é um construtor).

Examples
--------

### Using `Math.atan2()`

```js
Math.atan2(90, 15); // 1.4056476493802699
Math.atan2(15, 90); // 0.16514867741462683

Math.atan2(±0, -0);               // ±PI.
Math.atan2(±0, +0);               // ±0.
Math.atan2(±0, -x);               // ±PI for x > 0.
Math.atan2(±0, x);                // ±0 for x > 0.
Math.atan2(-y, ±0);               // -PI/2 for y > 0.
Math.atan2(y, ±0);                // PI/2 for y > 0.
Math.atan2(±y, -Infinity);        // ±PI for finite y > 0.
Math.atan2(±y, +Infinity);        // ±0 for finite y > 0.
Math.atan2(±Infinity, x);         // ±PI/2 for finite x.
Math.atan2(±Infinity, -Infinity); // ±3\*PI/4.
Math.atan2(±Infinity, +Infinity); // ±PI/4.
```

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

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

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

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

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

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`


Math.LN10 - JavaScript

Math.LN10
=========

A propriedade **`Math.LN10`** representa o logaritmo natural de 10, aproximadamente 2.302:

Math.LN10

=
ln
(
10
)
≈
2.302

\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2.302

| Property attributes of `Math.LN10` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

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

Como `LN10` é uma propriedade estática de `Math`, você sempre deve usa-lo como `Math.LN10`, ao invés de uma propriedade do objeto `Math` que você tenha criado (`Math` não é um construtor).

Exemplos
--------

### Usando `Math.LN10`

A seguinte função retorna o log natural de 10:

```js
function getNatLog10() {
  return Math.LN10;
}

getNatLog10(); // 2.302585092994046
```

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

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

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

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

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

* `Math.exp()`
* `Math.log()`
* `Math.log10()`


Math.LN2 - JavaScript

Math.LN2
========

A propriedade **`Math.LN2`** representa o logaritmo natural (também conhecido como logaritmo neperiano) de 2, que é aproximadamente 0.693:

Math.LN2

=
ln
(
2
)
≈
0.693

\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693

| Property attributes of `Math.LN2` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

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

Por `LN2` ser uma propriedade estática de `Math`, deve-se sempre usá-la como `Math.LN2`, e não como uma propriedade de um objeto `Math` que você criou.

Exemplos
--------

### Usando `Math.LN2`

A função a seguir retorna o logaritmo natural de 2:

```js
function getNatLog2() {
  return Math.LN2;
}

getNatLog2(); // 0.6931471805599453
```

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

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

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

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

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

* `Math.exp()`
* `Math.log()`
* `Math.log2()`


Math.E - JavaScript

Math.E
======

A propriedade **`Math.E`** representa a base dos logarítmos naturais, aproximadamente 2.718.

Math.E

=
e
≈
2.718

\mathtt{\mi{Math.E}} = e \approx 2.718

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

| Property attributes of `Math.E` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

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

Como `E` é uma propriedade estática de `Math`, sempre use-a como `Math.E`, ao invés de uma propriedade de um objeto `Math` que você criou (`Math` não é um construtor).

Exemplos
--------

### Usando `Math.E`

A seguinte função retorna o valor de *e*:

```js
function getNapier() {
  return Math.E;
}

getNapier(); // 2.718281828459045
```

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

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

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

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

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

* `Math.exp()`
* `Math.log()`
* `Math.log1p()`


Math.floor() - JavaScript

Math.floor()
============

Resumo
------

A função **`Math.floor(x)`** retorna o menor número inteiro dentre o número "x".

Sintaxe
-------
```

Math.floor(x)
```

### Parâmetros

`x`

Um número.

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

Por `floor` ser um método estático de `Math`, você sempre irá usar como `Math.floor()`,e não como método do objeto `Math que você criou`.

Exemplos
--------

### Exemplo: Usando `Math.floor`

```js
Math.floor(45.95); // 45
Math.floor(-45.95); // -46
```

### Exemplo: Ajuste Decimal

```js
// Closure
(function () {
  /\*\*
 \* Decimal adjustment of a number.
 \*
 \* @param {String} type The type of adjustment.
 \* @param {Number} value The number.
 \* @param {Integer} exp The exponent (the 10 logarithm of the adjustment base).
 \* @returns {Number} The adjusted value.
 \*/
  function decimalAdjust(type, value, exp) {
    // If the exp is undefined or zero...
    if (typeof exp === "undefined" || +exp === 0) {
      return Math[type](value);
    }
    value = +value;
    exp = +exp;
    // If the value is not a number or the exp is not an integer...
    if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
      return NaN;
    }
    // Shift
    value = value.toString().split("e");
    value = Math[type](+(value[0] + "e" + (value[1] ? +value[1] - exp : -exp)));
    // Shift back
    value = value.toString().split("e");
    return +(value[0] + "e" + (value[1] ? +value[1] + exp : exp));
  }

  // Decimal round
  if (!Math.round10) {
    Math.round10 = function (value, exp) {
      return decimalAdjust("round", value, exp);
    };
  }
  // Decimal floor
  if (!Math.floor10) {
    Math.floor10 = function (value, exp) {
      return decimalAdjust("floor", value, exp);
    };
  }
  // Decimal ceil
  if (!Math.ceil10) {
    Math.ceil10 = function (value, exp) {
      return decimalAdjust("ceil", value, exp);
    };
  }
})();

// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50
```

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

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

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

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

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

* The `Math` object it belongs to.
* `Math.abs`
* `Math.ceil()`
* `Math.round()`


Math.ceil() - JavaScript

Math.ceil()
===========

Resumo
------

`A função Math.ceil(x)` retorna o menor número inteiro maior ou igual a "x".

Sintaxe
-------
```

Math.ceil(x)
```

### Parâmetros

`x`

Um número.

### Valor de retorno

O menor inteiro maior ou igual ao número fornecido.

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

Por `ceil` ser um método estático de `Math`, você sempre usará como `Math.ceil()`, e não como um método do objeto `Math` que você criou.

Exemplos
--------

### Usando `Math.ceil()`

O exemplo a seguir mostra um exemplo de uso de `Math.ceil()`.

```js
Math.ceil(0.95); // 1
Math.ceil(4); // 4
Math.ceil(7.004); // 8
Math.ceil(-0.95); // -0
Math.ceil(-4); // -4
Math.ceil(-7.004); // -7
```

### Ajuste decimal

```js
// Closure
(function () {
  /\*\*
 \* Decimal adjustment of a number.
 \*
 \* @param {String} type The type of adjustment.
 \* @param {Number} value The number.
 \* @param {Integer} exp The exponent (the 10 logarithm of the adjustment base).
 \* @returns {Number} The adjusted value.
 \*/
  function decimalAdjust(type, value, exp) {
    // If the exp is undefined or zero...
    if (typeof exp === "undefined" || +exp === 0) {
      return Math[type](value);
    }
    value = +value;
    exp = +exp;
    // If the value is not a number or the exp is not an integer...
    if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
      return NaN;
    }
    // Shift
    value = value.toString().split("e");
    value = Math[type](+(value[0] + "e" + (value[1] ? +value[1] - exp : -exp)));
    // Shift back
    value = value.toString().split("e");
    return +(value[0] + "e" + (value[1] ? +value[1] + exp : exp));
  }

  // Decimal round
  if (!Math.round10) {
    Math.round10 = function (value, exp) {
      return decimalAdjust("round", value, exp);
    };
  }
  // Decimal floor
  if (!Math.floor10) {
    Math.floor10 = function (value, exp) {
      return decimalAdjust("floor", value, exp);
    };
  }
  // Decimal ceil
  if (!Math.ceil10) {
    Math.ceil10 = function (value, exp) {
      return decimalAdjust("ceil", value, exp);
    };
  }
})();

// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50
```

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

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

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

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

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

* O objeto `Math` pertence a.
* `Math.abs()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`
* `Math.trunc()`


Math.asinh() - JavaScript

Math.asinh()
============

A função **`Math.asinh()`** retorna o arco-seno hiperbólico de um número, isto é:

Math.asinh
(
x
)

=
arsinh
(
x
)
=
 the unique

y

such that

sinh
(
y
)
=
x

\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{o} ; y ; \text{único tal que} ; \sinh(y) = x

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

Sintaxe
-------
```

Math.asinh(x)
```

### Parâmetros

`x`

Um número.

### Valor de retorno

O arco-seno hiperbólico de um dado número.

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

Como `asinh()` é um métodos estático de `Math`, você deve sempre chamá-lo como `Math.asinh()`, ao invés de um método de um objeto `Math` que você criou (`Math` não é um construtor).

Exemplos
--------

### Usando `Math.asinh()`

```js
Math.asinh(1); // 0.881373587019543
Math.asinh(0); // 0
```

Polyfill
--------

Como uma solução simples a expressçao

\operatorname {arsinh} (x) = \ln \left(x + \sqrt{x^{2} + 1} \right)

 pode ser usada diretamente para uma emulação grosseira pela seguinte função:

```js
Math.asinh =
  Math.asinh ||
  function (x) {
    if (x === -Infinity) {
      return x;
    } else {
      return Math.log(x + Math.sqrt(x \* x + 1));
    }
  };
```

Apesar de formalmente correta, ela sofre de algumas problemas relacionadas à computação de ponto flutuante. Resultados precisos precisam de tratamento especial de positivos/negativos e argumentos pequenos/grandes como feitos por exemplo em em glibc ouGNU Scientific Library.

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

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

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

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

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

* `Math.acosh()`
* `Math.atanh()`
* `Math.cosh()`
* `Math.sinh()`
* `Math.tanh()`


Math.log1p() - JavaScript

Math.log1p()
============

A função **`Math.log1p()`** retorna o logaritmo natural (base `e`) de 1 + um número, isto é

∀
x
>
-
1
,

Math.log1p
(
x
)

=
ln
(
1
+
x
)

\forall x > -1, \mathtt{\operatorname{Math.log1p}(x)} = \ln(1 + x)

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

Sintaxe
-------
```

Math.log1p(x)
```

### Parâmetros

`x`

Um número.

### Valor de retorno

O logaritmo natural (base `e`) de **1** mais o número fornecido. Se o número for menor que **-1**, `NaN` será retornado.

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

Para valores muito pequenos de *x*, adicionando 1 pode reduzir ou eliminar precisão. Valores double floats costuman te dar em torno de 15 digitos de precisão no JavaScript. 1 + 1e-15 = 1.000000000000001, porém, 1 + 1e-16 = 1.000000000000000 e portanto, exatamente 1.0 naquele resultado, porque os números que passam de 15 digitos são arredondados.

Quando você calcula log(1 + x), você obterá um resultado muito perto de x, se x for um valor pequeno (isto é, porque eles são chamados logaritmos 'naturais'). Se você calcular Math.log(1 + 1.1111111111e-15) você obterá uma resposta perto de1.1111111111e-15. Ao invés, você vai acabar obtendo o logaritmo de 1.00000000000000111022 (o arrendondamento é feito em binário, portanto, as vezes isso pode parecer estranho), então você obterá o resultado 1.11022...e-15, com somente 3 digitos corretos. Se, ao invés, você calcular Math.log1p(1.1111111111e-15) você terá um retorno mais preciso de 1.1111111110999995e-15 com 15 digitos corretos de precisão (na verdade 16 nesse caso).

Se o valor de `x` for menor que -1, o valor retornado será sempre `NaN`.

Por conta do `log1p()` ser um metódo estático de `Math`, você sempre chamará como `Math.log1p()`, ao invés de chamar como um método de um objeto `Math` que você tenha criado (`Math` não é um construtor).

Exemplos
--------

### Usando `Math.log1p()`

```js
Math.log1p(1); // 0.6931471805599453
Math.log1p(0); // 0
Math.log1p(-1); // -Infinity
Math.log1p(-2); // NaN
```

Polyfill
--------

Isto pode ser implementado com a seguinte função:

```js
Math.log1p =
  Math.log1p ||
  function (x) {
    return Math.log(1 + x);
  };
```

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

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

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

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

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

* `Math.exp()`
* `Math.log()`
* `Math.expm1()`
* `Math.log10()`
* `Math.log2()`
* `Math.pow()`


Math.exp() - JavaScript

Math.exp()
==========

Sumário
-------

A função **`Math.exp()`** retorna `ex`, onde `x` é o argumento, e `e` é a Constante de Euler, a base dos logaritmos naturais

Síntaxe
-------

```js
Math.exp(x);
```

### Parâmetros

`x`

Um número.

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

Pelo fato de `exp` ser um método estático de `Math`, você sempre utiliza-o como `Math.exp()`, não como um método do objeto `Math` que você criou.

Exemplos
--------

### Exemplo: Usando `Math.exp`

```js
Math.exp(-1); // 0.36787944117144233
Math.exp(0); // 1
Math.exp(1); // 2.718281828459045
```

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

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

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

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

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

* O objeto `Math` ao qual ele pertence.
* `Math.E`
* `Math.log()`
* `Math.pow()`