Introdução
O objetivo deste post é fornecer um resumo da classe Math do JavaScript, que é extremamente útil mas parece não ser muito usada. Pelo que pesquisei, a performance da maioria dos métodos é muito boa, mesmo sendo uma linguagem script e executada pelo navegador pois o JavaScript passou por muitas melhorias nos últimos anos.
O Que e o Math no JavaScript?
Math é um objeto que acompanha o JavaScript puro. Ele é utilizado para realizar operações matemáticas, tais como: operações aritméticas, funções trigonométricas, funções de arredondamento e comparações.
É importante saber que o objeto Math não é um construtor e todas as suas propriedades e métodos são estáticos. Você pode referenciar a constante PI como MATH.PI e você pode chamar a função de seno como MATH.SIN(X) onde X é o argumento do método. Constantes são definidas com a precisão total de números reais em JavaScript.
Propriedades de Math
Representa a constante de Euler e também a base dos logaritmos naturais.
console.log(MATH.E); //Retonará 2.718281828459045
Retorna o logaritmo natural de 2.
console.log(MATH.LN2); //Retonará 0.6931471805599453
Retorna o logaritmo natural de 10.
console.log(Math.LN10); //retornará 2.302585092994046
Retorna o logaritmo de E na base 2.
console.log(Math.LOG2E); //Retornará 1.4426950408889634
Retorna o logaritmo de E na base 10.
console.log(Math.LOG10E); //Retornará 0.4342944819032518
Retorna o valor de PI.
console.log(Math.PI); //Retornará 3.141592653589793
Raiz quadrada de ½ (um meio ou 0,5).
console.log(Math.SQRT1_2); //Retornará 0.7071067811865476
Raiz quadrada de 2.
console.log(Math.SQRT2); //Retornará 1.4142135623730951
Métodos de Math
Os métodos fornecidos pelo objeto Math permitem que os cálculos mais comuns sejam executados de forma simples e rápida. Note que as funções trigonométricas (sin(), cos(), tan(), asin(), acos(), atan(), atan2()) recebem ou retornam ângulos em radianos. Para obter o valor em graus, você precisará dividir por Math.PI/180.
Retorna o valor absoluto (sem sinal) do número passado.
Math.abs('-1'); // 1
Math.abs(-2); // 2
Retorna o arco-coseno de um número (arccosx).
Math.acos(-1); // 3.141592653589793 Math.acos(0); // 1.5707963267948966
Retorna o arco-coseno hiperbólico de um número.
Math.acosh(1); // 0 Math.acosh(2); // 1.3169578969248166
Retorna o arco-seno de um número (arcsinx).
Math.asin(0.5); // 0.5235987755982989 Math.asin(1); // 1.5707963267948966
Retorna o arco-seno hiperbólico de um número.
Math.asinh(1); // 0.881373587019543 Math.asinh(0); // 0
Retorna o arco-tangente de um número (arctanx).
Math.atan(1); // 0.7853981633974483 Math.atan(0); // 0
Retorna o arco-tangente hiperbólico de um número (arctanx).
Math.atanh(0); // 0 Math.atanh(0.5); // 0.5493061443340548
Retorna o arco-tangente do quociente de seus argumentos.
Math.atan2(90, 15); // 1.4056476493802699 Math.atan2(15, 90); // 0.16514867741462683
Retorna a raiz cúbica de um número (x3).
Math.cbrt(0); // 0 Math.cbrt(2); // 1.2599210498948734
Retorna o menor inteiro que é maior ou igual a um número.
Math.ceil(.95); // 1 Math.ceil(4); // 4 Math.ceil(7.004) // 8
Retorna o coseno de um número (cosx).
Math.cos(0); // 1 Math.cos(1); // 0.5403023058681398
Retorna o coseno hiperbólico de um número .
Math.cosh(0); // 1 Math.cosh(1); // 1.5430806348152437
Retorna ex, onde x é o argumento, e e é a constante de Euler (2.718…), a base do logaritmo natural.
Math.exp(-1); // 0.36787944117144233 Math.exp(0); // 1
Retorna e^x-1.
Math.expm1(-1); // -0.6321205588285577 Math.expm1(1); // 1.718281828459045
Retorna o maior inteiro que é menor ou igual a um número.
Math.floor( 55.05); // 55 Math.floor(-55.05); // -56
Retorna a mais próxima representação de ponto flutuante de precisão-única de um número.
//O Número 1,5 pode ser representado precisamente pelo sistema numerico binário, portanto é identico em 32-bits e 64-bits Math.fround(1.5); // 1.5 Math.fround(1.5) === 1.5; // true //O Número 1,337 não pode ser presentado precisamente dessa forma e portanto, será diferente entre os formatos. Math.fround(1.337); // 1.3370000123977661 Math.fround(1.337) === 1.337; // false
Retorna a raiz quadrada da soma dos quadrados dos argumentos (x2+y2+…).
Math.hypot(3, 4); // 5 Math.hypot(3, 4, 5); // 7.0710678118654755
Retorna o resultado de uma multiplicação de inteiro de 32-bit.
Math.imul(2, 4); // 8 Math.imul(-1, 8); // -8
Retorna o logaritmo natural (logex ou lnx) de um número.
Math.log(1); // 0 Math.log(10); // 2.302585092994046
Retorna o logaritmo natural de 1 + x (loge(1+x) ou ln(1+x)) de um número.
Math.log1p(0); // 0 Math.log1p(-1); // -Infinity
Retorna o logaritmo de x na base 10 (log10x).
Math.log10(1); // 0 Math.log10(100000); // 5
Retorna o logaritmo de x na base 2 (log2x).
Math.log2(2); // 1 Math.log2(1024); // 10
Retorna o maior dentre os parâmetros recebidos.
Math.max(10, 20); // 20 Math.max(-10, -20); // -10 Math.max(-10, 20); // 20
Retorna o menor dentre os parâmetros recebidos.
Math.max(10, 20); // 10 Math.max(-10, -20); // -20 Math.max(-10, 20); // -10
Retorna a base x elevada à potência y do expoente, ou seja, xy.
Math.pow(7, 2); // 49 Math.pow(7, 3); // 343
Retorna um número pseudo-aleatório entre 0 e 1.
Math.random(); //0.8854927964642019 Math.random(); //0.24677687802268955 Math.random(); //0.1632699093589356 //... e assim por diante
Retorna o valor arrendodado de x, para o valor inteiro mais próximo.
round(3456.3456, 3); // 3456.346 round(3456.3456, 2); // 3456.35
Retorna o sinal de x, indicando se é positivo, negativo ou zero.
Math.sign(3); // 1 Math.sign(-3); // -1
Retorna o seno de um número (sinx).
Math.sin(0); // 0 Math.sin(1); // 0.8414709848078965
Retorna o seno hiperbólico de um número (sinhx).
Math.sinh(0); // 0 Math.sinh(1); // 1.1752011936438014
Retorna a raiz quadrada positiva de um número (x).
Math.sqrt(9); // 3 Math.sqrt(2); // 1.414213562373095 Math.sqrt(1); // 1
Retorna a tangente de um número (tanx).
Math.tan(1); // 1.5574077246549023 Math.tan(0.6); //0.6841368083416923
Retorna a parte inteira de x, removendo quaisquer dígitos fracionários.
Math.trunc(42.84); // 42 Math.trunc(0.123); // 0 Math.trunc(-0.123); // -0
Fonte:
reddit – what’s the best JS math library in terms of performance?