review-javascript-math
Voltar à Trilha

Revisão de Math do JavaScript

Trabalhando com o Tipo de Dados Number

  • Definição: O tipo Number do JavaScript inclui inteiros, números de ponto flutuante, Infinity e NaN. Números de ponto flutuante são números com ponto decimal. Infinity positivo é um número maior que qualquer outro número enquanto -Infinity é um número menor que qualquer outro número. NaN (Not a Number) representa um valor numérico inválido como a string "Jessica".

Operações Aritméticas Comuns

  • Operador de Adição: Este operador (+) é usado para calcular a soma de dois ou mais números.
  • Operador de Subtração: Este operador (-) é usado para calcular a diferença entre dois números.
  • Operador de Multiplicação: Este operador (*) é usado para calcular o produto de dois ou mais números.
  • Operador de Divisão: Este operador (/) é usado para calcular o quociente entre dois números
  • Divisão Por Zero: Se você tentar dividir por zero, o JavaScript retornará Infinity.
  • Operador de Resto: Este operador(%) retorna o resto de uma divisão.
  • Operador de Exponenciação: Este operador (**) eleva um número à potência de outro.

Cálculos com Números e Strings

  • Explicação: Quando você usa o operador + com um número e uma string, o JavaScript irá converter o número em uma string e concatenar os dois valores. Quando você usa os operadores -, * ou / com uma string e um número, o JavaScript irá converter a string em um número e o resultado será um número. Para null e undefined, o JavaScript trata null como 0 e undefined como NaN em operações matemáticas.
const result = 5 + '10';

console.log(result); // "510"
console.log(typeof result); // string

const subtractionResult = '10' - 5;
console.log(subtractionResult); // 5
console.log(typeof subtractionResult); // number

const multiplicationResult = '10' * 2;
console.log(multiplicationResult); // 20
console.log(typeof multiplicationResult); // number

const divisionResult = '20' / 2;
console.log(divisionResult); // 10
console.log(typeof divisionResult); // number

const result1 = null + 5;
console.log(result1); // 5
console.log(typeof result1); // number

const result2 = undefined + 5;
console.log(result2); // NaN
console.log(typeof result2); // number

Precedência de Operadores

  • Definição: A precedência dos operadores determina a ordem em que as operações são avaliadas em uma expressão. Operadores com maior precedência são avaliados antes daqueles com menor precedência. Valores dentro dos parênteses serão avaliados primeiro e multiplicação/divisão terá precedência maior que adição/subtração. Se os operadores tiverem a mesma precedência, então o JavaScript usará a associatividade.
const result = (2 + 3) * 4;

console.log(result); // 20

const result2 = 10 - 2 + 3;

console.log(result2); // 11

const result3 = 2  3  2;

console.log(result3); // 512
  • Definição: Associatividade nos informa a direção na qual uma expressão é avaliada quando múltiplos operadores do mesmo tipo existem. Ela define se a expressão deve ser avaliada da esquerda para a direita (left-associative) ou da direita para a esquerda (right-associative). Por exemplo, o operador de exponenciação também é associativo da direita para a esquerda:
const result4 = 5  4  1; 

console.log(result4); // 625

Operadores de Incremento e Decremento

  • Operador de Incremento: Este operador é usado para aumentar o valor em um. A notação prefixa ++num aumenta o valor da variável primeiro, depois retorna um novo valor. A notação pós-fixa num++ retorna o valor atual da variável primeiro, depois o aumenta.
let x = 5;

console.log(++x); // 6
console.log(x); // 6


let y = 5;

console.log(y++); // 5
console.log(y); // 6
  • Operador de Decremento: Este operador é usado para diminuir o valor em um. A notação prefixa e a notação pós-fixa funcionam da mesma forma que anteriormente com o operador de incremento.
let num = 5;

console.log(--num); // 4
console.log(num--); // 4
console.log(num); // 3

Operadores de Atribuição Composta

  • Operador de Atribuição de Adição (+=): Este operador realiza a adição dos valores e atribui o resultado à variável.
  • Operador de Atribuição de Subtração (-=): Este operador realiza a subtração dos valores e atribui o resultado à variável.
  • Operador de Atribuição de Multiplicação (*=): Este operador realiza a multiplicação dos valores e atribui o resultado à variável.
  • Operador de Atribuição de Divisão (/=): Este operador realiza a divisão dos valores e atribui o resultado à variável.
  • Operador de Atribuição de Resto (%=): Este operador divide uma variável pelo número especificado e atribui o resto à variável.
  • Operador de Atribuição de Exponenciação (=)**: Este operador eleva uma variável à potência do número especificado e reatribui o resultado à variável.

Booleanos e Igualdade

  • Definição de Booleano: Um booleano é um tipo de dado que pode ter apenas dois valores: true ou false.
  • Operador de Igualdade (==): Este operador usa coerção de tipo antes de verificar se os valores são iguais.
console.log(5 == '5'); // true
  • Operador de Igualdade Estrita (===): Este operador não realiza coerção de tipo e verifica se tanto os tipos quanto os valores são iguais.
console.log(5 === '5'); // false
  • Operador de Desigualdade (!=): Este operador usa coerção de tipo antes de verificar se os valores não são iguais.
  • Operador de Desigualdade Estrita (!==): Este operador não realiza coerção de tipo e verifica se tanto os tipos quanto os valores não são iguais.

Operadores de Comparação

  • Operador Maior Que (>): Este operador verifica se o valor à esquerda é maior que o da direita.
  • Operador Maior Ou Igual (>=): Este operador verifica se o valor à esquerda é maior ou igual ao da direita.
  • Operador Menor Que (<): Este operador verifica se o valor à esquerda é menor que o da direita.
  • Operador Menor Que (<=) ou Igual: Este operador verifica se o valor à esquerda é menor ou igual ao da direita.

Operadores Unários

  • Operador Unário Plus: Este operador converte seu operando em um número. Se o operando já for um número, ele permanece inalterado.
const str = '42';
const num = +str;

console.log(num); // 42
console.log(typeof num); // number
  • Operador de Negação Unária (-): Este operador nega o operando.
const num = 4;
console.log(-num); // -4
  • Operador lógico NOT (!): Este operador inverte o valor booleano do seu operando. Então, se o operando for true, ele se torna false e, se for false, ele se torna true.

Operadores Bit a Bit

  • Operador Bitwise AND (&): Este operador retorna 1 em cada posição de bit para a qual os bits correspondentes de ambos os operandos são 1.
  • Operador de Atribuição Bit a Bit E (&=): Este operador realiza uma operação de bitwise AND com o número especificado e reatribui o resultado à variável.
  • Operador OR bit a bit (|): Este operador retorna 1 em cada posição de bit para a qual os bits correspondentes de um ou ambos os operandos são 1.
  • Operador de Atribuição OR Bit a Bit (|=): Este operador realiza uma operação de bitwise OR com o número especificado e reatribui o resultado à variável.
  • Operador XOR bit a bit (^): Este operador retorna 1 em cada posição de bit para a qual os bits correspondentes de um dos operandos, mas não de ambos, são 1.
  • Operador Bitwise NOT (~): Este operador inverte a representação binária de um número.
  • Operador de Deslocamento à Esquerda (<<): Este operador desloca todos os bits para a esquerda por um número especificado de posições.
  • Operador de Deslocamento para Direita (>>): Este operador desloca todos os bits para a direita.

Instruções Condicionais, Valores Truthy, Valores Falsy e o Operador Ternário

  • if/else if/else: Uma declaração if recebe uma condição e executa um bloco de código se essa condição for truthy. Se a condição for false, então ela passa para o bloco else if. Se nenhuma dessas condições for true, então ela executará a cláusula else. Valores truthy são quaisquer valores que resultam em true quando avaliados em um contexto Booleano como uma declaração if. Valores falsy são valores que avaliam para false em um contexto Booleano.
const score = 87;

if (score >= 90) {
 console.log('You got an A'); 
} else if (score >= 80) {
 console.log('You got a B'); // You got a B
} else if (score >= 70) {
 console.log('You got a C');
} else {
 console.log('You failed! You need to study more!');
}
  • Operador Ternário: Este operador é frequentemente usado como uma forma mais curta de escrever declarações if else.
const temperature = 30;
const weather = temperature > 25 ? 'sunny' : 'cool';

console.log(It's a ${weather} day!); // It's a sunny day!

Operadores Lógicos Binários

  • Operador Logical AND (&&): Este operador verifica se ambos os operandos são true. Se ambos forem true, então ele retornará o segundo valor. Se qualquer operando for falsy, então ele retornará o valor falsy. Se ambos os operandos forem falsy, ele retornará o primeiro valor falsy.
const result = true && 'hello';

console.log(result); // hello
  • Operador OR Lógico (||): Este operador verifica se pelo menos um dos operandos é truthy.
  • Operador de Coalescência Nula (??): Este operador retornará um valor somente se o primeiro for null ou undefined.
const userSettings = {
 theme: null,
 volume: 0,
 notifications: false,
};

let theme = userSettings.theme ?? 'light';
console.log(theme); // light

O Objeto Math

  • O Método Math.random(): Este método gera um número de ponto flutuante aleatório entre 0 (inclusivo) e 1 (exclusivo). Isso significa que a saída possível pode ser 0, mas nunca alcançará 1.
  • O Método Math.max(): Este método recebe um conjunto de números e retorna o valor máximo.
  • O Método Math.min(): Este método recebe um conjunto de números e retorna o valor mínimo.
  • O Método Math.ceil(): Este método arredonda um valor para cima até o inteiro mais próximo.
  • O Método Math.floor(): Este método arredonda um valor para baixo até o inteiro mais próximo.
  • O Método Math.round(): Este método arredonda um valor para o inteiro mais próximo.
console.log(Math.round(2.3)); // 2
console.log(Math.round(4.5)); // 5
console.log(Math.round(4.8)); // 5
  • O Método Math.trunc(): Este método remove a parte decimal de um número, retornando apenas a porção inteira, sem arredondamento.
  • O Método Math.sqrt(): Este método retornará a raiz quadrada de um número.
  • O Método Math.cbrt(): Este método retornará a raiz cúbica de um número.
  • O Método Math.abs(): Este método retornará o valor absoluto de um número.
  • O Método Math.pow(): Este método recebe dois números e eleva o primeiro à potência do segundo.

Métodos Numéricos Comuns

  • isNaN(): NaN significa "Not-a-Number". É um valor especial que representa um resultado numérico não representável ou indefinido. A propriedade da função isNaN() é usada para determinar se um valor é NaN ou não. Number.isNaN() fornece uma maneira mais confiável de verificar valores NaN, especialmente em casos onde a coerção de tipo pode levar a resultados inesperados com a função global isNaN().
console.log(isNaN(NaN));       // true
console.log(isNaN(undefined)); // true
console.log(isNaN({}));        // true

console.log(isNaN(true));      // false
console.log(isNaN(null));      // false
console.log(isNaN(37));        // false


console.log(Number.isNaN(NaN));        // true
console.log(Number.isNaN(Number.NaN)); // true
console.log(Number.isNaN(0 / 0));      // true

console.log(Number.isNaN("NaN"));      // false
console.log(Number.isNaN(undefined));  // false
  • O Método parseFloat(): Este método analisa um argumento do tipo string e retorna um número de ponto flutuante. Ele foi projetado para extrair um número do início de uma string, mesmo que a string contenha caracteres não numéricos posteriormente.
  • The parseInt() Method: This method parses a string argument and returns an integer. parseInt() stops parsing at the first non-digit it encounters. Para números de ponto flutuante, ele retorna apenas a parte inteira. Se não encontrar um inteiro válido no início da string, retorna NaN.
  • O Método toFixed(): Este método é chamado em um número e recebe um argumento opcional, que é o número de dígitos a aparecer após o ponto decimal. Ele retorna uma representação em string do número com o número especificado de casas decimais.