Operações Matemáticas
No universo do JS, existe uma função padrão da linguagem que ajuda os desenvolvedores a realizarem algumas operações matemáticas de maneira fácil e rápida.
Existe atualmente duas formas de se fazer operações matemáticas no JS, a primeira delas envolve a escrita de números com diversos operadores aritméticos, ou seja, é como calcular na mão.
const resultado = (1 + 4) * 44 / ((1 + 5) * 1 -9);
A segunda forma envolve o uso dos métodos presentes na função do tipo Math().
Math.método();
O objeto Math contém propriedades e métodos estáticos que são usados para fazer operações matemáticas.
É importante ressaltar que o objeto math funciona apenas com o tipo number (número), e não com o tipo bigint, ok?
Vejamos abaixo cada um dos métodos e propriedades desse objeto.
Propriedades
O objeto math conta com uma série de propriedades que podem facilitar muito o dia a dia do desenvolvimento, vejamos:
E
A propriedade e representa o número de Euler, a base dos logaritmos naturais, e, que é aproximadamente 2,718.
console.log(Math.E);//2.718281828459045
LN10
A propriedade ln10 representa o logaritmo natural de 10, aproximadamente 2,302.
console.log(Math.LN10)//2.302585092994046
LN2
A propriedade ln2 representa o logaritmo natural de 2, aproximadamente 0,693:
console.log(Math.LN2)//0.6931471805599453
LOG10E
A propriedade log10e representa o logaritmo de base 10 de e, aproximadamente 0,434.
console.log(Math.LOG10E)//0.4342944819032518
LOG2E
A propriedade log2e representa o logaritmo de base 2 de e, aproximadamente 1,442.
console.log(Math.LOG2E)//1.4426950408889634
PI
A propriedade pi representa a razão entre a circunferência de um círculo e seu diâmetro, aproximadamente 3,14159.
console.log(Math.PI);//3.141592653589793
SQRT1_2
A propriedade sqrt1_2 representa a raiz quadrada de 1/2, que é aproximadamente 0,707.
console.log(Math.SQRT1_2);//0.7071067811865476
SQRT2
A propriedade sqrt2 representa a raiz quadrada de 2, aproximadamente 1,414.
console.log(Math.SQRT2);//1.4142135623730951
Métodos
O objeto math conta atualmente com um total de 35 métodos disponíveis para uso, cada qual com suas particularidades, vejamos cada um deles abaixo.
Abs()
O método abs() retorna o valor absoluto de um número.
Math.abs(-Infinity); // Infinity
Math.abs(-1); // 1
Math.abs(-0); // 0
Math.abs(0); // 0
Math.abs(1); // 1
Math.abs(Infinity); // Infinity
Valores positivos sempre são retornados, valores negativos são convertidos em positivos.
Acos()
O método acos() retorna o cosseno inverso (em radianos) de um número.
Math.acos(-2); // NaN
Math.acos(-1); // 3.141592653589793 (π)
Math.acos(0); // 1.5707963267948966 (π/2)
Math.acos(0.5); // 1.0471975511965979 (π/3)
Math.acos(1); // 0
Math.acos(2); // NaN
Acosh()
O método acosh() retorna o cosseno hiperbólico inverso de um número.
Math.acosh(0.999999999999);//NaN
Math.acosh(1);//1
Math.acosh(2);//1.3169578969248166
Math.acosh(2.5);//1.566799236972411
Asin()
O método asin() retorna o seno inverso (em radianos) de um número.
Math.asin(0.6);//0.6435011087932844
Math.asin(1.6);//NaN
Asinh()
O método asinh() retorna o seno hiperbólico inverso de um número.
Math.asinh(1);//0.881373587019543
Math.asinh(0);//0
Math.asinh(-1);//-0.881373587019543
Math.asinh(2);//1.4436354751788103
Atan()
O método atan() retorna a tangente inversa (em radianos) de um número.
Math.atan(8.9);//0.6747409422235527
Math.atan(1.6);//1.0303768265243125
Atan2()
O método atan2() retorna o ângulo no plano (em radianos) entre o eixo x positivo e o raio de (0, 0) ao ponto (x, y).
Math.atan2(5, 5);//45
Math.atan2(10, 10);//45
Math.atan2(0, 10);//90
Atanh()
O método atanh() retorna a tangente hiperbólica inversa de um número.
Math.atanh(-1);//-Infinity
Math.atanh(0);//0
Math.atanh(0.5);//0.549306144334055 (aproximadamente)
Math.atanh(1);//Infinity
Cbrt()
O método cbrt() retorna a raiz cúbica de um número.
Math.cbrt(-1);//-1
Math.cbrt(1);//1
Math.cbrt(Infinity);//Infinity
Math.cbrt(64);//4
Ceil()
O método ceil() sempre arredonda para cima e retorna o menor inteiro maior ou igual a um determinado número.
Math.ceil(.95);//11
Math.ceil(4);//4
Math.ceil(7.004);//8
Math.ceil(-7.004);//-7
Clz32()
O método clz32() retorna o número de bits zero à esquerda na representação binária de 32 bits de um número.
// 00000000000000000000000000000001
Math.clz32(1);//31
// 00000000000000000000000000000100
Math.clz32(4);//29
// 00000000000000000000001111101000
Math.clz32(1000);/22
Cos()
O método cos() retorna o cosseno de um número em radianos.
Math.cos(1);//0.5403023058681398
Math.cos(2);//-0.4161468365471424
Math.cos(Math.PI);//-1
Cosh()
O método cosh() retorna o cosseno hiperbólico de um número.
Math.cosh(0);//1
Math.cosh(1);//1.543080634815244 (aproximadamente)
Math.cosh(-1);//1.543080634815244 (aproximadamente)
Math.cosh(2);//3.7621956910836314
Exp()
O método exp() retorna E elevado à potência de um número.
Math.exp(0);//1
Math.exp(1);//2.718281828459 (aproximadamente)
Math.exp(-1);//0.36787944117144233
Math.exp(2);//7.38905609893065
Expm1()
O método expm1() retorna E elevado à potência de um número, subtraído por 1.
Math.expm1(0);//0
Math.expm1(1);//1.718281828459045
Math.expm1(-1);//-0.6321205588285577
Math.expm1(2);//6.38905609893065
Floor()
O método floor() sempre arredonda para baixo e retorna o maior inteiro menor ou igual a um determinado número.
Math.floor(5.95);//5
Math.floor(5.05);//5
Math.floor(5);//5
Math.floor(-5.05);//-6
Fround()
O método fround() retorna a representação flutuante de precisão única de 32 bits mais próxima de um número.
Math.fround(5.5);//5.5
Math.fround(5.05);//5.050000190734863
Math.fround(5);//5
Math.fround(-5.05);//-5.050000190734863
Hypot()
O método hypot() retorna a raiz quadrada da soma dos quadrados de seus argumentos.
Math.hypot(3, 4);//5
Math.hypot(5, 12);//13
Math.hypot(3, 4, 5);//7.0710678118654755
Math.hypot(-5);//5
Imul()
O método imul() retorna o resultado da multiplicação de 32 bits semelhante a C dos dois parâmetros.
Math.imul(3, 4);//12
Math.imul(-5, 12);//-60
Math.imul(0xffffffff, 5);//-5
Math.imul(0xfffffffe, 5);//-10
Log()
O método log() retorna o logaritmo natural (base e) de um número.
Math.log(8);//2.0794415416798357
Math.log(625);//6.437751649736401
Log10()
O método log10() retorna o logaritmo de base 10 de um número.
Math.log10(100000);//5
ath.log10(2);//0.3010299956639812
Math.log10(1);//0
Math.log10(0);//-Infinity
Log1p()
O método log1p() retorna o logaritmo natural (base e) de 1 + x, onde x é o argumento.
Math.log1p(1);//0.6931471805599453
Math.log1p(0);//0
Math.log1p(-1);//-Infinity
Math.log1p(-2);//NaN
Log2()
O método log2() retorna o logaritmo de base 2 de um número.
Math.log2(3);//1.584962500721156
Math.log2(2);//1
Math.log2(1);//0
Math.log2(0);//-Infinity
Max()
O método max() retorna o maior dos números fornecidos como parâmetros de entrada ou -Infinity se não houver parâmetros.
Math.max(1, 3, 2);//3
Math.max(-1, -3, -2);//-1
const array1 = [1, 3, 2];
Math.max(...array1);//3
Min()
O método min() retorna o menor dos números dados como parâmetros de entrada, ou Infinito se não houver parâmetros.
Math.min(2, 3, 1);//1
Math.min(-2, -3, -1);//-3
const array1 = [2, 3, 1];
Math.min(...array1);//1
Pow()
O método pow() retorna o valor de uma base elevada a uma potência.
Math.pow(7, 3);//343
Math.pow(4, 0.5);//2
Math.pow(7, -2);//0.02040816326530612
Math.pow(-7, 0.5);//NaN
Random()
O método random() retorna um número pseudo-aleatório de ponto flutuante que é maior ou igual a 0 e menor que 1, com distribuição aproximadamente uniforme nesse intervalo — que você pode dimensionar para o intervalo desejado.
A implementação seleciona a semente inicial para o algoritmo de geração de números aleatórios; não pode ser escolhido ou redefinido pelo usuário.
Math.random();//número randômico
Como gerar um número randômico de 0 a 99?
Math.floor(Math.random() * 100);
Como gerar um número randômico de 1 a 10?
Math.floor(Math.random() * 10) + 1;
Round()
O método round() retorna o valor de um número arredondado para o inteiro mais próximo.
Math.round(0.9);//1
Sign()
O método sign() retorna 1 ou -1, indicando o sinal do número passado como argumento. Se a entrada for 0 ou -0, ela será retornada como está.
Math.sign(3);//1
Math.sign(-3);//-1
Math.sign(0);//0
Math.sign('-3');//-1
Sin()
O método sin() retorna o seno de um número em radianos.
Math.sin(10);//-0.5440211108893698
Sinh()
O método sinh() retorna o seno hiperbólico de um número.
Math.sinh(0);//0
Math.sinh(1);//1.1752011936438014
Math.sinh(-1);//-1.1752011936438014
Math.sinh(2);//3.626860407847019
Sqrt()
O método sqrt() retorna a raiz quadrada de um número.
Math.sqrt(89);//9.433981132056603
Tan()
O método tan() retorna a tangente de um número em radianos.
Math.tan(12);//-0.6358599286615808
Tanh()
O método tanh() retorna a tangente hiperbólica de um número.
Math.tanh(-1);//-0.7615941559557649
Math.tanh(0);//0
Math.tanh(Infinity);//1
Math.tanh(1);//0.7615941559557649
Trunc()
O método trunc() retorna a parte inteira de um número removendo quaisquer dígitos fracionários.
Math.trunc(13.37);//13
Math.trunc(42.84);//42
Math.trunc(0.123);//0
Math.trunc(-0.123);//-0
Conclusão
Neste conteúdo aprendemos todos os métodos e propriedades do objeto Math que nos ajuda a realizar operações matemáticas.
Lembrando que nos exemplos que vimos acima, você pode usar o console.log em conjunto com cada método ou atributo, ou quem sabe fazer com que eles façam parte de uma operação matemática maior.
Te encontro na próxima jornada 🥳