JavaScript: O objeto Math

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

Math.E

Representa a constante de Euler e também a base dos logaritmos naturais.

console.log(MATH.E);
//Retonará 2.718281828459045

 

Math.LN2

Retorna o logaritmo natural de 2.

console.log(MATH.LN2);
//Retonará 0.6931471805599453

 

Math.LN10

Retorna o logaritmo natural de 10.

console.log(Math.LN10);
//retornará 2.302585092994046

 

Math.LOG2E

Retorna o logaritmo de E na base 2.

console.log(Math.LOG2E);
//Retornará 1.4426950408889634

 

 

Math.LOG10E

Retorna o logaritmo de E na base 10.

console.log(Math.LOG10E);
//Retornará 0.4342944819032518

 

Math.PI

Retorna o valor de PI.

console.log(Math.PI);
//Retornará 3.141592653589793

 

Math.SQRT1_2

Raiz quadrada de ½ (um meio ou 0,5).

console.log(Math.SQRT1_2);
//Retornará 0.7071067811865476

 

Math.SQRT2

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.

Math.abs(x)

Retorna o valor absoluto (sem sinal) do número passado.

Math.abs('-1');     // 1
Math.abs(-2);       // 2

 

Math.acos(x)

Retorna o arco-coseno de um número (arccosx).

Math.acos(-1);  // 3.141592653589793
Math.acos(0);   // 1.5707963267948966

 

Math.acosh(x) 

Retorna o arco-coseno hiperbólico de um número.

Math.acosh(1);   // 0
Math.acosh(2);   // 1.3169578969248166

 

Math.asin(x)

Retorna o arco-seno de um número (arcsinx).

Math.asin(0.5); // 0.5235987755982989
Math.asin(1);   // 1.5707963267948966

 

Math.asinh(x) 

Retorna o arco-seno hiperbólico de um número.

Math.asinh(1);  // 0.881373587019543
Math.asinh(0);  // 0

 

Math.atan(x)

Retorna o arco-tangente de um número (arctanx).

Math.atan(1);   // 0.7853981633974483
Math.atan(0);   // 0

 

Math.atanh(x) 

Retorna o arco-tangente hiperbólico de um número (arctanx).

Math.atanh(0);   // 0
Math.atanh(0.5); // 0.5493061443340548

 

Math.atan2(x, y)

Retorna o arco-tangente do quociente de seus argumentos.

Math.atan2(90, 15); // 1.4056476493802699
Math.atan2(15, 90); // 0.16514867741462683

 

Math.cbrt(x) 

Retorna a raiz cúbica de um número (x3).

Math.cbrt(0); // 0
Math.cbrt(2); // 1.2599210498948734

 

Math.ceil(x)

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

 

Math.cos(x)

Retorna o coseno de um número (cosx).

Math.cos(0);           // 1
Math.cos(1);           // 0.5403023058681398

 

Math.cosh(x) 

Retorna o coseno hiperbólico de um número .

Math.cosh(0);  // 1
Math.cosh(1);  // 1.5430806348152437

 

Math.exp(x)

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

 

Math.expm1(x) 

Retorna e^x-1.

Math.expm1(-1); // -0.6321205588285577 
Math.expm1(1);  // 1.718281828459045

 

Math.floor(x)

Retorna o maior inteiro que é menor ou igual a um número.

Math.floor( 55.05); //  55
Math.floor(-55.05); // -56

 

Math.fround(x) 

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

 

Math.hypot([x[,y[,…]]]) 

Retorna a raiz quadrada da soma dos quadrados dos argumentos (x2+y2+…).

Math.hypot(3, 4);        // 5
Math.hypot(3, 4, 5);     // 7.0710678118654755

 

Math.imul(x) 

Retorna o resultado de uma multiplicação de inteiro de 32-bit.

Math.imul(2, 4);          // 8
Math.imul(-1, 8);         // -8

 

Math.log(x)

Retorna o logaritmo natural (logex ou lnx) de um número.

Math.log(1);  // 0
Math.log(10); // 2.302585092994046

 

Math.log1p(x) 

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

 

Math.log10(x) 

Retorna o logaritmo de x na base 10 (log10x).

Math.log10(1);      // 0
Math.log10(100000); // 5

 

Math.log2(x) 

Retorna o logaritmo de x na base 2 (log2x).

Math.log2(2);    // 1
Math.log2(1024); // 10

 

Math.max([x[,y[,…]]])

Retorna o maior dentre os parâmetros recebidos.

Math.max(10, 20);   //  20
Math.max(-10, -20); // -10
Math.max(-10, 20);  //  20

 

Math.min([x[,y[,…]]])

Retorna o menor dentre os parâmetros recebidos.

Math.max(10, 20);   //  10
Math.max(-10, -20); // -20
Math.max(-10, 20);  // -10

 

Math.pow(x,y)

Retorna a base x elevada à potência y do expoente, ou seja, xy.

Math.pow(7, 2);    // 49
Math.pow(7, 3);    // 343

 

Math.random()

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

 

Math.round(x)

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

 

Math.sign(x) 

Retorna o sinal de x, indicando se é positivo, negativo ou zero.

Math.sign(3);     //  1
Math.sign(-3);    // -1

 

Math.sin(x)

Retorna o seno de um número (sinx).

Math.sin(0);           // 0
Math.sin(1);           // 0.8414709848078965

 

Math.sinh(x) 

Retorna o seno hiperbólico de um número (sinhx).

Math.sinh(0); // 0
Math.sinh(1); // 1.1752011936438014

 

Math.sqrt(x)

Retorna a raiz quadrada positiva de um número (x).

Math.sqrt(9); // 3
Math.sqrt(2); // 1.414213562373095
Math.sqrt(1);  // 1

 

Math.tan(x)

Retorna a tangente de um número (tanx).

Math.tan(1); // 1.5574077246549023
Math.tan(0.6); //0.6841368083416923

 

 

Math.trunc(x) 

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:

w3schools

MDN – web docs

reddit – what’s the best JS math library in terms of performance?

Java vs Javascript: Speed of Math

Deixe um comentário