recursal/MDN huggingface dataset:
Array.prototype[@@iterator]()
=============================

El valor inicial de la propiedad **`@@iterator`** es el mismo objeto de función que el valor inicial de la propiedad `values()`.

Sintaxis
--------
```

arr[Symbol.iterator]()
```

### Valor de retorno

El valor inicial dado por el **iterador** `values()`. Por defecto, usar `arr[Symbol.iterator]` devolverá la función `values()`.

Ejemplos
--------

### Iteración usando el bucle `for...of`


```js
var arr = ["w", "y", "k", "o", "p"];
var eArr = arr[Symbol.iterator]();
// nuestro navegador debe ser compatible con el bucle for..of
// y variables let-scoped en bucles for
for (let letter of eArr) {
  console.log(letter);
}
```

### Iteración alternativa


```js
var arr = ["w", "y", "k", "o", "p"];
var eArr = arr[Symbol.iterator]();
console.log(eArr.next().value); // w
console.log(eArr.next().value); // y
console.log(eArr.next().value); // k
console.log(eArr.next().value); // o
console.log(eArr.next().value); // p
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype-@@iterator |

Compatibilidad con navegadores
------------------------------

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

Ver también
-----------

* `Array.prototype.keys()`
* `Array.prototype.entries()`
* `Array.prototype.forEach()`
* `Array.prototype.every()`
* `Array.prototype.some()`
* `Array.prototype.values()`
Array.prototype.values()
========================

El método **`values()`** devuelve un nuevo objeto **`Array Iterator`** que contiene los valores para cada índice del array.


```js
var a = ["w", "y", "k", "o", "p"];
var iterator = a.values();

console.log(iterator.next().value); // w
console.log(iterator.next().value); // y
console.log(iterator.next().value); // k
console.log(iterator.next().value); // o
console.log(iterator.next().value); // p
```

Sintaxis
--------
```

arr.values()
```

### Valor devuelto

Un nuevo objeto `Array` iterator.

Ejemplos
--------

### Iteración usando un bucle `for...of`


```js
var arr = ["w", "y", "k", "o", "p"];
var iterador = arr.values();

for (let letra of iterador) {
  console.log(letra);
}
```

Especificaciones
----------------

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

Compatibilidad con navegadores
------------------------------

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

Vea también
-----------

* `Array.prototype.keys()`
* `Array.prototype.entries()`
* `Array.prototype.forEach()`
* `Array.prototype.every()`
* `Array.prototype.some()`
Array.prototype.shift()
=======================

El método **`shift()`** elimina el **primer** elemento del array y lo retorna. Este método modifica la longitud del array.

Sintaxis
--------
```

arr.shift()
```

Descripción
-----------

El método `shift` elimina el elemento en el índice cero y desplaza los valores consecutivos hacia abajo, devolviendo el valor eliminado. Si la propiedad `length` es 0, devuelve `undefined`.

`shift` es genérico; este método puede utilizarse con call o apply a objetos simliares a arrays. Los objetos que no tengan una propiedad `length` que refleje el último elemento de una serie consecutiva de propiedades numéricas con índice base cero pueden no comportarse de manera significativa.

Ejemplos
--------

### Eliminando un elemento de un array

El siguiente código muestra el contenido del array `miPescado` antes y después de eliminar el primer elemento. También muestra el elemento eliminado:


```js
var miPescado = ["ángel", "payaso", "mandarín", "cirujano"];

console.log("miPescado antes: " + miPescado);
// "miPescado antes: ángel,payaso,mandarín,cirujano"

var eliminado = miPescado.shift();

console.log("miPescado después: " + miPescado);
// "miPescado after: payaso,mandarín,cirujano"

console.log("Elemento eliminado: " + eliminado);
// "Elemento eliminado: ángel"
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.shift |

Compatibilidad con navegadores
------------------------------

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

Ver también
-----------

* `Array.prototype.push()`
* `Array.prototype.pop()`
* `Array.prototype.unshift()`
Array.prototype.reverse()
=========================

El método **`reverse()`** invierte el orden de los elementos de un array *in place*. El primer elemento pasa a ser el último y el último pasa a ser el primero.

Pruébalo
--------

Sintaxis
--------
```

reverse()
```

### Valor devuelto

El array invertido.

Descripción
-----------

El método `reverse` cruza los elementos del objeto matriz invocados en su lugar, mutando la matriz, y retornando una referencia a la misma.

Ejemplos
--------

### Colocar al revés los elementos de un array

 El siguiente ejemplo crea un array `a` que contiene tres elementos y luego lo invierte.
 La llamada a `reverse()` devuelve una referencia al array `a` invertido.


```js
const a = [1, 2, 3];

console.log(a); // [1, 2, 3]

a.reverse();

console.log(a); // [3, 2, 1]
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.reverse |

Compatibilidad con navegadores
------------------------------

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

Ver también
-----------

* `Array.prototype.join()`
* `Array.prototype.sort()`
* `TypedArray.prototype.reverse()` (en-US)
Array.prototype.unshift()
=========================

El método **`unshift()`** agrega uno o más elementos al inicio del array, y devuelve la nueva longitud del array.

Pruébalo
--------

Sintaxis
--------
```

arr.unshift(elemento1[, ...[, elementoN]])
```

### Parámetros

`elementoN`

Elementos a agregar al inicio del array.

### Devuelve

La nueva propiedad `length` del objeto sobre el cual el método fue llamado.

Descripción
-----------

El método `unshift` inserta los valores proporcionados al inicio de un objeto del tipo array.

`unshift` es intencionalmente genérico; este método puede ser called o applied a objetos similares a arrays. Objetos que no contengan una propiedad `length` reflejando una serie de propiedades numéricas consecutivas, comenzada a partir del cero, pueden no comportarse de una manera comprensible.

Ejemplos
--------


```js
var arr = [1, 2];

arr.unshift(0); // resultado de la llamada es 3, la nueva longitud del array
// arr es [0, 1, 2]

arr.unshift(-2, -1); // = 5
// arr es [-2, -1, 0, 1, 2]

arr.unshift([-3]);
// arr es [[-3], -2, -1, 0, 1, 2]
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.unshift |

Compatibilidad con navegadores
------------------------------

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

Ver también
-----------

* `Array.prototype.push()`
* `Array.prototype.pop()`
* `Array.prototype.shift()`
* `Array.prototype.concat()`
get Array[@@species]
====================

La propiedad de acceso **`Array[@@species]`** devuelve el constructor de `Array`.

Sintaxis
--------
```

Array[Symbol.species]
```

### Valor de retorno

El constructor `Array`.

Descripción
-----------

La propiedad de acceso `species` devuelve el constructor predeterminado para objetos `Array`. Los constructores de subclase pueden anularlo para cambiar la asignación del constructor.

Ejemplos
--------

La propiedad `species` devuelve la función de constructor predeterminada, que es el constructor `Array` para objetos `Array`:


```js
Array[Symbol.species]; // function Array()
```


In a derived collection object (e.g. your custom array `MyArray`), the `MyArray` species is the `MyArray` constructor. However, you might want to overwrite this, in order to return parent `Array` objects in your derived class methods:


```js
class MyArray extends Array {
  // Overwrite MyArray species to the parent Array constructor
  static get [Symbol.species]() {
    return Array;
  }
}
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-array-@@species |

Compatibilidad con navegadores
------------------------------

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

Ver también
-----------

* `Array`
* `Symbol.species`
Array.prototype.pop()
=====================

El método **`pop()`** elimina el **último** elemento de un array y lo devuelve. Este método cambia la longitud del array.

Pruébalo
--------

Sintaxis
--------
```

arr.pop()
```

### Valor devuelto

El elemento que ha sido eliminado del array; `undefined` si el array está vacío.

Descripción
-----------

El método `pop` elimina el último elemento de un array y devuelve su valor al método que lo llamó.

`pop` es intencionadamente genérico; este método puede ser called o applied en objectos similares a un array. En objetos que no contengan una propiedad `length`, que refleje su forma en una serie de propiedades numéricas consecutivas en base cero, puede no comportarse de manera significativa.

Si se llama a `pop()` en un array vacío, devuelve `undefined`.

Ejemplos
--------

### Eliminando el último elemento de un array

El siguiente código crea el array `myFish`, que contiene cuatro elementos, a continuación, elimina su último elemento.


```js
var myFish = ["angel", "clown", "mandarin", "sturgeon"];

var popped = myFish.pop();

console.log(myFish); // ['angel', 'clown', 'mandarin' ]

console.log(popped); // 'sturgeon'
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.pop |

Compatibilidad con navegadores
------------------------------

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

Vea también
-----------

* `Array.prototype.push()`
* `Array.prototype.shift()`
* `Array.prototype.unshift()`
* `Array.prototype.concat()`
* `Array.prototype.splice()`
Number.NEGATIVE\_INFINITY
=========================

Resumen
-------

La propiedad **`Number.NEGATIVE_INFINITY`** representa el valor del infinito negativo.

No se tiene que crear un objeto `Number` para acceder a esta propiedad estática (use `Number.NEGATIVE_INFINITY`).

| Atributos de la propiedad `Number.NEGATIVE_INFINITY` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | No |

Descripción
-----------

El valor `Number.NEGATIVE_INFINITY` es el mismo que el valor negativo de la propiedad del objeto global `Infinity`**`.`**

Este valor tiene un comportamiento ligeramente diferente que el del infinito matematico:

* Cualquier valor positivo, incluyendo `POSITIVE_INFINITY`, multiplicado por `NEGATIVE_INFINITY` da como resultado `NEGATIVE_INFINITY`.
* Cualquier valor negativo, incluyendo `NEGATIVE_INFINITY`, multiplicado por `NEGATIVE_INFINITY` da como resultado `POSITIVE_INFINITY`.
* Cero multiplicado por `NEGATIVE_INFINITY` da como resultado `NaN`.
* NaN multiplicado por `NEGATIVE_INFINITY` da como resultado `NaN`.
* `NEGATIVE_INFINITY`, divido por cualquier valor negativo excepto `NEGATIVE_INFINITY`, da como resultado `POSITIVE_INFINITY`.
* `NEGATIVE_INFINITY`, divido por cualquier valor positivo excepto `POSITIVE_INFINITY`, da como resultado `NEGATIVE_INFINITY`.
* `NEGATIVE_INFINITY`, divido por `NEGATIVE_INFINITY` o por `POSITIVE_INFINITY`, da como resultado `NaN`.
* Cualquier numero divido por `NEGATIVE_INFINITY` da como resultado cero.

Muchos métodos JavaScript (tales como el constructor del objeto `Number`, `parseFloat`, y `parseInt`) retornan `NaN` si el valor especifico en el párametro es significativamente menor a `Number.MIN_VALUE`.

Podrías utilizar la propiedad `Number.NEGATIVE_INFINITY` para indicar una condición de error que retorne un numero finito en caso de que esto suceda. Note, sin embargo, que `isFinite` seria mas apropiado en estos casos.

Example
-------

En el siguiente ejemplo, a la variable `smallNumber` se le asigna un valor mucho mas pequeño al valor minimo. Cuando la sentencia `if` es ejecutada, `smallNumber` tiene el valor "`-Infinity`", por lo cual a `smallNumber` le es asignado un valor finito mas manejable antes de continuar.


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

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

Especificaciones
----------------

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

Compatibilidad con navegadores
------------------------------

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

Ver también
-----------

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

El método **`Number.isSafeInteger()`** determina si el valor provisto es un número que es un entero seguro.

Pruébalo
--------

Un entero seguro es un entero que

* puede ser exactamente representado como un número IEEE-754 de doble presición, y
* su representación IEEE-754 no puede ser el resultado de redondear cualquier otro entero para adaptarse a la representación de IEEE-754.

Por ejemplo, `253 - 1` es un entero seguro: puede ser exactamente representado y ningún otro entero puede ser redondeado a él bajo cualquier modo de redondeo de IEEE-754. En contraste, `253` *no* es un entero seguro, puede ser exactamente representado en IEEE-754, pero el entero `253 + 1` no puede ser directamente representado en IEEE-754 pero en su lugar, redondea a `253` bajo los modos de redondeo *redondeo-al-más-cercano* y *redondeo-a-cero*. Los enteros seguros consisten en todos los enteros desde `-(253 - 1)` inclusivo, hasta `253 - 1` inclusivo (± `9007199254740991` o ± 9,007,199,254,740,991).

Manejar valores más grandes o más pequeños que ~9 cuatrillones con presición completa requiere usar una biblioteca de artimética de presición arbitraria. Ver Lo que todo programador necesita saber sobre aritmética de punto flotante para más información sobre representaciones de punto flotante de los números.

Sintaxis
--------
```

Number.isSafeInteger(valorDePrueba)
```

### Parámetros

`valorDePrueba`

El valor a probar si es un entero seguro.

### Valor de retorno

Un `Boolean` que indica si el valor dado es un número que es entero seguro.

Ejemplos
--------


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


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

Especificaciones
----------------

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

Compatibilidad con navegadores
------------------------------

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

Ver también
-----------

* El objeto `Number` al que pertenece.
* `Number.MIN_SAFE_INTEGER` (en-US)
* `Number.MAX_SAFE_INTEGER`
Number.MAX\_SAFE\_INTEGER
=========================

La constante **`Number.MAX_SAFE_INTEGER`** es el número mas grande 'seguro' en JavaScript (`2^53 - 1`).

Pruébalo
--------

La fuente de este ejemplo interactivo está almacenada en GitHub. Si quieres contribuir al proyecto de ejmplos interactivos, por favor clona https://github.com/mdn/interactive-examples y envíanos un 'pull request'.

| Atributos de la propiedad `Number.MAX_SAFE_INTEGER` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | No |

Descripción
-----------

La constante `MAX_SAFE_INTEGER` tiene un valor de `9007199254740991` (9,007,199,254,740,991 o ~9 mil billones). El razonamiento detrás de ese número es que JavaScript usa números flotantes de doble precisión tal como está especfificado en IEEE 754 por lo que puedes representar números de forma segura entre `-(2^53 - 1)` y `2^53 - 1`.

Seguro, en este contexto, se refiere a la habilidad de representar enteros de forma exacta y compararlos de forma correcta. Por ejemplo, `Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2` evaluará como 'verdadero', lo cual es matemáticamente incorrecto. Ver `Number.isSafeInteger()` para más información.

Debido a que `MAX_SAFE_INTEGER` es una propiedad estática de `Number`, siempre se usa como `Number.MAX_SAFE_INTEGER`, en lugar de como una propiedad de un objeto `Number` que hayas creado.

Ejemplos
--------


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

Especificaciones
----------------

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

Compatibilidad con navegadores
------------------------------

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

Ver también
-----------

* `Number.MIN_SAFE_INTEGER` (en-US)
* `Number.isSafeInteger()`
Number.isInteger()
==================

El método **`Number.isInteger()`** determina si el valor pasado es de tipo entero.

Pruébalo
--------

Sintaxis
--------
```

Number.isInteger(valor)
```

### Parámetros

`valor`

El valor a ser probado si es un entero.

### Valor devuelto

Un `Boolean` indicando si el valor dado es un entero o no.

Descripción
-----------

Si el valor seleccionado es un entero, devuelve `true`, de lo contrario `false`. Si el valor es `NaN` o infinito, devuelve `false`.

Ejemplos
--------


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

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

Number.isInteger(NaN); // 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
    );
  };
```

Especificaciones
----------------

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

Compatibilidad con navegadores
------------------------------

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

Ver también
-----------

* El objeto `Number` al que pertenece.
Number.isFinite()
=================

El método **`Number.isFinite()`** determina si el valor pasado es un número finito.

Pruébalo
--------

Sintaxis
--------
```

Number.isFinite(valor)
```

### Parameters

`valor`

El valor cuya finitud será probada.

### Return value

Un `Boolean` indicando si el valor dado es finito o no.

Description
-----------

En comparación con la funcion global `isFinite()` , este método no convierte el parámetro forzádamente a un número. Esto significa que solo valores de tipo númerico, que también son finitos, retornan `true`.

Ejemplos
--------


```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, retornaría true con la función
// global isFinite('0')
Number.isFinite(null); // false, retornaría true con la función
// global isFinite(null)
```

Polyfill
--------


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

Especificaciones
----------------

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

Compatibilidad con navegadores
------------------------------

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

Ver también
-----------

* El objeto `Number` al que pertenece esta función.
* La función global `isFinite`.
Number.POSITIVE\_INFINITY
=========================

Resumen
-------

La propiedad **`Number.POSITIVE_INFINITY`** representa el infinito positivo.

No se tiene que crear un objeto `Number` para acceder a esta propiedad estática (use `Number.POSITIVE_INFINITY`).

| Atributos de la propiedad `Number.POSITIVE_INFINITY` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | No |

Descripción
-----------

El valor de `Number.POSITIVE_INFINITY` es el mismo valor de la propiedad `Infinity` del objeto global.

Este valor tiene un comportamiento ligeramente diferente al infinio matemático:

* Cualquier valor positivo, incluyendo `POSITIVE_INFINITY`, multiplicado por `POSITIVE_INFINITY` da como resultado `POSITIVE_INFINITY`.
* Cualquier valor negativo, incluyendo `NEGATIVE_INFINITY`, multiplicado por `POSITIVE_INFINITY` da como resultado `NEGATIVE_INFINITY`.
* Cero multiplicado por `POSITIVE_INFINITY` da como resultado NaN.
* NaN multiplicado por `POSITIVE_INFINITY` da como resultado NaN.
* `POSITIVE_INFINITY`, dividido por cualquier valor negativo excepto `NEGATIVE_INFINITY`, da como resultado `NEGATIVE_INFINITY`.
* `POSITIVE_INFINITY`, divido por cualquier valor positivo excepto `POSITIVE_INFINITY`, da como resultado `POSITIVE_INFINITY`.
* `POSITIVE_INFINITY`, divido por `INFINITY` o por `POSITIVE_INFINITY`, da como resultado NaN.
* Cualquier numero divido por `POSITIVE_INFINITY` da como resultado cero.

Muchos métodos de JavaScript (tales como el constructor del objeto `Number`, `parseFloat` y `parseInt`) retornan `NaN` si el valor especificado en el parámetro es signficativamente mayor a `Number.MAX_VALUE`.

Podrías utilizar la propiedad `Number.POSITIVE_INFINITY` para indicar una condición de error que retorne un numero finito en caso de que esto suceda. Note, sin embargo, que `isFinite` seria mas apropiado en estos casos.

Ejemplo
-------

En el siguiente ejemplo, a la variable `bigNumber` se le asigna un valor mucho mayor al valor máximo. Cuando la sentencia `if` es ejecutada, `bigNumber` tiene el valor "`Infinity`", por lo cual a `bigNumber` le es asignado un valor mas manejable antes de continuar.


```js
var bigNumber = Number.MAX\_VALUE \* 2;
if (bigNumber === Number.POSITIVE\_INFINITY) {
  bigNumber = returnFinite();
}
```

Especificaciones
----------------

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

Compatibilidad con navegadores
------------------------------

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

Ver también
-----------

* `Number.NEGATIVE_INFINITY`
* `Infinity`
* `isFinite`
Number.MAX\_VALUE
=================

La propiedad **`Number.MAX_VALUE`** representa el valor numérico positivo máximo representable en JavaScript.

| Atributos de la propiedad `Number.MAX_VALUE` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | No |

Descripción
-----------

La propiedad `MAX_VALUE` tiene un valor aproximado a `1.79E+308`. Si el valor es mayor será representado como *`Infinity`*.

Dado que `MAX_VALUE` es una propiedad estática de `Number`, siempre ha de usarse como `Number.MAX_VALUE`, y no como propiedad del objeto que has creado.

Ejemplos
--------

### Usando `MAX_VALUE`

La función *verificarValorMaximo* recibe un número como parámetro que se compara con *Number.MAX\_VALUE.* Si el número es menor se imprime por consola *"El número no es infinito"*, de ser mayor *"El número es infinito"*.


```js
var numero1 = 1.79e307;
var numero2 = 1.79e310;

function verificarValorMaximo(num) {
  if (num <= Number.MAX\_VALUE) {
    console.log("El número no es infinito");
  } else {
    console.log("El número es infinito");
  }
}

verificarValorMaximo(numero1); // El número no es infinito
verificarValorMaximo(numero2); // El número es infinito
```

Especificaciones
----------------

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

Compatibilidad con navegadores
------------------------------

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

Ver también
-----------

* `Number.MIN_VALUE`