duduromeroa.com

Javascript

Programación para web (4.3/8): Métodos para datos numéricos





En las secciones 4.1, 4.2 y 4.3 ya mencioné que los métodos son funciones predefinidas y usables para alterar datos; sean estos caracteres textuales, símbolos o números. En esta sección se detallará el comportamiento de los métodos para datos tipo número.

MÉTODO ceil()

Redondea un decimal al entero inmediato mayor.

let numA = 3.00001;
console.log(Math.ceil(numA));
//-> 4

let numB = 1.999;
console.log(Math.ceil(numB));
//-> 2

let numC = 0.001;
console.log(Math.ceil(numC));
//-> 1

// Negativos
let numD = -3.99;
console.log(Math.ceil(numD));
//-> -3

MÉTODO PARA EL EXPONENCIAL DE EULER exp()

Este método da la cifra constante 2.718281828459045235360 (...). ¿Para qué sirve este número?.

let num = 1;
// Multiplicar el número 'e' por 1
console.log(Math.exp(num));
//-> 2.718281828459045

El número 'e' es un número fijo, pero infinito decimal que no resulta de la división de ningún número conocido. El número 'e' es usado para cálculos financieros; pero también para determinar –incluso, predecir– incrementos en tiempo y velocidad. El número 'e' fue definido en el siglo 17 por una secuencia de hallazgos iniciados por el matemático escocés John Napier y posteriormente por suizo Leonhard Euler, entre otros.

MÉTODO toFixed()

Devuelve un dato decimal con una cantidad de decimales dada en su argumento. No altera el decimal inicial.

const decimal = 10.888888888;
// Limitar a 3 decimales
console.log(decimal.toFixed(3));
//-> 10.889

// Sin decimales
console.log(decimal.toFixed());
//-> 11

// Sin decimales
console.log(decimal.toFixed(0));
//-> 11

// Permitir Hasta 20 decimales
console.log(decimal.toFixed(20));
//-> 10.88888888800000032120

MÉTODO floor()

Redondea un decimal al entero inmediato menor.

let numA = 3.00001;
console.log(Math.floor(numA));
//-> 3

let numB = 1.999;
console.log(Math.floor(numB));
//-> 1

let numC = 0.001;
console.log(Math.floor(numC));
//-> 0

// Negativos: -4 | -3 | -2 | -1 | 0 | 1...
/* En números negativos, el menor 
de los enteros está ubicado a la 
izquierda de la regla numérica */
let numD = -3.99;
console.log(Math.floor(numD));
//-> -4

MÉTODO isInteger()

Retorna true cuando el valor evaluado es un número entero. Ya que isInteger() no es un método global, sí necesita el objeto Number para precisar la evaluación:

const edad = 4;
console.log( Number.isInteger(edad) );
//-> true

const saludo = "holi";
console.log( Number.isInteger(saludo) );
//-> false

const decimal = 10.8;
console.log( Number.isInteger(decimal) );
//-> false

const ceros = 10.000;
console.log( Number.isInteger(ceros) );
//-> true

/* JS detecta este número como entero debido a 
que el último decimal no influiría en la precisión 
del número, confirmando que es un entero. Pero al 
incrementarse es decimal, esa cantidad deja de ser entero. */
const numGrande = 4500000000000000.1;
console.log( Number.isInteger(numGrande) );
//-> true

MÉTODO isNaN()

Detecta un dato no numérico y envia true para confirmarlo. Si envía false, entonces el dato sí es tipo numérico.

 // isNaN = NO es un número
//--> true si NO lo es
//--> false si SÍ lo es

const edad = "Holi";
// True. Edad no es un número
console.log(isNaN(edad) );
//-> true. Holi NO es un número

const falsee = false;
console.log(isNaN(falsee));
//-> false. Es decir, ese valor SÍ es un número

const truee = true;
console.log(isNaN(truee));
//-> false. Es decir, ese valor SÍ es un número

const vacio = "";
console.log(isNaN(vacio));
//-> false. Es decir, VACIO SÍ es un número

/* Otro valores dan 
los siguientes resultados */
isNaN(NaN); // true
isNaN(undefined); // true
isNaN({}); // true
isNaN(null); // false

/* Otra forma de evaluar si un dato es un número */
let x = "3";
if (typeof x === "number") {
console.log("SI es número");
} else {
console.log("NO es número");
}
//-> NO es número. 
/* "3" es leído como un dato string. */

Si deseamos que el resultado de la evaluación sea TRUE para un dato que sí sea numérico, negaremos isNaN() mediante signo '!':

Negar una negación

Hay que estar atento. Afirmar "No es verdad que la luna no es verde" puede verse como una maraña sin lógica.


Primero, el hecho es que la luna tiene un color claro, grisáceo; pero no es de color verde.


[ Afirmación a confirmar ] No es verdad que la luna no es verde

[ Hecho ] La luna no es verde

[ Afirmación: Se elimina la primera negación ] -No- es verdad que la luna no es verde

[ Confirmación ] Verdad


* * * *

Por lo tanto, cuando negamos isNaN() ya estamos añadiendo una doble negación. Es decir, preguntamos con !isNaN() "¿ese dato No es un No número?".


¿Qué sucede si debemos evaluar el número 20? Analicemos:


[ Afirmación a confirmar ] No es verdad que el 20 no es un número

[ Hecho ] El 20 sí es un número

[ Confirmación: Se eliminan ambas negaciones ] -No- 20 es un -no- Número

[ Afirmación ] ¿20 es un Número?

[ Confirmación ] Verdad.


/* Negar isNaN() nos permite mostrar TRUE cuando 
el valor sí es un número */
const edad = 4;
// ¿Edad No es No número?
console.log(!isNaN(edad) );
//-> true

MÉTODOS ARITMÉTICOS EN JAVASCRIPT

MÉTODO Math.max()

Obtiene el valor mayor a partir de los argumentos ingresados.

// Forma directa pero poco funcional
let cant = Math.max(2,10,200); 
console.log(cant);
//-> 200

// Aplicando arreglo de datos
let edades = [5, 90, 71, 45.5];
let extraerMax = Math.max(...edades
);

console.log(extraerMax);
//-> 90

Notar cómo en el ejemplo anterior se aplicó el operador spread. Este "obtiene los valores de un arreglo siempre que se lo use al invocar una función o al definir un arreglo".

MÉTODO Math.min()

Obtiene el valor menor a partir de los argumentos ingresados.

let edades = [5, 90, 71, 45.5];
let extraerMin = Math.min(...edades
);
console.log(extraerMin);
//-> 5

Ambos métodos Math.min() y Math.max() resolverán como NaN cuando exista un valor que no sea un número:

let edades = [5, "holii"];
let extraerMin = Math.min(...edades
);
console.log(extraerMin);
//-> NaN

MÉTODO sqrt()

Obtiene raíz cuadrada –un número multiplicado por sí mismo dos veces– de un valor numérico entero o decimal. Este método responde a ¿Qué número multiplicado por sí mismo dos veces da el número inicial?

let numerito = 19.20;

/* Qué número multiplicado por sí mismo
dos veces da el valor de 'numerito' */
console.log(Math.sqrt(numerito));
//-> 4.381780460041329

// Limitamos decimales a solo un decimal
console.log(Math.sqrt(numerito).toFixed(1));
// 4.4

/* El número que multiplicado dos veces 
da 19.20 es el 4.4 (reducido en un decimal)*/

MÉTODO pow()

El método power of exponent o pow() devuelve el resultado de un número multiplicado tantas veces se haya ingresado en el argumento. Por ejemplo, si deseamos operar 3 multiplicado 2 veces:

// Dar el resultado de 3 multiplicado 2 veces
let operar = Math.pow(3,2);
console.log(operar);
//-> 9

Otros ejemplos son:

/* Usando variables como argumentos */
let numA = 3;
let numB = 3;
let calcular = Math.pow(numA, numB);
console.log(calcular);
//->

/* Usando operaciones como argumentos */
let numC = 3;
let resolver = Math.pow(numC, 3*2);
console.log(resolver);
//-> 729

/* Cualquier número elevado a 0 dará 1 */
console.log(Math.pow(500, 0));
//-> 1

MÉTODO random()

Devuelve un número decimal aleatorio entre 0.0 y 1.0;

let calculo = Math.random();
console.log("Random: " + calculo);
//-> 0.10360796113997717

// Siempre redondeará al entero mayor
console.log("Ceil: " + Math.ceil(calculo));
//-> 1

// Siempre redondeará al entero menor
console.log("Floor: " + Math.floor(calculo));
//-> 0

// Números entre 0 a 100 con decimales
console.log("Multiplicado por 100 con decimales: " + 
calculo * 100);
//-> Ejemplo: 50.1300....

// Números entre 0 a 10 con decimales
console.log("Multiplicado por 10 con decimales: " + 
calculo * 10);
//-> Ejemplo: 8.9812...

// Números entre 0 a 10 SIN decimales
console.log("Multiplicado por 20 y trunc(): " +
Math.trunc(calculo * 20));
//-> Ejemplo: 18

MÉTODO round()

Este método redondeará al entero inmediato con un mínimo o máximo decimal:

let numA = 3.01;
console.log(Math.round(numA));
//-> Redondeado a 3

let numB = 3.9;
console.log(Math.round(numA));
//-> Redondeado a 3

MÉTODO trunc()

Elimina decimales y obtiene solo el entero. A diferencia de ceil(), round() o floor(); el método trunc() NO redondea.

let numA = 10.100;
console.log(Math.trunc(numA));
//-> 10

let numB = 0.89;
console.log(Math.trunc(numB));
//-> 0

let numC = 8.9999999;
console.log(Math.trunc(numC));
//-> 8

console.log(Math.trunc(numA / numB));
//-> 11


Subir al inicio Seguir a la parte quinta



BIBLIOGRAFÍA:
    3ra edición. 2018. Marijn Haverbeke. No starch press.
    Mozilla Foundation.
    David Flanagan (2020). Editorial O'Reilly.
    Ved Antani, Stoyan Stefanov (2017). Packt Publishing.
    Editorial Packt.
    Information and Computation. Elsevier.
    ACM SIGCSE BulletinVolume 19Issue 1Feb. 1987 pp 98–102https://doi.org/10.1145/31726.31742.