duduromeroa.com

Javascript

16 métodos de Javascript para datos numéricos. Programación para web (4.3/8)


George Póyla, matemático. Resolver problemas de diseño. www.duduromeroa.com

Por Eduardo J. Romero Andrade
| Guayaquil

Contacto duduromeroa@gmail.com



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 Math.abs()

Obtiene solo el número absoluto entero, sin signos:

En Javascript

const x = -10;
const y = 5;

// Valor STRING que se convertirá a número
const z = '-1.5';

console.log(Math.abs(x)); 
// 10
console.log(Math.abs(y)); 
// 5
console.log(Math.abs(z)); 
// 1.5

MÉTODO Math.cbrt()

Retorna la raíz cúbica de un número dado:

En Javascript

const num = 598;

/* Qué número multiplicado TRES veces 
POR SÍ sí mismo da 598 */
const raizCubi = Math.cbrt(num);
console.log(raizCubi); 

// CONFIRMAR
/* Multiplicar 3 veces por sí mismo la raíz cúbica de 598 */
console.log(raizCubi * raizCubi * raizCubi);
// 598.0000000000001

MÉTODO Math.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 Math.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 COMPROBADO 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 comprobado ] La luna no es verde

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

[ Valor lógico ] 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 Math.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 Math.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 Math.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 Math.sign()

Obtiene solo la referencia en la regla numérica de un valor. Si el número es negativo se obtiene -1; si es positivo, 1; y si es cero, 0:

En Javascript

const x = -10;
const y = 5;
const z = 0;

// negativo
console.log(Math.sign(x)); 
// -1

// positivo
console.log(Math.sign(y)); 
// 1

// cero
console.log(Math.sign(z)); 
// 0

MÉTODO Math.sqrt()

Retorna la raíz cuadrada de un número dado en el argumento. Solo es admitido un valor positivo:

En Javascript

const num = 16;

/* Qué número multiplicado dos veces da 16 */
const raizCuadrada = Math.sqrt(num);
console.log(raizCuadrada); 
//-> 4

MÉTODO Math.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 Avanzar



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