Números JavaScript

En JavaScript moderno pueden destacarse dos tipos de números: Regular y bigInt.

Los números regulares se almacenan en el formato de 64 bits IEEE-754. También se conocen como “Números flotantes de doble precisión”. Los desarrolladores utilizan estos números la mayor parte en su práctica.
Los números BigInt se utilizan para representar enteros de longitud arbitraria. Solo los utilizamos en algunas áreas únicas.

Las formas de escribir un número

Supongamos que quieres escribir mil millones. Esta es la forma más común:

let billion = 1000000000;

En nuestra práctica, comúnmente intentamos alejarnos de escribir muchos ceros. Preferimos escribir, por ejemplo, "1bn". Ahora, aprenderemos cómo acortar un número en JavaScript.

Para acortar un número en JavaScript, debes agregar la letra "e" al número y especificar el recuento de ceros. Se verá de esta manera:

Javascript numbers

let million = 1e6; // 1 million, literally: 1 and 6 zeroes console.log(2.5e6); // 2.5 millions (2,500,000)

Javascript numbers

let exponential = 2.56e3; console.log(exponential); // 2560

Ahora, imagina que quieres escribir “un microsegundo”. Debes hacerlo de la siguiente manera:

let ms = 0.000001;

Si estás deseoso de evitar escribir una gran cantidad de ceros, debes actuar de esta manera:

Javascript numbers

let ms = 1e-6; // six zeroes to the left from 1 console.log(ms);

Como 0.000001 incluye 6 ceros, será 1e-6.

Números Hexadecimales, Binarios y Octales

En Javascript, utilizamos números hexadecimales, también conocidos como Hex, para representar colores, codificar caracteres, y mucho más. Afortunadamente, hay una manera más corta de escribirlos:

0x y luego el número.

Aquí tienes un ejemplo:

Javascript hexadecimal numbers

let hex = 0xfff; console.log(hex); // 4095 console.log(0xff); // 255 console.log(0xFF); // 255 (the same, case doesn't matter)

Aquí tienes un ejemplo de los números octales :

Javascript octal numbers

let octal = 030; console.log(octal); // 24

Generalmente, los desarrolladores utilizan los sistemas numerales binario y octal más raramente. Estos sistemas numerales también están soportados utilizando los siguientes prefijos: 0b y 0o.

Por ejemplo:

Javascript binary and octal numbers

let a = 0b11111111; // binary form of 255 let b = 0o377; // octal form of 255 console.log(a == b); // true

toString (Base)

Este método devuelve una representación de cadena de num, con una base particular, que puede variar de 2 a 36. Pero por defecto es 10.

Por ejemplo:

Javascript toString method numbers

let num = 255; console.log(num.toString(16)); // ff console.log(num.toString(2)); // 11111111

Redondeo

Una operación típica al trabajar con números es el redondeo.

A continuación puedes encontrar varias funciones incorporadas usadas para el redondeo:

Math.floor

Con la ayuda de esta función, puedes redondear fácilmente hacia abajo. Por ejemplo, 6.2 se convierte en 6, -2.2 se convierte en-3.

Math.ceil

Esta función hace lo contrario. Redondea los números hacia arriba. Por ejemplo, 3.1 se convierte en 4, -2.2 se convierte en -2 .

Math.round

El uso de esta función redondeará al entero más cercano. Por ejemplo, 3.1 se convierte en 3, 5.6 se convierte en 6, y -2.2 se convierte en -2.

Math.trunc

Esta función elimina cualquier cosa después del punto decimal. Por ejemplo, 6.1 se convierte en 6.

Cálculo Impreciso

En el formato de 64 bits IEEE-754, hay 64 bits para almacenar un número. 52 de ellos se utilizan para almacenar los dígitos, 11 de ellos - para la posición del punto decimal, y 1- para el signo.

En caso de que el número sea demasiado grande, se desbordará el almacenamiento de 64 bits y potencialmente dará un infinito.

Para una mejor comprensión, revisa este ejemplo:

Javascript infinity numbers

console.log(2e500); // Infinity

La pérdida de precisión también es algo común. Mira la siguiente prueba (falsa!):

Javascript numbers

console.log(0.1 + 0.2 == 0.3); // false

Pruebas: isFinite e isNan

Primero que nada, veamos los siguientes dos valores numéricos únicos:

Infinity (y -Infinity). Este valor numérico es mayor (menor) que cualquier otra cosa.
NaN muestra un error.

Es vital saber que estos no son números estándar. Por lo tanto, necesitas usar funciones especiales para comprobarlos.

isNaN(value)

Por ejemplo:

Javascript numbers isNaN method

console.log(isNaN(NaN)); // true console.log(isNaN("str")); // true

Te puedes preguntar por qué no es posible usar la comparación de === NaN. Simplemente porque el NaN es único en que no será igual a nada, ni siquiera a sí mismo:

Javascript NaN compare

console.log(NaN === NaN); // false

isFinite(value) convertirá su argumento a un número y devolverá true en caso de que el número sea regular, no NaN/Infinity/-Infinity.

Miremos este ejemplo:

Javascript isFinite method

console.log(isFinite("23")); // true console.log(isFinite("str")); // false, because a special value: NaN console.log(isFinite(Infinity)); // false, because a special value: Infinity

Hay casos en los que los desarrolladores utilizan isFinite para validar si un valor de cadena es un número regular, de esta manera:

Javascript isFinite method

let num = +prompt("Enter a number", ''); console.log(isFinite(num));// if you don't enter Infinity, -Infinity or Nan, then will be true

ParseInt y ParseFloat

Una conversión numérica que utiliza un + o un Number() es estricta. Si un valor no es exactamente un número, fallará de la siguiente manera:

Javascript parse numbers

console.log(+"200px"); // NaN

Los espacios al principio o al final de la cadena son la única excepción, ya que se ignoran.

Por cierto, en CSS, puedes encontrar valores en unidades, como "20pt" o "50px". Además, hay muchos países donde el símbolo de la moneda va después del monto. Por ejemplo, "19$". Si quieres extraer un valor numérico de ello, puedes usar parseInt y parseFloat. Estas funciones leerán de una cadena hasta el punto en que no puedan. Si ocurre un error, se devolverá el número que se ha recopilado. El parseInt devolverá un entero, mientras que parseFloat- el número de punto flotante, de la siguiente manera:

Javascript parse numbers

console.log(parseInt('50px')); // 50 console.log(parseFloat('22.5em')); // 22.5 console.log(parseInt('20.4$')); // 20, only the integer part is returned console.log(parseInt('22.2')); // 22, only the integer part is returned console.log(parseFloat('22.2.4')); // 22.2, the second point stops the reading

En algunas situaciones, las funciones parseInt y parseFloat no devolverán el NaN. Esto puede suceder cuando no se encuentran dígitos. Revisa el siguiente ejemplo:

Javascript parse numbers

console.log(parseInt('a13')); // NaN, the first symbol stops the process

La función parseInt() tiene un parámetro opcional que especifica la base del sistema numeral. Así, parseInt puede analizar las cadenas de números hexadecimales, números binarios, etc:

Javascript parse hex numbers

console.log(parseInt('0xff', 16)); // 255 console.log(parseInt('ff', 16)); // 255, without 0x also works console.log(parseInt('2n9', 36)); // 3429

Hora del Cuestionario: ¡Pon a Prueba Tus Habilidades!

¿Listo para desafiar lo que has aprendido? Sumérgete en nuestros cuestionarios interactivos para una comprensión más profunda y una forma divertida de reforzar tu conocimiento.