Números en Javascript

Javascript tiene sólo un único tipo de número. Los números pueden ser escritos con o sin decimales.

Ejm

var x = 3.14;    // A number with decimals
var y = 3;       // A number without decimals

Los números extra grandes o extra pequeños se pueden escribir con notación científica (exponente).

Ejm

var x = 123e5;    // 12300000
var y = 123e-5;   // 0.00123

Los números de JavaScript son siempre coma flotante de 64 bits

A diferencia de muchos otros lenguajes de programación, JavaScript no define diferentes tipos de números, como enteros, corto, largo, coma flotante, etc.

Los números de JavaScript siempre se almacenan como números de coma flotante de doble precisión, siguiendo el estándar internacional IEEE 754.

Este formato almacena números en 64 bits, donde el número (la fracción) se almacena en los bits 0 a 51, el exponente en los bits 52 a 62 y el signo en el bit 63

Precisión

Los enteros (números sin notación de punto o exponente) tienen una precisión de hasta 15 dígitos.

Ejm

var x = 999999999999999;   // x will be 999999999999999
var y = 9999999999999999;  // y will be 10000000000000000

El número máximo de decimales es 17, pero la aritmética de coma flotante no siempre es 100% precisa.

Ejm

var x = 0.2 + 0.1;         // x will be 0.30000000000000004

Para resolver el problema anterior, ayuda a multiplicar y dividir.

Ejm

var x = (0.2 * 10 + 0.1 * 10) / 10;       // x will be 0.3

Añadiendo números y cadenas

JavaScript usa el operador + tanto para la suma como para la concatenación.

Se agregan los números. Las cadenas están concatenadas.

Si añades 2 números, el resultado será un número

Ejm

var x = 10;
var y = 20;
var z = x + y;           // z will be 30 (a number)

Y si añades 2 strings, el resultado será una concatenación de strings.

Ejm

ar x = "10";
var y = "20";
var z = x + y;           // z will be 1020 (a string)

Si añades un número y un string, el resultado será una concatenación de strings.

Ejm

var x = 10;
var y = "20";
var z = x + y;           // z will be 1020 (a string)

Si añades un string y un número, el resultado será una concatenación

Ejm

var x = "10";
var y = 20;
var z = x + y;           // z will be 1020 (a string)

Un error común es esperar que este resultado sea 30.

var x = 10;
var y = 20;
var z = "The result is: " + x + y;

Un error común es esperar que este resultado sea 102030.

var x = 10;
var y = 20;
var z = "30";
var result = x + y + z;

El intérprete de JavaScript funciona de izquierda a derecha. Primero se agrega 10 + 20 porque x e y son ambos números. Entonces 30 + “30” se concatena porque z es una cadena.

Cadenas numéricas

Las cadenas de JavaScript pueden tener contenido numérico.

Ejm

var x = 100;         // x is a number
var y = "100";       // y is a string

JavaScript intentará convertir cadenas en números en todas las operaciones numéricas. Esto funcionará.

Ejm

var x = "100";
var y = "10";
var z = x / y;       // z will be 10

Esto también funcionará.

Ejm

var x = "100";
var y = "10";
var z = x * y;       // z will be 1000

Y esto también funcionará.

Ejm

var x = "100";
var y = "10";
var z = x - y;       // z will be 90

Pero el siguiente ejm no funcionará

Ejm

var x = "100";
var y = "10";
var z = x + y;       // z will not be 110 (It will be 10010)

En el último ejemplo, JavaScript usa el operador + para concatenar las cadenas.

NaN – Not a Number

NaN es una palabra reservada de JavaScript que indica que un número no es un número legal. Intentar hacer aritmética con una cadena no numérica dará como resultado NaN (no un número).

Ejm

var x = 100 / "Apple" // x will be NaN (Not a Number)

Sin embargo, si la cadena contiene un valor numérico, el resultado será un número.

Ejm

var x = 100 / "10";     // x will be 10

Puedes usar la función global de JavaScript isNaN() para averiguar si un valor es un número.

Ejm

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>You can use the global JavaScript function isNaN() to find out if a value is a number:</p>

<p id="demo"></p>

<script>
var x = 100 / "Apple";
document.getElementById("demo").innerHTML = isNaN(x);
</script>

</body>
</html>

Cuidado con NaN. Si usas NaN en una operación matemática, el resultado también será NaN:

Ejm

var x = NaN;
var y = 5;
var z = x + y;         // z will be NaN

O el resultado puede ser una concatenación.

Ejm

var x = NaN;
var y = "5";
var z = x + y;         // z will be NaN5

NaN es un número: typeof NaN devuelve el número:

Ejm

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>The typeof NaN is number:</p>

<p id="demo"></p>

<script>
var x = NaN;
document.getElementById("demo").innerHTML = typeof x;
</script>

</body>
</html>

Infinity (Infinito)

Infinity (o –Infinity) es el valor que JavaScript devolverá si calcula un número fuera del mayor número posible.

Ejm

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>Infinity is returned if you calculate a number outside the largest possible number:</p>

<p id="demo"></p>

<script>
var myNumber = 2; 
var txt = "";
while (myNumber != Infinity) {
   myNumber = myNumber * myNumber;
   txt = txt + myNumber + "<br>";
}
document.getElementById("demo").innerHTML = txt;
</script>

</body>
</html>

ivision por 0 (cero) también genera Infinito:

Infinity es un número: typeof Infinity devuelve un número.

Ejm

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>Infinity is a number:</p>

<p id="demo"></p>

<script>
var x = Infinity;
document.getElementById("demo").innerHTML = typeof x;
</script>

</body>
</html>

Hexadecimal

JavaScript interpreta las constantes numéricas como hexadecimales si van precedidas de 0x.

Ejm

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>Numeric constants, preceded by 0x, are interpreted as hexadecimal:</p>

<p id="demo"></p>

<script>
var x = 0xFF;
document.getElementById("demo").innerHTML = "0xFF = " + x;
</script>

</body>
</html>

Ojo: Nunca escribas un número con un cero a la izquierda (como 07). Algunas versiones de JavaScript interpretan los números como octales si están escritos con un cero a la izquierda.

Por defecto, JavaScript muestra los números como decimales base 10. Pero puedes usar el método toString() para generar números de la base 2 a la base 36. Hexadecimal es base 16. Decimal es base 10. Octal es base 8. Binario es base 2.

Ejm

var myNumber = 32;
myNumber.toString(10);  // returns 32
myNumber.toString(32);  // returns 10
myNumber.toString(16);  // returns 20
myNumber.toString(8);   // returns 40
myNumber.toString(2);   // returns 100000

Los números pueden ser objetos

Normalmente, los números de JavaScript son valores primitivos creados a partir de literales.

Ejm

<!DOCTYPE html>
<html lang="es">
<body>
	<h2>Javascript Numbers</h2>	
	<p>Un número puede ser un objeto, pero no hay necesidad de crear un número como objeto.</p>

	<p id="demo"></p>

	<script>
		var x = 123;
		var y = new Number(123);
		document.getElementById("demo").innerHTML = typeof x +
		"<br />" + typeof y;
	</script>
</body>
</html>

No crees objetos numéricos. Disminuye la velocidad de ejecución. La palabra clave new complica el código. Esto puede producir algunos resultados inesperados.

Cuando se usa el operador ==, los números iguales son iguales.

Ejm

var x = 500;             
var y = new Number(500);

// (x == y) is true because x and y have equal values

Cuando se usa el operador ===, los números iguales no son iguales, porque el operador === espera igualdad tanto en tipo como en valor.

Ejm

var x = 500;             
var y = new Number(500);

// (x === y) is false because x and y have different types

O incluso peor. Los objetos no se pueden comparar:

EJm

var x = new Number(500);             
var y = new Number(500);

// (x == y) is false because objects cannot be compared

Ten en cuenta la diferencia entre (x == y) y (x === y). Comparar dos objetos JavaScript siempre devolverá falso.