Variables numéricas

En Javascript crear variables numéricas es muy sencillo, pero hay que conocer bien como trabajar con ellas y los diferentes métodos de los que dispone.

¿Qué es una variable numérica?

En Javascript, los números son uno de los tipos de datos básicos (tipos primitivos) que para crearlos, simplemente basta con escribirlos. No obstante, en Javascript todo son objetos, como veremos más adelante, y también se pueden declarar como si fueran un objeto:

Constructor Descripción
Number new Number(n) Crea un objeto numérico a partir del número n pasado por parámetro.
Number n Simplemente, el número en cuestión. Notación preferida.

Sin embargo, aunque existan varias formas de declararlos, no se suele utilizar la notación new con objetos primitivos ya que es bastante más tedioso y complicado que utilizar la notación de literales:

// Literales
var n1 = 4;
var n2 = 15.8;

// Objetos
var n1 = new Number(4);
var n2 = new Number(15.8);

Cualquier parámetro pasado al new Number() que no sea un número, dará como resultado un valor NaN (ver más adelante).

Constantes numéricas

Existe una serie de constantes definidas en relación a las variables numéricas. La mayoría de ellas establecen límites máximos y mínimos, veamos su significado:

Constante Valor en Javascript Descripción
Number.POSITIVE_INFINITY Infinity Infinito positivo: +∞
Number.NEGATIVE_INFINITY -Infinity Infinito negativo: -∞
Number.MAX_VALUE 1.7976931348623157e+308 Valor más grande
Number.MIN_VALUE 5e-324 Valor más pequeño
Number.MAX_SAFE_INTEGER 9007199254740991 Valor seguro más grande
Number.MIN_SAFE_INTEGER -9007199254740991 Valor seguro más pequeño
Number.EPSILON 2-52 Número muy pequeño: ε
Number.NaN NaN Not A Number

La diferencia entre Number.MAX_VALUE y Number.MAX_SAFE_INTEGER es que, el primero es el valor máximo que es posible representar en Javascript. Por otro lado, el segundo es el valor máximo para realizar cálculos con seguridad en Javascript.

Los lenguajes de programación están sujetos a la precisión numérica debido a la forma interna en la que guardan valores numéricos. Si necesitamos realizar operaciones con muy alta precisión numérica en Javascript, se recomienda utilizar librerías como decimal.js o bigNumber.js.

NaN (Not A Number)

El acrónimo NaN es un valor especial de Javascript que significa Not A Number (No es un número). Este valor se usa para representar valores imposibles o indeterminados, como por ejemplo, resultados matemáticos de operaciones como:

  • 0 / 0 (Indeterminaciones)
  • 4 - 'a' (Valores imposibles)
  • NaN + 4 (Operaciones con NaN como operando)

Este valor se utiliza habitualmente para detectar si una operación ha fallado o ha dado un valor no representable. Sin embargo, no podemos compararlo literalmente con NaN, sino que tenemos que usar la función Number.isNaN():

var num = NaN;

// La siguiente operación, contra toda lógica, es falsa
num == NaN;         // false

// Se debe usar Number.isNaN() para comprobar si el valor es NaN
Number.isNaN(num);  // true

// Si comprobamos el tipo de dato de NaN, nos dirá que es numérico
typeof(num);        // number

Como se puede ver en la última línea del ejemplo anterior, mencionar que en Javascript, si comprobamos el tipo de dato de NaN con typeof nos dirá que es un número. Puede parecer ilógico que Not A Number sea un número, esto ocurre porque NaN está en un contexto numérico.

En otras palabras, dentro de los tipos de datos numéricos, NaN es un conjunto de números que no se pueden representar.

Comprobaciones numéricas

En Javascript tenemos varias funciones para conocer la naturaleza de una variable numérica (número finito, número entero, número seguro o si no es representable como un número). Las podemos ver a continuación en la siguiente tabla:

Método Descripción
Boolean Number.isFinite(n) Comprueba si n es un número finito.
Boolean Number.isInteger(n) Comprueba si n es un número entero.
Boolean Number.isSafeInteger(n) Comprueba si n es un número seguro.
Boolean Number.isNaN(n) Comprueba si n no es un número.

Ten en cuenta que estas funciones devuelven un booleano (valor de verdadero o falso), lo que lo hace ideales para usarlas como condiciones en bucles o condicionales. A continuación veamos dos ejemplos para cada una de estas funciones:

// ¿Número finito?
Number.isFinite(42);         // true
Number.isFinite(Infinity);   // false, es infinito

// ¿Número entero?
Number.isInteger(5);         // true
Number.isInteger(4.6);       // false, es decimal

// ¿Número seguro?
Number.isSafeInteger(1e+15); // true
Number.isSafeInteger(1e+16); // false, es un valor no seguro

// ¿No es un número?
Number.isNaN(NaN);           // true
Number.isNaN(5);             // false, es un número

Recuerda no hacer comprobaciones directas con NaN, sino utilizar la función Number.isNaN().

Conversión numérica

En muchos casos tendremos variables de texto que nos interesa convertir a número, para realizar operaciones posteriormente con ellas. Para ello, lo ideal es utilizar las funciones de parseo numérico, parseInt() y parseFloat(). Veamos cuales son y cómo se pueden utilizar:

Método Descripción
Number Number.parseInt(s) Convierte una cadena de texto s en un número entero.
Number Number.parseInt(s, radix) Idem al anterior, pero desde una base radix.
Number Number.parseFloat(s) Convierte una cadena de texto s en un número decimal.
Number Number.parseFloat(s, radix) Idem al anterior, pero desde una base radix.

Para ilustrar esto, veamos un ejemplo con parseInt() cuando solo le pasamos un parámetro (un texto) que queremos convertir a número:

Number.parseInt('42');          // 42
Number.parseInt('42€');         // 42
Number.parseInt('Núm. 42');     // NaN
Number.parseInt('A');           // NaN

Nota que la función parseInt() funciona perfectamente para variables de texto que contienen números o que empiezan por números. Esto es muy útil para eliminar unidades de variables de texto. Sin embargo, si la variable de texto comienza por un valor que no es numérico, parseInt() devolverá un NaN.

Si lo que queremos es quedarnos con el número que aparece más adelante en la variable de texto, habrá que manipular ese texto con alguna de las funciones que veremos en el apartado de variables de texto.

Veamos ahora que ocurre si utilizamos parseInt() con dos parámetros, donde el primero es el texto con el número y el segundo es la base numérica del número:

Number.parseInt('11101', 2);     // 29 en binario
Number.parseInt('31', 8);        // 25 en octal
Number.parseInt('FF', 16);       // 255 en hexadecimal

Esta modalidad de parseInt() se suele utilizar cuando queremos pasar a base decimal un número que se encuentra en otra base (binaria, octal, hexadecimal...).

Al igual que con parseInt() tenemos otra función llamada parseFloat(). Funciona exactamente igual a la primera, sólo que la primera está específicamente diseñada para utilizar con números enteros y la segunda para números decimales. Si utilizamos parseInt() con un número decimal, nos quedaremos sólo con la parte entera, mientras que parseFloat() la conservará.

Representación numérica

Por último, en el caso de querer cambiar el tipo de representación numérica, podemos utilizar las siguientes funciones para alternar entre exponencial y punto fijo:

Método Descripción
String .toExponential(n) Convierte el número a notación exponencial con n decimales.
String .toFixed(n) Convierte el número a notación de punto fijo con n decimales.
String .toPrecision(p) Utiliza p dígitos de precisión en el número.

Observemos el siguiente ejemplo aplicando las funciones anteriores al número decimal 1.5:

(1.5).toExponential(2);     // "1.50e+0" en exponencial
(1.5).toFixed(2);           // "1.50" en punto fijo
(1.5).toPrecision(1);       // "2"
Manz
Publicado por Manz

Docente, divulgador informático y freelance. Escribe en Emezeta.com, es profesor en la Oficina de Software Libre de la Universidad de La Laguna y dirige el curso de Programación web FullStack de EOI en Tenerife (Canarias). En sus ratos libres, busca GIF de gatos en Internet.