029 – Operadores em Dart – + – * / && || ~ ++ — += -= == Tutorial de Dart

Playlist: Curso Grátis de FLUTTER e DART Completo

Curso de DART

Operadores

Dart define os operadores mostrados na tabela a seguir. Você pode substituir muitos desses operadores, conforme descrito em Operadores substituíveis.

Descrição Operador
unex postfix expr ++ expr– () []. ?
prefixo unário -expr! expr ~ expr ++ expr –expr
multiplicativo * /% ~ /
aditivo + –
turno MENOR MENOR, MAIOR MAIOR, MAIOR MAIOR MAIOR
bit a bit E &
bitwise XOR ^
bit a bit OU |
teste relacional e de tipo MAIOR, MAIOR IGUAL, MENOR IGUAL, MENOR MENOR como é é!
igualdade ==!
lógica AND &&
OR lógica ||
se nulo?
expr1 condicional? expr2: expr3
cascata ..
atribuição = * = / = + = – = & = ^ = etc.
Aviso: A precedência do operador é uma aproximação do comportamento de um analisador de dardo. Para respostas definitivas, consulte a gramática na especificação da linguagem Dart.

Quando você usa operadores, cria expressões. Aqui estão alguns exemplos de expressões de operador:

um ++
a + b
a = b
a == b
c? a: b
a é T
Na tabela de operadores, cada operador tem precedência mais alta que os operadores nas linhas que o seguem. Por exemplo, o operador multiplicativo% tem precedência mais alta que (e, portanto, executa antes) o operador de igualdade ==, que tem precedência mais alta que o operador AND lógico &&. Essa precedência significa que as duas linhas de código a seguir são executadas da mesma maneira:

// Parênteses melhoram a legibilidade.
if ((n% i == 0) && (d% i == 0)) …

// Mais difícil de ler, mas equivalente.
se (n% i == 0 && d% i == 0) …
Aviso: Para operadores que trabalham em dois operandos, o operando à esquerda determina qual versão do operador é usada. Por exemplo, se você tiver um objeto Vector e um objeto Point, aVector + aPoint usará a versão Vector de +.

Operadores aritméticos
O Dart suporta os operadores aritméticos usuais, conforme mostrado na tabela a seguir.

Operador Significado
+ Acrescentar
– Subtrair
-expr Unário menos, também conhecido como negação (inverter o sinal da expressão)
* Multiplique
/ Divide
~ / Divide, retornando um resultado inteiro
% Obtém o restante de uma divisão inteira (módulo)
Exemplo:

assert (2 + 3 == 5);
assert (2 – 3 == -1);
assert (2 * 3 == 6);
assert (5/2 == 2,5); // Resultado é um duplo
assert (5 ~ / 2 == 2); // Result é um int
assert (5% 2 == 1); // Restante

assert (‘5/2 = $ 5 ~ / 2 r $ 5% 2’ == ‘5/2 = 2 r 1’);
O Dart também oferece suporte a operadores de incremento e decremento de prefixo e postfix.

Operador Significado
++ var var = var + 1 (o valor da expressão é var + 1)
var ++ var = var + 1 (o valor da expressão é var)
–var var = var – 1 (o valor da expressão é var – 1)
var– var = var – 1 (o valor da expressão é var)
Exemplo:

var a, b;

a = 0;
b = ++ a; // Incrementar a antes de b receber seu valor.
assert (a == b); // 1 == 1

a = 0;
b = a ++; // Incrementar um AFTER b obtém seu valor.
assert (a! = b); // 1! = 0

a = 0;
b = – a; // Decrementa a before b recebe seu valor.
assert (a == b); // -1 == -1

a = 0;
b = a–; // Decrementa um AFTER b recebe seu valor.
assert (a! = b); // -1! = 0
Operadores de igualdade e relacionais
A tabela a seguir lista os significados de igualdade e operadores relacionais.

Operador Significado
== Igual; veja a discussão abaixo
! = Não é igual
MAIOR Maior que
MENOR Menos que
MAIOR = Maior que ou igual a
MENOR= Menor ou igual a
Para testar se dois objetos x e y representam a mesma coisa, use o operador ==. (No raro caso em que você precisa saber se dois objetos são exatamente o mesmo objeto, use a função identical ().) Veja como o operador == funciona:

Se x ou y for nulo, retornará verdadeiro se ambos forem nulos e falso se apenas um for nulo.

Retorna o resultado da invocação do método x == (y). (Isso é certo, operadores como == são métodos que são invocados em seu primeiro operando. Você pode até mesmo substituir muitos operadores, incluindo ==, como você verá em Operadores substituíveis.)

Veja um exemplo do uso de cada um dos operadores relacionais e de igualdade:

assert (2 == 2);
afirmar (2! = 3);
afirmar (3MAIOR 2);
assert (2 MENOR3);
assert (3MAIOR = 3);
assert (2 MENOR= 3);
Operadores de teste de tipo
O como, é e é! os operadores são úteis para verificar tipos em tempo de execução.

Operador Significado
como o Typecast (também usado para especificar prefixos de biblioteca)
é True se o objeto tiver o tipo especificado
é! Falso se o objeto tiver o tipo especificado
O resultado de obj é T se true obj implementa a interface especificada por T. Por exemplo, obj is Object é sempre true.