Math

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 🥳