Um Operador é um símbolo que opera sobre um valor ou dado. Representa uma ação específica no trabalho com dados. Os dados nos quais os operadores operam são chamados de operandos. Ele pode ser usado com um ou mais valores para produzir um único valor. Todos os operadores JavaScript padrão estão disponíveis com o programa TypeScript.
Exemplo
10 + 10 = 20;
No exemplo acima, os valores '10' e '20' são conhecidos como operandos, enquanto '+' e '=' são conhecidos como operadores.
Operadores em TypeScript
No TypeScript, um operador pode ser classificado das seguintes maneiras.
- Operadores aritméticos
- Operadores de comparação (relacionais)
- Operadores lógicos
- Operadores bit a bit
- Operadores de atribuição
- Operador ternário/condicional
- Operador de concatenação
- Operador de tipo
Operadores aritméticos
Os operadores aritméticos tomam valores numéricos como operandos, executam uma ação e retornam um único valor numérico. Os operadores aritméticos mais comuns são adição(+), subtração(-), multiplicação(*) e divisão(/).
| Operador | Nome do operador | Descrição | Exemplo |
|---|---|---|---|
| + | Adição | Ele retorna uma adição dos valores. | let a = 20; let b = 30; let c = a + b; console.log( c ); // <strong>Output</strong> 30 |
| - | Subtração | Ele retorna a diferença dos valores. | let a = 30; let b = 20; let c = a - b; console.log( c ); // <strong>Output</strong> 10 |
| * | Multiplicação | Ele retorna o produto dos valores. | let a = 30; let b = 20; let c = a * b; console.log( c ); // <strong>Output</strong> 600 |
| / | Divisão | Ele executa a operação de divisão e retorna o quociente. | let a = 100; let b = 20; let c = a / b; console.log( c ); // <strong>Output</strong> 5 |
| % | Módulo | Ele executa a operação de divisão e retorna o restante. | let a = 95; let b = 20; let c = a % b; console.log( c ); // <strong>Output</strong> 15 |
| ++ | Incremento | É usado para incrementar o valor da variável em um. | let a = 55; a++; console.log( a ); // <strong>Output</strong> 56 |
| -- | Diminuir | É usado para diminuir o valor da variável em um. | let a = 55; a--; console.log( a ); // <strong>Output</strong> 54 |
Operadores de comparação (relacionais)
Os operadores de comparação são usados para comparar os dois operandos. Esses operadores retornam um valor booleano verdadeiro ou falso. Os importantes operadores de comparação são fornecidos abaixo.
| Operador | Nome do operador | Descrição | Exemplo |
|---|---|---|---|
| == | É igual a | Verifica se os valores dos dois operandos são iguais ou não. | let a = 10; let b = 20; console.log(a==b); //false console.log(a==10); //true console.log(10=='10'); //true |
| === | Idêntico (igual e do mesmo tipo) | Verifica se o tipo e os valores dos dois operandos são iguais ou não. | let a = 10; let b = 20; console.log(a===b); //false console.log(a===10); //true console.log(10==='10'); //false |
| != | Não é igual a | Verifica se os valores dos dois operandos são iguais ou não. | let a = 10; let b = 20; console.log(a!=b); //true console.log(a!=10); //false console.log(10!='10'); //false |
| !== | Não idênticos | Verifica se o tipo e os valores dos dois operandos são iguais ou não. | let a = 10; let b = 20; console.log(a!==b); //true console.log(a!==10); /false console.log(10!=='10'); //true |
| > | Maior que | Verifica se o valor dos operandos esquerdos é maior que o valor do operando direito ou não. | let a = 30; let b = 20; console.log(a>b); //true console.log(a>30); //false console.log(20> 20'); //false |
| >= | Melhor que ou igual a | Verifica se o valor dos operandos esquerdos é maior ou igual ao valor do operando direito ou não. | let a = 20; let b = 20; console.log(a>=b); //true console.log(a>=30); //false console.log(20>='20'); //true |
| < | Menor que | Verifica se o valor dos operandos esquerdos é menor que o valor do operando direito ou não. | let a = 10; let b = 20; console.log(a <b); true console.log(a<10); false console.log(10<'10'); false< pre></b);> |
| <=< td> | Menos que ou igual a | Verifica se o valor dos operandos esquerdos é menor ou igual ao valor do operando direito ou não. | let a = 10; let b = 20; console.log(a<=b); true console.log(a<="10);" console.log(10<="10" ); true< pre></=b);> |
Operadores lógicos
Operadores lógicos são usados para combinar duas ou mais condições em uma única expressão e retornar o resultado booleano verdadeiro ou falso. Os operadores lógicos são fornecidos abaixo.
| Operador | Nome do operador | Descrição | Exemplo |
|---|---|---|---|
| && | Lógico E | Retorna verdadeiro se ambos os operandos (expressão) forem verdadeiros, caso contrário, retorna falso. | let a = false; let b = true; console.log(a&&b); /false console.log(b&&true); //true console.log(b&&10); //10 which is also 'true' console.log(a&&'10'); //false |
| || | OU lógico | Retorna verdadeiro se algum dos operandos (expressão) for verdadeiro, caso contrário, retorna falso. | let a = false; let b = true; console.log(a||b); //true console.log(b||true); //true console.log(b||10); //true console.log(a||'10'); //'10' which is also 'true' |
| ! | Lógico NÃO | Retorna o resultado inverso de um operando (expressão). | let a = 20; let b = 30; console.log(!true); //false console.log(!false); //true console.log(!a); //false console.log(!b); /false console.log(!null); //true |
Operadores bit a bit
Os operadores bit a bit executam as operações bit a bit nos operandos. Os operadores bit a bit são os seguintes.
| Operador | Nome do operador | Descrição | Exemplo |
|---|---|---|---|
| & | E bit a bit | Ele retorna o resultado de uma operação booleana AND em cada bit de seus argumentos inteiros. | let a = 2; let b = 3; let c = a & b; console.log(c); // <br> <strong>Output <strong> 2 </strong></strong> |
| | | OU bit a bit | Ele retorna o resultado de uma operação booleana OR em cada bit de seus argumentos inteiros. | let a = 2; let b = 3; let c = a | b; console.log(c); // <br> <strong>Output</strong> 3 |
| ^ | XOR bit a bit | Ele retorna o resultado de uma operação booleana OR exclusiva em cada bit de seus argumentos inteiros. | let a = 2; let b = 3; let c = a ^ b; console.log(c); // <strong>Output </strong> 1 |
| ~ | Bit a bit NÃO | Ele inverte cada bit nos operandos. | let a = 2; let c = ~ a; console.log(c); // <strong>Output</strong> -3 |
| >> | Deslocamento bit a bit para a direita | O valor do operando esquerdo é movido para a direita pelo número de bits especificado no operando direito. | let a = 2; let b = 3; let c = a >> b; console.log(c); // <strong>Output </strong> 0 |
| << | Deslocamento bit a bit para a esquerda | O valor do operando esquerdo é movido para a esquerda pelo número de bits especificado no operando direito. Novos bits são preenchidos com zeros no lado direito. | let a = 2; let b = 3; let c = a << b; console.log(c); // <strong>Output </strong> 16 |
| >>> | Deslocamento bit a bit para a direita com zero | O valor do operando esquerdo é movido para a direita pelo número de bits especificado no operando direito e zeros são adicionados no lado esquerdo. | let a = 3; let b = 4; let c = a >>> b; console.log(c); // <strong>Output </strong> 0 |
Operadores de Atribuição
Operadores de atribuição são usados para atribuir um valor à variável. O lado esquerdo do operador de atribuição é chamado de variável e o lado direito do operador de atribuição é chamado de valor. O tipo de dados da variável e do valor deve ser o mesmo, caso contrário o compilador gerará um erro. Os operadores de atribuição são os seguintes.
| Operador | Nome do operador | Descrição | Exemplo |
|---|---|---|---|
| = | Atribuir | Ele atribui valores do lado direito ao operando do lado esquerdo. | let a = 10; let b = 5; console.log('a=b:' +a); // <strong>Output </strong> 10 |
| += | Adicionar e atribuir | Ele adiciona o operando esquerdo ao operando direito e atribui o resultado ao operando do lado esquerdo. | let a = 10; let b = 5; let c = a += b; console.log(c); // <strong>Output </strong> 15 |
| -= | Subtrair e atribuir | Subtrai o operando direito do operando esquerdo e atribui o resultado ao operando do lado esquerdo. | let a = 10; let b = 5; let c = a -= b; console.log(c); // <strong>Output </strong> 5 |
| *= | Multiplicar e atribuir | Multiplica o operando esquerdo pelo operando direito e atribui o resultado ao operando do lado esquerdo. | let a = 10; let b = 5; let c = a *= b; console.log(c); // <strong>Output </strong> 50 |
| /= | Dividir e atribuir | Ele divide o operando esquerdo com o operando direito e atribui o resultado ao operando do lado esquerdo. | let a = 10; let b = 5; let c = a /= b; console.log(c); // <strong>Output </strong> 2 |
| %= | Módulo e atribuição | Ele divide o operando esquerdo com o operando direito e atribui o resultado ao operando do lado esquerdo. | let a = 16; let b = 5; let c = a %= b; console.log(c); // <strong>Output </strong> 1 |
Operador Ternário/Condicional
O operador condicional recebe três operandos e retorna um valor booleano baseado na condição, seja ela verdadeira ou falsa. Seu funcionamento é semelhante a uma instrução if-else. O operador condicional possui associatividade da direita para a esquerda. A sintaxe de um operador condicional é fornecida abaixo.
expression ? expression-1 : expression-2;
Exemplo
let num = 16; let result = (num > 0) ? 'True':'False' console.log(result);
Saída:
True
Operador de concatenação
O operador de concatenação (+) é um operador usado para anexar as duas strings. Na operação de concatenação, não podemos adicionar espaço entre as strings. Podemos concatenar várias strings em uma única instrução. O exemplo a seguir nos ajuda a entender o operador de concatenação em TypeScript.
Exemplo
let message = 'Welcome to ' + 'JavaTpoint'; console.log('Result of String Operator: ' +message);
Saída:
Result of String Operator: Welcome to JavaTpoint
Operadores de tipo
Há uma coleção de operadores disponíveis que podem ajudá-lo ao trabalhar com objetos em TypeScript. Operadores como typeof, instanceof, in e delete são exemplos do operador Type. A explicação detalhada desses operadores é fornecida abaixo.
| Nome do operador | Descrição | Exemplo |
|---|---|---|
| em | É usado para verificar a existência de uma propriedade em um objeto. | let Bike = {make: 'Honda', model: 'CLIQ', year: 2018}; console.log('make' in Bike); // <strong>Output:</strong> true |
| excluir | É usado para excluir as propriedades dos objetos. | let Bike = { Company1: 'Honda', Company2: 'Hero', Company3: 'Royal Enfield' }; delete Bike.Company1; console.log(Bike); // <strong>Output:</strong> { Company2: 'Hero', Company3: 'Royal Enfield' } |
| tipo de | Ele retorna o tipo de dados do operando. | let message = 'Welcome to ' + 'JavaTpoint'; console.log(typeof message); // <strong>Output:</strong> String |
| instancia de | É usado para verificar se o objeto é de um tipo especificado ou não. | let arr = [1, 2, 3]; console.log( arr instanceof Array ); // true console.log( arr instanceof String ); // false |