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

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

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

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

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

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

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

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

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

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

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

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`