Números y algunos de sus métodos

En pos de continuar con el aprendizaje de JavaScript aquí estoy ahora añadiendo el poder de los números. Claro está que es algo común de todos los lenguajes de programación. Y a estas alturas veo que los datos en los lenguajes de programación no escapan de ello. Números y textos. Aunque los arreglos y objetos pasan a ser tomados como tipos de datos diferentes, no dejan de contener números y textos.

En el artículo pasado documenté el tema de las cadenas de textos, ahora vamos con los números.

Declarar variables tipo número

Tan burgar como:

let nombreVariable = 20; 

let nombreVariable2 = "20"; //Esto no es un valor número, es un texto

const nomVar = new Number(2021);
//Forma no muy común para declara una variable tipo número que a la final será un objeto

Tipo de valores tipo número

Es verdad que en mis estudios anteriores de programación, como Basic, VisualBasic, Java, Php (ninguno culminado), llegué a ver variables numéricas tipo float, double, int y pare de contar, pero que a la final eran números. Estos se diferenciaban si eran decimales, enteros o no sé qué más.

No obstante, me agrada saber que en JavaScript no es necesario especificar si se está creando una variable numérica entera o decimal. Al declararse un número, no importa si es decimal o entero, la variable es tipo número y punto, genial.

const nombreVar = 11.5;

Operaciones con números

En un lenguaje de programación o específicamente en JavaScript a esto se le llama Operadores y Expresiones Matemáticas. Son muchas, entre ellas las expresiones aritméticas y sus operadores. También hay de lógica, de comparación, etc. Los detalles aquí en la página de Mozilla.

No obstante aquí resumo lo que se impartió en el curso.

Operaciones básicas

const numero1 = 30;
const numero2 = 20;

suma = numero1 + numero2; //JS entiende que no está concatenando, la concatenación con signos de +          solo funciona para datos tipo string.
resta = numero1 - numero2;
multiplicacion = numero1 * numero2;
division = numero1 - numero2;
modulo = numero1 % numero2; //El residuo de la división en enteros                                  

El operador módulo lo que hace es devolver el residuo que resulta de dividir en cantidades enteras un número A entre un número B.

Comparaciones

Las comparaciones tratan de comparar dos variables sobre si son iguales, en el caso de los números si son mayor o menor y esto va a arrojar valores booleanos.

Comparaciones con operadores mayor que y menor que (<>)

Lo que haces es comparar valores, hasta ahora entiendo que solo dos valores como es normal. El resultado devuelve un booleano.

console.log(10>1);//Esto va a mostrar true en la consola

let dato;
dato = 10 < 1; //Esto a va a asignar el valor false a la variable dato

No hay más que decir al respecto.

Comparaciones con operadores igual a (== ===)

Con el operador == estamos preguntando si un dato tiene el mismo valor que otro dato, pero no es estricto, podría arrojar true si ambos datos tienen el mismo valor aún siendo tipo number y el otro tipo string.

let dato1 = 20;
let dato2 = "20";
let dato3 = 20;

let dato4 = dato1 == dato2; //Esto va a asignar el valor true a dato4 
let dato5 = dato1 == dato3; //Esto va a asignar el valor true a dato5  

El operador === es estricto. Va a tomar en cuenta el tipo de dato en la comparación.

let dato1 = 20;
let dato2 = "20";
let dato3 = 20;

let dato4 = dato1 === dato2; //Esto va a asignar el valor false a dato4 
let dato5 = dato1 === dato3; //Esto va a asignar el valor true a dato5  

Comparaciones con operadores diferente a (!= !==)

Lo mismo de arriba ocurre para el operador diferente a.

let dato1 = 20;
let dato2 = "20";

dato1 != dato2;  // Esto va a arrojar false
dato1 !== dato2; // Esto va a arrojar true

Comparación de los valores null y undefined

Es importante aclarar que al comparar dos datos con valores null y undefined respectivamente con el operadore == tendremos como resultado true, cosa que no debería ser. En cambio al hacer la operación con el operador === tenemos como resultado el valor false.

El objeto MATH

MATH es un objeto de funciones con operaciones matemáticas.

Podría ponerme aquí a mostrar ejemplos de las diferentes operaciones matemáticas que se pueden hacer con este objeto, pero creo que queda claro que operaciones matemáticas hay para tirar para arriba. Lo que hay que centrarse es en como usarlas.

La sintaxis es la siguiente:

let nombreVariable = Math.operacion(dato);

En algunos casos no necesita argumento como en el caso de pi

let dato = Math.PI;
console.log(dato); //Mostrara el valor de PI

let resultado;
const dato = 16;

resultado = Math.sqrt(dato);// sqrt calcula la raíz cuadrada

console.log(resultado); //Esto arrojará el número 4 en consola

Así como hay raíz cuadrada hay un montón de operaciones cuadradas que cubren operaciones algebraicas, trigonométricas y creo que hasta de ecuaciones diferenciales.

Hay una operación random muy interesante que aún teniendo paréntesis no veo que se le meta datos.

let resultado;
resultado = MATH.random();
console.log(resultado); // Esto arrojará un decimal de muchas cifras random

Se puede mezclar con otras operaciones para ajustarlo a nuestras necesidades, por ejemplo, un número aleatorio de dos cifras:

let resultado;
resultado = MATH.floor(MATH.random * 100);
console.log(resultado); //Esto arrojará un valor aleatorio de dos cifras

Si quiero divertirme con las operaciones matemáticas que trae este objeto y/o conocer a más detalles sus características:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math

https://www.w3schools.com/js/js_math.asp

Orden de las operaciones

En el curso hubo una parte que explicaba el orden de las operaciones, me pregunto si en otros lenguajes de programación será diferente pero aquí en JS no veo necesario ni siquiera exponerlo.

Incrementar o decrementar

Los valores suelen incrementarse o decrementarse. En JS esto se hace con los signos + y – dobles, antes o después del nombre de la variable, de la siguiente manera:

let numero1 = 5;
let numero2 = 5;
let numero3 = 5;
let numero4 = 5;
let numero5 = 5;
let numero6 = 5;

numero1++;
console.log(numero1); //resultado: 6

++numero2;
console.log(numero2); //resultado: 6

numero3--;
console.log(numero3); //resultado: 4

--numero4;
console.log(numero4); //resultado: 4

numero5+=2;
console.log(numero5); //resultado: 7

numero6-=2;
console.log(numero6); //resultado: 3

En el caso de las variables numero1 y numero2 el resultado es el mismo, pero hay que tomar en cuenta que en el flujo de operaciones de JS en el primer caso el flujo llama el valor y luego lo incrementa, en el caso de numero2, primero lo incrementa y luego lo llama. Pero con el console.log() no se suele apreciar eso. Eso lo apreciamos mejor echando los valores en la consola. Por ejemplo:

Lo mismo para para los casos de las variables numero3 y numero4 pero en decremento.

En el caso de las variables numero5 y numero6 se incrementa por el valor que se le asigna luego del signo =. Tomando en cuenta que no hay otra forma de escribirlo como en los otros casos y que no va a llamar el valor y luego incrementar, no, en estos casos siempre incrementa y luego llama al valor ya incrementado.

Métodos con el objeto Number

Esto es más de lo mismo que con el objeto MATH, es decir, no se tratan de un método como tal, si no de un objeto que tiene métodos. La sintaxis es la siguiente:

Number.metodo(dato);

Método parseInt – Pasar un string a número entero

const numero1 = "20";
const numero2 = "20.2";

console.log(Number.parseInt(numero1));
//Esto arroja como valor un dato tipo number: 20
console.log(Number.parseInt(numero2));
//Esto arroja como valor un dato tipo number: 20

Método parseFloat – Pasar un string a número decimal

El método anterior va a pasar un string a un número entero, si el número tipo string describe un decimal entonces el resultado solo arrojará el valor entero. Si queremos pasar el valor de numero2 a decimal tal como está debemos usar parseFloat.

const numero1 = "20";
const numero2 = "20.2";

console.log(Number.parseFloat(numero1));
//Esto arroja como valor un dato tipo number: 20
console.log(Number.parseFloat(numero2));
//Esto arroja como valor un dato tipo number: 20.2

Valor NaN: Not a Number

Podríamos sentirnos tentados a convertir un string que no es un número a dato tipo number con, por ejemplo, parseInt, pero eso nos va a arrojar como valor NaN

const numero = "casa";

console.log(Number.parseInt(numero));
//Esto arroja: NaN

Método isInteger – Para saber si un número es un entero o no

Arroja un valor buleano.

const numero1 = 20;
const numero2 = 20.4;
const numero3 = "caballo";

console.log(Number.isInteger(numero1));
//Esto arroja como valor: true

console.log(Number.isInteger(numero2));
//Esto arroja como valor: false

console.log(Number.isInteger(numero3));
//Esto arroja como valor: false

Según el instructor en algunos casos será necesario combinar estos procedimientos para verificar si los datos llegan como string, y si es así, entonces pasarlos a number.

Método toString() para pasar un número a string

De forma inversa podemos pasar un dato tipo number a tipo string usando el método .toString(), este método no es parte del objeto Number.

const numero = 20;
console.log(typeof numero); //Esto arroja como valor: number

numero = numero.toString();
console.log(typeof numero); //Esto arroja como valor: string