Operadores em Dart
Os operadores são símbolos usados para fazer operações com valores, exemplo:
void main() {
int resultado = 10 + 5;
print(resultado); // Exibe: 15
}
Nesse exemplo, o operador + soma dois valores.
Operadores aritméticos
Operadores aritméticos são usados para fazer contas.
| Operador | Nome | Exemplo |
|---|---|---|
+ | Soma | 10 + 5 |
- | Subtração | 10 - 5 |
* | Multiplicação | 10 * 5 |
/ | Divisão | 10 / 5 |
~/ | Divisão inteira | 10 ~/ 3 |
% | Resto da divisão | 10 % 3 |
Soma
void main() {
int total = 10 + 5;
print(total);
}
Subtração
void main() {
int saldo = 100;
int gasto = 35;
int saldoFinal = saldo - gasto;
print(saldoFinal); // Exibe: 65
}
Multiplicação
void main() {
int quantidade = 3;
double preco = 20.50;
double total = quantidade * preco;
print(total); // Exibe: 61.5
}
Divisão
void main() {
double resultado = 10 / 4;
print(resultado); // Exibe: 2.5
}
Em Dart, o operador / sempre retorna um double. Mesmo quando a divisão parece exata:
void main() {
double resultado = 10 / 2;
print(resultado); // Exibe: 5.0
}
Divisão inteira
Use ~/ quando quiser apenas a parte inteira da divisão.
void main() {
int resultado = 10 ~/ 3;
print(resultado); // Exibe: 3
}
Resto da divisão
Use % para pegar o resto da divisão.
void main() {
int resto = 10 % 3;
print(resto); // Exibe: 1
}
Isso acontece porque 10 dividido por 3, dá 3 e sobra 1.
Operadores de comparação
Os operadores de comparação servem para comparar valores. O resultado sempre será true ou false.
| Operador | Significado |
|---|---|
== | Igual |
!= | Diferente |
> | Maior |
< | Menor |
>= | Maior ou igual |
<= | Menor ou igual |
Eles não precisam ser usados obrigatoriamente dentro de uma estrutura de condição como if. Uma comparação pode ser exibida diretamente, armazenada em uma variável ou usada como parte de outra expressão, exemplo:
void main() {
int idade = 18;
print(idade == 18); // Exibe: true
}
Operadores lógicos
Os operadores lógicos são usados para combinar condições.
| Operador | Nome | Significado |
|---|---|---|
| && | E | Todas as condições precisam ser verdadeiras |
| || | OU | Pelo menos uma condição precisa ser verdadeira |
| ! | NÃO | Inverte o valor lógico |
Operador &&
void main() {
bool usuarioAtivo = true;
bool pagamentoConfirmado = true;
if (usuarioAtivo && pagamentoConfirmado) {
print('Acesso liberado');
} else {
print('Acesso bloqueado');
}
}
Operador ||
void main() {
bool admin = false;
bool suporte = true;
if (admin || suporte) {
print('Pode acessar o painel');
} else {
print('Acesso negado');
}
}
Operador !
void main() {
bool bloqueado = false;
if (!bloqueado) {
print('Usuário pode acessar'); // Exibe: Usuário pode acessar
} else {
print('Usuário bloqueado');
}
}
Operadores de atribuição
O operadores de atribuição são usados para guardar ou atualizar valores em variáveis.
| Operador | Exemplo | Equivalente |
|---|---|---|
= | saldo = 100 | Atribui valor |
+= | saldo += 50 | saldo = saldo + 50 |
-= | saldo -= 20 | saldo = saldo - 20 |
*= | total *= 2 | total = total * 2 |
/= | valor /= 2 | valor = valor / 2 |
~/= | valor ~/= 2 | valor = valor ~/ 2 |
%= | valor %= 2 | valor = valor % 2 |
Estruturas de condição
As estruturas de condição servem para executar um bloco de código apenas quando uma condição for verdadeira. Em Dart, as principais estruturas são:
| Estrutura | Uso |
|---|---|
if | Executa algo se a condição for verdadeira |
else | Executa algo se a condição do if for falsa |
else if | Testa uma nova condição |
switch | Compara um valor com vários casos |
Em Dart, a condição usada no if precisa resultar em um valor booleano, ou seja, true ou false.
if
Use if quando quiser executar um código apenas se uma condição for verdadeira.
void main() {
int idade = 20;
if (idade >= 18) {
print('Usuário maior de idade');
}
}
else
Use else quando quiser executar outro bloco caso a condição do if seja falsa.
void main() {
int idade = 16;
if (idade >= 18) {
print('Usuário maior de idade');
} else {
print('Usuário menor de idade');
}
}
else if
Use else if quando precisar testar mais de uma condição, exemplo com status de pagamento:
void main() {
String status = 'pendente';
if (status == 'aprovado') {
print('Pagamento aprovado');
} else if (status == 'pendente') {
print('Pagamento aguardando confirmação');
} else if (status == 'recusado') {
print('Pagamento recusado');
} else {
print('Status desconhecido');
}
}
Condições com operadores lógicos
Podemos combinar condições usando &&, || e !. O operador && significa E, ou seja, todas as condições precisam ser verdadeiras:
void main() {
bool usuarioAtivo = true;
bool pagamentoConfirmado = true;
if (usuarioAtivo && pagamentoConfirmado) {
print('Acesso liberado');
} else {
print('Acesso bloqueado');
}
}
Já o operador || significa OU, ou seja, pelo menos uma condição precisa ser verdadeira:
void main() {
bool admin = false;
bool suporte = true;
if (admin || suporte) {
print('Pode acessar o painel');
} else {
print('Acesso negado');
}
}
O operador ! inverte o valor lógico:
void main() {
bool bloqueado = false;
if (!bloqueado) {
print('Usuário pode acessar');
} else {
print('Usuário bloqueado');
}
}
switch
Use switch quando você precisa comparar o mesmo valor com várias possibilidades:
void main() {
String status = 'enviado';
switch (status) {
case 'criado':
print('Pedido criado');
case 'pago':
print('Pagamento confirmado');
case 'enviado':
print('Pedido enviado');
case 'entregue':
print('Pedido entregue');
default:
print('Status desconhecido');
}
}
Em Dart, um case não vazio termina automaticamente ao final do seu bloco. Diferente de linguagens como C e JavaScript, normalmente você não precisa usar break em cada case.
switch expression
O Dart também permite usar switch como expressão. Isso significa que o switch pode produzir um valor.
void main() {
String status = 'pago';
String mensagem = switch (status) {
'criado' => 'Pedido criado',
'pago' => 'Pagamento confirmado',
'enviado' => 'Pedido enviado',
'entregue' => 'Pedido entregue',
_ => 'Status desconhecido',
};
print(mensagem); // Exibe: Pagamento confirmado
}
O switch expression existe a partir do Dart 3.0. Ele usa => para ligar cada caso ao valor retornado.
Estruturas de repetição
As estruturas de repetição servem para executar o mesmo bloco de código várias vezes. Em Dart, as principais estruturas são:
| Estrutura | Uso |
|---|---|
for | Quando você sabe quantas vezes quer repetir |
for in | Quando quer percorrer uma coleção |
while | Quando quer repetir enquanto uma condição for verdadeira |
do while | Quando quer executar pelo menos uma vez antes de testar a condição |
for
Use for quando você sabe quantas vezes o código deve repetir:
for (início; condição; incremento) {
// código repetido
}
Exemplo:
void main() {
for (int contador = 1; contador <= 5; contador++) {
print('Execução número $contador');
}
}
for in
Use for in para percorrer uma coleção, como uma List ou um Set:
void main() {
List<String> usuarios = ['Ana', 'Jose', 'Carlos'];
for (String usuario in usuarios) {
print(usuario);
}
}
O for in é mais simples quando você não precisa trabalhar com o índice da lista.
break
Use o break para parar uma repetição antes que ela termine.
void main() {
List<String> usuarios = ['Ana', 'Jose', 'Carlos'];
for (String usuario in usuarios) {
if (usuario == 'Jose') {
print('Usuário encontrado');
break;
}
print('Verificando $usuario');
}
}
Depois do break, a repetição termina.
continue
Use o continue para pular a repetição atual e ir para a próxima.
void main() {
List<String> usuarios = ['Ana', 'Jose', 'Carlos'];
for (String usuario in usuarios) {
if (usuario == 'Jose') {
continue;
}
print(usuario);
}
}
forEach
O forEach é um método usado para percorrer todos os itens de uma coleção, como uma List, executando uma função para cada item. Ele é parecido com um for in, mas usa uma função como argumento.
No for in seria assim:
List<String> usuarios = ['Ana', 'Jose', 'Carlos'];
for (String usuario in usuarios) {
print(usuario);
}
}
Já a sintaxe do forEach é assim:
void main() {
List<String> variavel_contendo_informações = ['Ana', 'Bruno', 'Carlos'];
variavel_contendo_informações.forEach((nova_variavel_que_recebe_valores_da_variavel_contendo_informações) {
print('Informação: $nova_variavel_que_recebe_valores_da_variavel_contendo_informações');
});
}
Um exemplo seria:
void main() {
List<String> usuarios = ['Ana', 'Bruno', 'Carlos'];
usuarios.forEach((usuario) {
print('Usuário: $usuario');
});
}
Esse tipo de for é usado em quando criamos função anônima. Ela será executada uma vez para cada item da lista. A cada repetição, o valor atual da lista fica disponível na variável usuario.
O mesmo código poderia ser escrito com for in:
void main() {
List<String> usuarios = ['Ana', 'Bruno', 'Carlos'];
for (String usuario in usuarios) {
print('Usuário: $usuario');
}
}
Os dois exemplos fazem a mesma coisa. Use forEach quando quiser aplicar uma ação simples em todos os itens de uma coleção. Um exemplo mais realista seria:
void main() {
List<String> produtos = ['Mouse', 'Teclado', 'Monitor'];
produtos.forEach((produto) {
print('Produto cadastrado: $produto');
});
}
Também é possível usar a forma curta com => quando houver apenas uma instrução:
void main() {
List<String> produtos = ['Mouse', 'Teclado', 'Monitor'];
produtos.forEach((produto) => print('Produto cadastrado: $produto'));
}
No entanto, é bom explicar que dentro de forEach, não existe break ou continue como em um for comum. Se precisar parar a repetição no meio, prefira usar for in.
while
Use while quando você não sabe exatamente quantas vezes o código deve repetir, mas sabe qual condição precisa continuar existindo para que o código continue repetindo.
void main() {
int tentativas = 1;
while (tentativas <= 3) {
print('Tentativa $tentativas');
tentativas++;
}
}
do while
Use do while quando o bloco precisa executar pelo menos uma vez. A diferença é que o while testa a condição antes de executar, já o do while executa primeiro e testa depois.
void main() {
int opcao = 1;
do {
print('Menu exibido');
opcao++;
} while (opcao <= 3);
}