Curso IT Fundamentos JavaScript 040_Operadores

Operadores JavaScript são usados para realizar operações matemáticas, comparações, operações lógicas, etc., e retornar resultados.

Operadores Aritméticos

• +: Adição
• -: Subtração
• *: Multiplicação
• /: Divisão
• %: Resto (módulo)
• **: Exponenciação

Exemplo:

1
let a = 5;
2
let b = 2;
3

4
console.log(a + b);  // Saída 7
5
console.log(a - b);  // Saída 3
6
console.log(a * b);  // Saída 10
7
console.log(a / b);  // Saída 2.5
8
console.log(a % b);  // Saída 1
9
console.log(a**b);  // Saída 25

Operadores de Atribuição

• =: Atribuição
• +=: Atribuição de adição
• -=: Atribuição de subtração
• *=: Atribuição de multiplicação
• /=: Atribuição de divisão
• %=: Atribuição de resto
• **=: Atribuição de exponenciação
• ??=: Atribuição nula, atribui apenas quando o valor da variável é null ou undefined

Exemplo:

1
let x = 5;
2
x += 2;  // x = x + 2; Saída 7
3
x -= 2;  // x = x - 2; Saída 3
4
x *= 2;  // x = x * 2; Saída 10
5
x /= 2;  // x = x / 2; Saída 2.5
6
x %= 2;  // x = x % 2; Saída 1
7
x **= 2;  // x = x ** 2; Saída 25
8
x ??= 2;  // Saída 5, quando x é null ou undefined atribui 2
9
console.log(x);

Operadores de Comparação

• ==: Igualdade (o tipo de valor é convertido automaticamente)
• ===: Igualdade estrita (valor e tipo devem ser iguais)
• !=: Desigualdade
• !==: Desigualdade estrita
• >: Maior que
• <: Menor que
• >=: Maior ou igual
• <=: Menor ou igual

Ao encontrar valores não numéricos, primeiro converte para número e depois compara. Ao encontrar strings, compara o código Unicode dos caracteres posição por posição.

Exemplo:

1
let a = 5;
2
let b = '5';
3
let c = 10;
4

5
console.log(a == b);   // Saída true, valores são iguais
6
console.log(a === b);  // Saída false, tipos são diferentes
7
console.log(a != b);   // Saída false, valores são iguais
8
console.log(a !== b);  // Saída true, tipos são diferentes
9
console.log(a > c);  // Saída false, 5 < 10
10
console.log(a < c);  // Saída true, 5 < 10
11
console.log(a >= c);  // Saída false, 5 <= 10
12
console.log(a <= c);  // Saída true, 5 <= 10

Operadores Lógicos

Operadores lógicos ao processar operandos convertem-nos em valores booleanos e retornam o valor original do operando.

&&: E lógico (AND)

Usado para verificar se todas as condições são true. Se todas as condições forem true, o resultado da expressão inteira é true; caso contrário, o resultado é false. A operação AND procura o primeiro false da esquerda para a direita sequencialmente. Se encontrar false, para o cálculo e retorna o valor original deste operando (avaliação de curto-circuito). Se não houver false, retorna o último true.

||: OU lógico (OR)

Usado para verificar se pelo menos uma condição é true. Se pelo menos uma condição for true, o resultado da expressão inteira é true; se todas as condições forem false, o resultado é false. A operação OR procura o primeiro true da esquerda para a direita sequencialmente. Se encontrar true, para o cálculo e retorna o valor original deste operando (avaliação de curto-circuito). Se não houver true, retorna o último false.

!: NÃO lógico (NOT)

Usado para inverter um valor booleano. Se um valor for true, usando o operador NOT lógico, ele é invertido para false; se um valor for false, é invertido para true. O NOT lógico também pode ser usado para converter valores não booleanos em valores booleanos. Ele converterá qualquer valor que não seja null, undefined, 0, NaN, "" (string vazia) em true, enquanto os valores mencionados acima são todos convertidos em false.

Exemplo:

1
let a = true;
2
let b = false;
3
let c = "hello";
4
let d = null;
5

6
console.log(a && b);  // Saída false
7
console.log(c && d);  // Saída null
8
console.log(a || b);  // Saída true
9
console.log(c || d);  // Saída hello
10
console.log(!a);      // Saída false
11
console.log(!d);      // Saída true

Operador Ternário

• condition ? expr1 : expr2: Se a condição for verdadeira, retorna expr1, caso contrário, retorna expr2.

Exemplo:

1
let age = 18;
2
let status = (age >= 18) ? 'Adulto' : 'Menor';
3
console.log(status);  // Saída 'Adulto'

Operador de Coalescência Nula

O operador de coalescência nula (Nullish Coalescing Operator) é usado para processar valores padrão, normalmente usado para garantir que uma variável tenha um valor não nulo (não null e não undefined). A sintaxe deste operador é ??.

Ao usar o operador de coalescência nula, ele retorna o primeiro operando definido (não null e não undefined). Se o primeiro operando for null ou undefined, retorna o segundo operando.

Exemplo:

1
let num1 = 0;
2
let num2 = 1;
3
let result = num1 ?? num2;
4
console.log(result);  // Saída 0, porque num não é null ou undefined
5

6
let user;
7
console.log(user ?? "Anônimo"); // Saída Anônimo, porque user não está definido

Operadores Bit a Bit

• &: AND bit a bit
• |: OR bit a bit
• ^: XOR bit a bit
• ~: NOT bit a bit
• <<: Deslocamento à esquerda
• >>: Deslocamento à direita
• >>>: Deslocamento à direita sem sinal

Exemplo:

1
let a = 5;  // Binário: 0101
2
let b = 3;  // Binário: 0011
3

4
console.log(a & b);   // Saída 1 (AND bit a bit)
5
console.log(a | b);   // Saída 7 (OR bit a bit)
6
console.log(a ^ b);   // Saída 6 (XOR bit a bit)
7
console.log(~a);      // Saída -6 (NOT bit a bit)
8
console.log(a << 1);  // Saída 10 (Deslocamento à esquerda)
9
console.log(a >> 1);  // Saída 2 (Deslocamento à direita)

Outros Operadores

• typeof: Retorna uma string que indica o tipo do operando não avaliado.
• instanceof: Usado para testar se um objeto é uma instância do tipo especificado.

Exemplo:

1
let str = 'Hello';
2
console.log(typeof str);  // Saída 'string'
3

4
let arr = [1, 2, 3];
5
console.log(arr instanceof Array);  // Saída true

+ (Adição)

Em JavaScript, o sinal de adição + tem múltiplas finalidades, incluindo operações matemáticas, concatenação de strings e operações unárias.

Operação Matemática

Exemplo:

1
let a = 5;
2
let b = 3;
3
let result = a + b;
4
console.log(result);  // Saída 8

Se ambos forem números, + é usado para realizar adição matemática.

Concatenação de Strings

Exemplo:

1
let str1 = 'Hello';
2
let str2 = ' World';
3
let result = str1 + str2;
4
console.log(result);  // Saída 'Hello World'

Se um dos operandos for uma string, + executará concatenação de strings.

Operador Unário de Adição

Exemplo:

1
let str = '42';
2
let num = +str;
3
console.log(num);  // Saída 42

Ao usar + antes de um único operando, ele pode converter o operando em número, esta é a função do operador unário de adição.

Conversão de Tipo

Exemplo:

1
let num = 42;
2
let str = '10';
3
let result = num + str;  // Conversão de tipo implícita (coerção de tipo)
4
console.log(result);  // Saída '4210'

Se um dos operandos for uma string, + realizará conversão de tipo, convertendo outros operandos em string e depois executará concatenação de strings.

Conexão de Arrays

Exemplo:

1
let arr1 = [1, 2, 3];
2
let arr2 = [4, 5, 6];
3
let result = arr1 + arr2;
4
console.log(result);  // Saída '1,2,34,5,6'

Quando um operando é um array, + converterá o array em string e depois executará concatenação de strings.

Casos Especiais

Exemplo:

1
let specialResult1 = '1' + 2 + 3;
2
console.log(specialResult1);  // Saída '123'
3

4
let specialResult2 =  2 + 3 + '1';
5
console.log(specialResult2);  // Saída '51'

specialResult1, porque a string aparece no lado esquerdo de +, os números subsequentes serão concatenados como strings. specialResult2, porque a string aparece no lado direito de +, os números anteriores primeiro realizarão operação matemática e depois serão concatenados.

- (Subtração)

Em JavaScript, o sinal de subtração - é um operador usado para realizar subtração matemática.

Subtração Matemática

Exemplo:

1
let a = 5;
2
let b = 3;
3
let result = a - b;
4
console.log(result);  // Saída 2

Se ambos forem números, - é usado para realizar subtração matemática.

Operador Unário de Subtração

Exemplo:

1
let num = 42;
2
let result = -num;
3
console.log(result);  // Saída -42

Ao usar - antes de um único operando, ele pode executar operação unária de subtração, transformando o operando em seu oposto.

Conversão de Tipo

Exemplo:

1
let num1 = 42;
2
let str = '10';
3
let result = num1 - str;
4
console.log(result);  // Saída 32

Se um dos operandos for uma string, - realizará conversão de tipo, convertendo outros operandos em número e depois executará subtração matemática.

Casos Especiais

Exemplo:

1
let specialResult = '10' - 2;
2
console.log(specialResult);  // Saída 8

Neste caso especial, como o conteúdo da string pode ser convertido com sucesso em número, - executará subtração matemática.

=、==、=== (Atribuição, Igualdade Frouxa, Igualdade Estrita)

Em JavaScript, o sinal de igual = é um operador de atribuição, enquanto == e === são operadores de comparação. A igualdade frouxa converterá dois operandos para o mesmo tipo e depois realizará a comparação. Em julgamentos condicionais, geralmente usa-se === para comparação de igualdade estrita, pois não realiza conversão de tipo.

Operador de Atribuição

= é usado para atribuir o valor do lado direito à variável do lado esquerdo.

Exemplo:

1
let x = 5;
2
let y = 'Hello';
3
console.log(x);  // Saída 5
4
console.log(y);  // Saída 'Hello'

Neste exemplo, = atribui o valor do lado direito às variáveis x e y do lado esquerdo.

Operador de Comparação

== e === são usados para comparar a igualdade de dois valores.

Exemplo:

1
let a = 5;
2
let b = '5';
3

4
console.log(a == b);   // Saída true
5
console.log(a === b);  // Saída false

== ao realizar comparação de igualdade, realiza conversão de tipo, null == undefined resulta em true. === ao realizar comparação de igualdade, requer que valor e tipo sejam iguais, null === undefined resulta em false. NaN não é igual a nenhum valor, incluindo o próprio NaN.

++、-- (Incremento, Decremento)

Em JavaScript, incremento (++) e decremento (--) são operadores usados para aumentar ou diminuir o valor de uma variável.

Operador de Incremento (++)

Após o uso, a variável original imediatamente aumenta 1. Pré-incremento retorna o valor após incremento (novo valor); Pós-incremento retorna o valor antes do incremento (valor antigo);

Exemplo de pré-incremento:

1
let a = 5;
2
// Pré-incremento, primeiro aumenta 1, depois usa o novo valor
3
let b = ++a;
4
console.log(b);  // Saída 6
5
console.log(a);  // Saída 6

Neste exemplo, a primeiro aumenta 1, depois b obtém o novo valor de a (6).

Exemplo de pós-incremento:

1
let x = 5;
2
// Pós-incremento, primeiro usa o valor atual, depois aumenta 1
3
let y = x++;
4
console.log(y);  // Saída 5
5
console.log(x);  // Saída 6

Neste exemplo, y primeiro obtém o valor atual de x (5), depois o valor de x aumenta 1.

Operador de Decremento (—)

Após o uso, a variável original imediatamente diminui 1. Pré-decremento retorna o valor após decremento (novo valor); Pós-decremento retorna o valor antes do decremento (valor antigo);

Exemplo de pré-decremento:

1
let p = 10;
2
// Pré-decremento, primeiro diminui 1, depois usa o novo valor
3
let q = --p;
4
console.log(q);  // Saída 9
5
console.log(p);  // Saída 9

Neste exemplo, p primeiro diminui 1, depois q obtém o novo valor de p (9).

Exemplo de pós-decremento:

1
let m = 8;
2
// Pós-decremento, primeiro usa o valor atual, depois diminui 1
3
let n = m--;
4
console.log(n);  // Saída 8
5
console.log(m);  // Saída 7

Neste exemplo, n primeiro obtém o valor atual de m (8), depois o valor de m diminui 1.

Precedência de Operadores:

https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Operators/Operator_precedence