Constantes matemáticas y funciones en JavaScript

En este tutorial, aprenderemos sobre Math Object en JavaScript, que nos permite usar constantes matemáticas como π, e, √2 y realizar operaciones matemáticas con números como pow(), sqrt(), max(), min(), random(), abs(), ceil(), floor(), round()y truc().

Índice
  1. constantes matemáticas
    1. Calcular la circunferencia de un circulo.
  2. Pow-matemáticas
    1. Operador de exponenciación (**)
    2. Cree métodos cuadrados y cúbicos usando el operador de exponenciación
  3. Matemáticas
    1. Crear nuestro propio método de raíz cuadrada
  4. Máxima Matemática
    1. Encuentra el número más grande en una matriz
  5. Matemáticas mínimas
  6. matemáticas aleatorias
    1. Genera un entero aleatorio dado el rango máximo
    2. Generar un entero aleatorio entre dos valores (incluido)
    3. Mezclar elementos de una matriz
  7. Abdominales matemáticos
    1. Encuentra la diferencia absoluta entre dos números
  8. Techo matemático
  9. piso de matematicas
    1. Obtener una parte fraccionaria de un número
    2. Obtener el cociente y el resto de una división de dos enteros
  10. torre de matemáticas
  11. baúl de matemáticas
    1. Crear nuestro propio método de truncamiento
  12. Funciones matemáticas restantes

constantes matemáticas

Math Object en JavaScript proporciona 8 constantes matemáticas que se pueden usar:

Math.E        // returns 2.718281828459045  (Euler's number)
Math.PI       // returns 3.141592653589793  (PI)
Math.SQRT2    // returns 1.4142135623730951 (square root of 2)
Math.SQRT1_2  // returns 0.7071067811865476 (square root of 1/2)
Math.LN2      // returns 0.6931471805599453 (natural logarithm of 2)
Math.LN10     // returns 2.302585092994046  (natural logarithm of 10
Math.LOG2E    // returns 1.4426950408889634 (base 2 logarithm of E)
Math.LOG10E   // returns 0.4342944819032518 (base 10 logarithm of E)

Calcular la circunferencia de un circulo.

utilizar Math.PI constante para calcular la circunferencia 2πr de un círculo dado el radio r:

function calculateCircumference(radius) {
  return 2 * Math.PI * radius;
}

calculateCircumference(10); // returns 62.83185307179586

Pow-matemáticas

los Math.pow(a, b) devuelve a (base) a la potencia b (exponente), es decir aB.

Math.pow(4, 3);      
// returns 64 i.e. 4×4×4

Math.pow(-4, 3);     
// returns -64 i.e. (-4)×(-4)×(-4)

Math.pow(4, -3);     
// returns 0.015625 i.e. 1 ÷ (4 × 4 x 4) 

Math.pow(64, 0.5);   
// returns 8 i.e. 2√64

Math.pow(-64, 0.5);  
// returns NaN i.e. 2√-64 square root number cannot be negative

Math.pow(64, -0.5);  
// returns 0.125 i.e. 1 ÷ 2√64 = 1/8

Analicemos el resultado de los ejemplos anteriores para una comprensión clara:

Matemáticas.pow(a, b) aB desglose resultados
Matemáticas.pow(4, 3) 43 4×4×4 64
Matemáticas.pow(-4, 3) (-4)3 (-4) × (-4) × (-4) -64
Matemáticas.pow(4, -3) 4(-3) 1 ÷ (4 × 4 × 4) 0.015625
Matemáticas.pow(64, 0.5) 640.5 2√64 8
Matemáticas.pow(-64, 0.5) (-64)0.5 2√-64 no
Matemáticas.pow(64, -0.5) 64(-0.5) 1 ÷ 2√64 0.125

Operador de exponenciación (**)

Es muy interesante saber que JavaScript ES6 proporciona una sintaxis abreviada ** para el poder matemático también conocido como operador de exponenciación. Entonces lo anterior Math.pow los ejemplos son los mismos que:

console.log(4 ** 3);       // returns 64
console.log((-4) ** 3);    // returns -64
console.log(4 ** -3);      // returns 0.015625
console.log(64 ** 0.5);    // returns 8
console.log((-64) ** 0.5); // returns NaN
console.log(64 ** -0.5);   // returns 0.125

Tenga en cuenta que si usa una sintaxis abreviada con la base -ve, debe envolver la base entre paréntesis () para evitar Error de sintaxis.

➤ -4 ** 3
Uncaught SyntaxError: Unary operator used immediately before exponentiation expression. Parenthesis must be used to disambiguate operator precedence

➤ (-4) ** 3
-64

Cree métodos cuadrados y cúbicos usando el operador de exponenciación

Vamos a crear métodos matemáticos de potencia usando el operador de exponenciación **:

const square = x => x ** 2;
const cube = x => x ** 3;

square(4); // returns 16
cube(3);   // returns 27

Matemáticas

los Math.sqrt(x) La función devuelve la raíz cuadrada del número dado.

Math.sqrt(0);     // returns 0
Math.sqrt(null);  // returns 0

Math.sqrt(25);    // returns 5
Math.sqrt(1);     // returns 1
Math.sqrt(0.5);   // returns 0.7071067811865476

Math.sqrt(-5);    // returns NaN as number cannot be negative
Math.sqrt(NaN);   // returns NaN as number cannot be NaN

Crear nuestro propio método de raíz cuadrada

Creamos el nuestro squareroot métodos que utilizan el operador de exponenciación ES6 **:

const squareroot = x => x ** 0.5;

squareroot(0);      // returns 0
squareroot(null);   // returns 0
squareroot(25);     // returns 5
squareroot(1);      // returns 1
squareroot(0.5);    // returns 0.707106781186547
squareroot(-5);     // returns NaN as number cannot be negative
squareroot(NaN);    // returns NaN as number cannot be NaN 

Tenga en cuenta que la raíz cuadrada de los números negativos no existe entre el conjunto de números reales, por lo que JavaScript devuelve NaN. La raíz cuadrada de números negativos es un número imaginario representado por i es decir √-1 = i

Máxima Matemática

los Math.max(value1, value2, value3, ...) La función devuelve el valor más grande entre los valores dados.

Math.max(1, 3, 2, 0, -1);      
// returns 3

Si un argumento no se puede convertir en un número, NaN Volvió.

Math.max(1, 3, 2, '0', -1);    
// returns 3 as '0' is converted to numeric 0

Math.max(1, 3, 2, 'zero', -1); 
// returns NaN as 'zero' cannot be converted to numeric value

Encuentra el número más grande en una matriz

utilizar Math.max función para encontrar el número más grande en una matriz de tres maneras: -

① Usando el operador de propagación ...

const numbers = [1, 2, 3, 4, 5];
Math.max(...numbers);          
// returns 5

② Uso del prototipo de función apply() método

const numbers = [1, 2, 3, 4, 5];
Math.max.apply(null, numbers);  
// returns 5

③ Uso Array.reduce() método

const numbers = [1, 2, 3, 4, 5];
numbers.reduce((a,b) => Math.max(a,b));  
// returns 5

Sin embargo, ambos spread (...) y apply() fallará o devolverá un resultado incorrecto si la matriz contiene demasiados elementos, porque intentan pasar los elementos de la matriz como parámetros de función. los Array.reduce() método no tiene este problema.

Matemáticas mínimas

los Math.min(value1, value2, value3, ...) La función devuelve el valor más pequeño entre los valores dados.

Ejemplo de uso Math.min es idéntico a Math.max Una función.

Math.min(1, 3, 2, 0, -1);               // returns -1
Math.min(1, 3, 2, '0', -1);             // returns -1
Math.min(1, 3, 2, 'zero', -1);          // returns NaN

const numbers = [1, 2, 3, 4, 5];  
Math.min(...numbers);                   // returns 1
Math.min.apply(null, numbers);          // returns 1
numbers.reduce((a,b) => Math.min(a,b)); // returns 1 

matemáticas aleatorias

los Math.random() las funciones devuelven un número aleatorio de punto flotante entre 0 (inclusive) y 1 (exclusivo)

0 ≤ Math.random() < 1

Vamos a crear algunos métodos útiles usando Math.random() Una función:

Genera un entero aleatorio dado el rango máximo

Comencemos por crear un método. getRandomIntque devuelve un entero aleatorio dado el rango máximo

const getRandomInt = (max) => Math.floor(Math.random() * max) + 1;

Usemos este método para encontrar un nombre de usuario aleatorio en la matriz dada

const userList = ["Alice", "Bob", "Charlie", "David", "Eric", "Franklin", "Gavin", "Harry", "Iris", 
                "Joey", "Kate", "Leo", "Monica", "Nancy", "Oscar", "Phoebe", "Quinn", "Ross", 
                "Sofia", "Tyler", "Umar", "Victor", "Wilson", "Xena", "Yasmine", "Zara"];

const getRandomUser = () => userList[getRandomInt(userList.length)];

console.log(getRandomUser()); // Wilson
console.log(getRandomUser()); // Charlie
console.log(getRandomUser()); // Leo
console.log(getRandomUser()); // Joey
console.log(getRandomUser()); // Gavin

Generar un entero aleatorio entre dos valores (incluido)

Comencemos por crear un método. getRandomIntInclusiveque devuelve un entero aleatorio entre dos valores (inclusive)

const getRandomIntInclusive = (min, max) => {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min + 1)) + min;
};

Usemos este método para generar una matriz de 10 elementos con números aleatorios de dos dígitos, es decir, entre 10 y 99

var numbers = [];
var min = 10;
var max = 99;

for ( var i = 0; i < 10; i++ ) {
    numbers.push(getRandomIntInclusive(min, max));
}

console.log(numbers);
// [25, 55, 95, 51, 47, 10, 74, 86, 74, 77]

Mezclar elementos de una matriz

Este es un uso muy interesante de Math.random() funcionar con Array.sort() funciones para barajar los elementos de una matriz. Vamos a crear nuestro shuffleElements método:

const shuffleElements = (list) => list.sort(() => Math.random() - 0.5);

La idea aquí es generar un número aleatorio usando Math.random() entre -0.5 y 0.5 y aliméntelo a Array.sort() la función que ordena una matriz según el valor devuelto es +ve, o 0 o -ve

Usemos este método:

const list = [1, 2, 3, 4, 5, 6, 7, 8, 9];

console.log(shuffleElements(list));
// [6, 1, 2, 4, 3, 9, 5, 8, 7]

console.log(shuffleElements(list));
// [9, 6, 8, 1, 2, 7, 4, 5, 3]

console.log(shuffleElements(list));
// [6, 7, 3, 1, 2, 5, 8, 9, 4]

Abdominales matemáticos

los Math.abs(x) devuelve el absoluto de un número, es decir, |x|

Math.abs('-1');     // 1
Math.abs(-2);       // 2
Math.abs(null);     // 0
Math.abs('');       // 0
Math.abs([]);       // 0
Math.abs([2]);      // 2
Math.abs([1,2]);    // NaN
Math.abs({});       // NaN
Math.abs('string'); // NaN
Math.abs();         // NaN

Encuentra la diferencia absoluta entre dos números

utilizar Math.abs() Para encontrar la diferencia absoluta entre dos números dados:

const difference = (a, b) => Math.abs(a-b);

console.log(difference(3, 5)); // 2
console.log(difference(5, 3)); // 2

Techo matemático

los Math.ceil(x) La función se usa para redondear el número dado hacia el techo.

x ≤ Math.ceil(x) ≤ x+1
Math.ceil(0.95);    // 1
Math.ceil(45.95);   // 46
Math.ceil(45.05);   // 46
Math.ceil(-0.95);   // -0
Math.ceil(-45.05);  // -45 
Math.ceil(-45.95);  // -45

Math.ceil(null);    // 0

piso de matematicas

los Math.floor(x) La función se utiliza para redondear el número dado hacia el suelo significa hacia abajo.

x-1 ≤ Math.floor(x) ≤ x
Math.floor(0.95);    // 0
Math.floor(45.95);   // 45
Math.floor(45.05);   // 45
Math.floor(-0.95);   // -1
Math.floor(-45.05);  // -46 
Math.floor(-45.95);  // -46

Math.floor(null);    // 0

Obtener una parte fraccionaria de un número

Vamos a crear un método fraction para obtener una parte fraccionaria del número usando Math.floor() y Math.abs() las funciones:

const fraction = (x) => Math.abs(x) - Math.floor(Math.abs(x));

fraction(45.95);   // 0.95
fraction(45.05);   // 0.05
fraction(-45.95);  // 0.95
fraction(-45.05);  // 0.05

Obtener el cociente y el resto de una división de dos enteros

los Math.floor() y % se puede usar para encontrar el cociente y el resto de una división de dos números enteros respectivamente:

var dividend = 14;
var divisor = 3;

console.log("quotient", Math.floor(dividend/divisor));
console.log("remainder", dividend % divisor);
// quotient 4
// remainder 2

torre de matemáticas

los Math.round(x) La función se usa para redondear el número dado al entero más cercano en cualquier dirección, hacia arriba o hacia abajo.

console.log(Math.round(0.9));
// 1

console.log(Math.round(5.95), Math.round(5.5), Math.round(5.05));
// 6 6 5

console.log(Math.round(-5.05), Math.round(-5.5), Math.round(-5.95));
// -5 -5 -6

baúl de matemáticas

los Math.trunc(x) La función devuelve la parte entera de un número eliminando la parte fraccionaria.

Math.trunc(0.123);   // 0
Math.trunc(12.34);   // 12
Math.trunc(-0.123);  // -0
Math.trunc(-12.34);  // -12
Math.trunc('foo');   // NaN

Note que Math.trunc(x) no aplica ninguna lógica de redondeo y simplemente trunca el punto y la parte decimal del número.

Crear nuestro propio método de truncamiento

Creamos el nuestro truncate métodos usando Math.ceil() y Math.floor() las funciones:

const truncate = (x) => x < 0 ? Math.ceil(x) : Math.floor(x);

truncate(0.123);   // 0
truncate(12.34);   // 12
truncate(-0.123);  // -0
truncate(-12.34);  // -12
truncate('foo');   // NaN

Funciones matemáticas restantes

Hemos cubierto en detalle la mayoría de las funciones de objetos matemáticos de uso frecuente en JavaScript. Aquí está la lista de funciones matemáticas restantes que pueden ser necesarias en cálculos matemáticos complejos.

Método La descripcion
acos(x) Devuelve el arcocoseno de x, en radianes
acosh(x) Devuelve el arcocoseno hiperbólico de x
asen(x) Devuelve el arcoseno de x, en radianes
asinh(x) Devuelve el arcoseno hiperbólico de x
atán(x) Devuelve la arcotangente de x como un valor numérico entre -PI/2 y PI/2 radianes
atán2(y, x) Devuelve el arcotangente del cociente de sus argumentos
atanh(x) Devuelve la arcotangente hiperbólica de x
cbrt(x) Devuelve la raíz cúbica de x
porque(x) Devuelve el coseno de x (x está en radianes)
garrapata(s) Devuelve el coseno hiperbólico de x
exp(x) Devuelve el valor de eXdonde e es el número de Euler
exp1(x) Devuelve el valor de (eX-1), donde e es el número de Euler
registro (x) Devuelve el logaritmo natural (base e) de x
pecado(s) Devuelve el seno de x (x está en radianes)
sen(x) Devuelve el seno hiperbólico de x
bronceado Devuelve la tangente de un ángulo.
tanh(x) Devuelve la tangente hiperbólica de un número

Si quieres conocer otros artículos parecidos a Constantes matemáticas y funciones en JavaScript puedes visitar la categoría Tutoriales.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Subir

Esta página web utiliza cookies para analizar de forma anónima y estadística el uso que haces de la web, mejorar los contenidos y tu experiencia de navegación. Para más información accede a la Política de Cookies . Ver mas