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.