Operadores no TypeScript

Operadores no TypeScript

Este artigo explica os operadores no TypeScript.

YouTube Video

Operadores no TypeScript

Os operadores no TypeScript são usados para realizar cálculos numéricos, comparações de valores e operações lógicas. Como o TypeScript utiliza operadores semelhantes aos do JavaScript, é fácil se acostumar com eles, mas o TypeScript permite operações mais rigorosas utilizando a segurança de tipos.

Os principais operadores são os seguintes:.

Operadores Aritméticos

Os operadores aritméticos são usados para cálculos numéricos.

Operador Descrição Exemplo Resultado
+ Adição 5 + 3 8
- Subtração 5 - 3 2
* Multiplicação 5 * 3 15
/ Divisão 5 / 2 2.5
% Resto 5 % 2 1
++ Incremento (prefixo) let x = 5; ++x 6
-- Decremento (prefixo) let x = 5; --x 4
 1let a = 10; // Initialize variable 'a' with the value 10
 2let b = 3;  // Initialize variable 'b' with the value 3
 3
 4// Perform and display arithmetic operations between 'a' and 'b'
 5console.log("Addition (a + b):      ", a + b); // 13
 6console.log("Subtraction (a - b):   ", a - b); // 7
 7console.log("Multiplication (a * b):", a * b); // 30
 8console.log("Division (a / b):      ", a / b); // 3.333...
 9console.log("Modulus (a % b):       ", a % b); // 1
10
11// Demonstrate post-increment operation on 'a'
12// Output the current value of 'a' (10), then increment
13console.log("Post-increment (a++):  ", a++);
14// Display the incremented value of 'a' (11)
15console.log("Value of 'a' after increment:", a);
16
17// Demonstrate pre-increment operation on 'a'
18// Increment 'a' first (12) then output
19console.log("Pre-increment (++a):   ", ++a);
20
21// Demonstrate post-decrement operation on 'a'
22// Output the current value of 'a' (12), then decrement
23console.log("Post-decrement (a--):  ", a--);
24// Display the decremented value of 'a' (11)
25console.log("Value of 'a' after decrement:", a);
26
27// Demonstrate pre-decrement operation on 'a'
28// Decrement 'a' first (10) then output
29console.log("Pre-decrement (--a):   ", --a);

Operadores de Atribuição

Os operadores de atribuição atribuem o valor à direita para a variável à esquerda.

Operador Descrição Exemplo Resultado
= Atribuição x = 10 x = 10
+= Soma e atribui x += 5 x = 15
-= Subtrai e atribui x -= 5 x = 5
*= Multiplica e atribui x *= 2 x = 20
/= Divide e atribui x /= 2 x = 5
%= Calcula resto e atribui x %= 3 x = 1
1let z = 5;
2z += 3;
3console.log(z);  // Outputs: 8
4
5z *= 2;
6console.log(z);  // Outputs: 16

Operadores de Comparação

Os operadores de comparação comparam valores e retornam true ou false.

Operador Descrição Exemplo Resultado
== Igual (sem comparação de tipo) 5 == "5" true
=== Estritamente igual (inclui tipo) 5 === "5" false
!= Diferente (sem comparação de tipo) 5 != "5" false
!== Estritamente diferente (inclui tipo) 5 !== "5" true
> Maior que 5 > 3 true
< Menor que 5 < 3 false
>= Maior ou igual a 5 >= 5 true
<= Menor ou igual a 5 <= 3 false
1console.log('5 == "5"   :', 5 == "5");   // Outputs: true
2console.log('5 === "5"  :', 5 === "5");  // Outputs: false
3console.log('5 != "5"   :', 5 != "5");   // Outputs: false
4console.log('5 !== "5"  :', 5 !== "5");  // Outputs: true
5console.log('5 > 3      :', 5 > 3);      // Outputs: true
6console.log('5 < 3      :', 5 < 3);      // Outputs: false
7console.log('5 >= 5     :', 5 >= 5);     // Outputs: true
8console.log('5 <= 3     :', 5 <= 3);     // Outputs: false

Operadores Lógicos

Os operadores lógicos são usados para combinar expressões lógicas.

Operador Descrição Exemplo Resultado
&& E Lógico true && false false
|| OU Lógico true || false true
! Negação !true false
1console.log('true && false :', true && false);  // Outputs: false
2console.log('true || false :', true || false);  // Outputs: true
3console.log('!true         :', !true);          // Outputs: false

Precedência dos Operadores Lógicos

No TypeScript, os operadores lógicos são geralmente avaliados na ordem de NOT primeiro, seguido por AND e, finalmente, OR.

NOT Tem a Maior Precedência

NOT é um operador unário e é avaliado com a maior precedência.

1console.log(!true || false);  // false
AND Tem Precedência Sobre OR

AND tem uma precedência maior que OR, então a parte do AND é avaliada primeiro.

1console.log(true || false && false);  // true

Como resultado, a parte do AND (&&) é calculada primeiro, e o seu resultado é passado para o OR (||).

AND e OR Realizam Avaliação de Curto-Circuito

No TypeScript, AND e OR realizam avaliação de curto-circuito. Se o resultado é determinado pelo valor da expressão à esquerda, a expressão à direita não é avaliada.

1let a = false && console.log("This will not be printed");
2console.log(a);  // false
3
4let b = true || console.log("This will not be printed");
5console.log(b);  // true

Em ambos os casos, console.log() não é executado.

Definir a Precedência Explicitamente

Usar parênteses para agrupar expressões explicitamente pode evitar mal-entendidos sobre a precedência.

1console.log(true || (false && false));  // true
Diferenças Entre a Linguagem Natural e a Interpretação do Programa

Ao usar operadores lógicos, é importante estar ciente das ambiguidades na linguagem natural. Por exemplo, na frase 'um cachorro branco ou um gato', isso pode significar 'um cachorro branco ou qualquer gato' ou 'um cachorro branco ou um gato branco'. Em código, isso pode ser escrito da seguinte forma:.

1if (isWhite && isDog || isCat) {
2    console.log(' "A white dog" or "a cat of any color" ');
3}
4
5if (isWhite && (isDog || isCat)) {
6    console.log(' "A white dog" or "a white cat" ');
7}

Como a linguagem natural pode ser ambígua, é necessário ter cautela ao programar e projetar sistemas.

Operadores Bit a Bit

Os operadores bit a bit manipulam números no nível de bits.

Operador Descrição Exemplo Resultado
& E Lógico 5 & 1 1
` ` OU Lógico 5 | 1
^ OU Exclusivo (XOR) 5 ^ 1 4
~ Negação (NOT) ~5 -6
<< Deslocamento para a Esquerda 5 << 1 10
>> Deslocamento para a Direita (Com Sinal) 5 >> 1 2
>>> Deslocamento para a Direita (Sem Sinal) 5 >>> 1 2
1console.log('5 & 1  :', 5 & 1);   // Outputs: 1  (AND operation)
2console.log('5 | 1  :', 5 | 1);   // Outputs: 5  (OR operation)
3console.log('5 ^ 1  :', 5 ^ 1);   // Outputs: 4  (XOR operation)
4console.log('~5     :', ~5);      // Outputs: -6 (NOT operation)
5console.log('5 << 1 :', 5 << 1);  // Outputs: 10 (Left shift operation)
6console.log('5 >> 1 :', 5 >> 1);  // Outputs: 2  (Right shift operation)
7console.log('5 >>> 1:', 5 >>> 1); // Outputs: 2  (Unsigned right shift operation)

Operador Ternário

O operador ternário retorna valores diferentes com base no resultado de uma expressão condicional.

1let age = 20;
2let access = (age >= 18) ? "Allowed" : "Denied";
3console.log(access);  // Outputs: Allowed

Operadores de Tipo

Os operadores de tipo do TypeScript incluem os seguintes:.

Operador Descrição Exemplo Resultado
typeof Retorna o tipo de uma variável typeof 123 "number"
instanceof Verifica se um objeto pertence a uma classe específica arr instanceof Array true
is Como uma proteção de tipo, verifica se um valor é de um tipo específico value is string true or false
 1console.log(typeof "Hello");  // "string"
 2console.log(typeof 42);       // "number"
 3
 4let arr: number[] = [1, 2, 3];
 5console.log("arr instanceof Array : ", arr instanceof Array); // true
 6
 7// Example of Type Guard
 8function isString(value: any): value is string {
 9  return typeof value === "string";
10}
11
12let value: any = "Hello";
13if (isString(value)) {
14  console.log("Value is a string:", value);  // "Value is a string: Hello"
15}

Operadores de tipo são usados para verificar o tipo de um valor ou convertê-lo para um tipo específico.

  • O operador typeof retorna o tipo de uma variável.
  • O operador instanceof verifica se um objeto pertence a uma classe específica.
  • O operador is é usado para verificar se um valor é de um tipo específico. Faz parte das proteções de tipo do TypeScript.

Resumo

  • Operadores Aritméticos: Realizam cálculos básicos.
  • Operadores de Atribuição: Atribuem valores a variáveis.
  • Operadores de Comparação: Comparam valores.
  • Operadores Lógicos: Combinam condições lógicas.
  • Operadores Bit a Bit: Realizam operações no nível de bit.
  • Operador Ternário: Retorna valores com base em condições.
  • Operadores de tipo podem verificar o tipo de um valor.

No TypeScript, esses operadores podem ser usados para escrever cálculos complexos e expressões condicionais de maneira eficiente.

Você pode acompanhar o artigo acima usando o Visual Studio Code em nosso canal do YouTube. Por favor, confira também o canal do YouTube.

YouTube Video