Sintaxe Dart

A sintaxe do Dart é projetada para ser clara, concisa e familiar para desenvolvedores que já tiveram contato com linguagens como C, Java ou JavaScript. Vamos ver alguns elementos básicos a estrutura da linguagem:

Ponto de Entrada: A Função main()

Todo aplicativo Dart precisa de uma função main() de nível superior, que é o ponto de entrada onde a execução do programa começa.

void main() {
  print('Olá, Dart!'); // 'print()' é usado para exibir saída no console.
}

Variáveis e Tipos de Dados

• Declaração: Você pode declarar variáveis usando var (onde o tipo é inferido pelo compilador) ou especificando o tipo explicitamente. Dart é uma linguagem com tipagem forte (sound type system), o que ajuda a evitar erros.

var nome = 'Dart';         // Tipo String inferido

String linguagem = 'Dart'; // Tipo String explícito

int ano = 2011;            // Tipo inteiro

double versao = 3.4;       // Tipo ponto flutuante (número com decimal)

bool ehLegal = true;       // Tipo booleano (true ou false)

• Null Safety (Segurança contra Nulos): Por padrão, os tipos não podem conter null a menos que você indique explicitamente com um ?.

String? nomeNuloPodeSer; // Esta variável PODE ser nula
// String nomeNaoNulo = null; // Isso daria um erro de compilação

nomeNuloPodeSer = null;

void main() {
  print(nomeNuloPodeSer);
}

• final e const:

  • final: A variável só pode ser definida uma vez. É inicializada quando acessada (runtime).

  • const: A variável é uma constante de tempo de compilação. Seu valor deve ser conhecido em tempo de compilação.

final String apelido = 'Dartzinho';

// apelido = 'Outro'; // Erro: 'apelido' não pode ser reatribuído

const double PI = 3.14159;

Tipos de Dados Comuns:

• Números: int (inteiros), double (ponto flutuante).

• Strings: Sequências de caracteres. Podem ser definidas com aspas simples (') ou duplas ("). A interpolação de strings é feita com $variavel ou ${expressao}.

String saudacao = 'Olá';
String pessoa = 'Mundo';
String mensagem = '$saudacao, $pessoa! O ano é ${DateTime.now().year}.';

void main(){
  print(mensagem); // Ex: Olá, Mundo! O ano é 2025.
}

• Booleanos: bool (valores true ou false).

• Listas (Arrays): Coleção ordenada de objetos.

List<int> numeros = [1, 2, 3, 4, 5];
List<String> frutas = ['Maçã', 'Banana', 'Laranja'];

void main() {
  print(frutas[0]); // Acessa o primeiro elemento: Maçã
  frutas.add('Uva');
  print(frutas.length); // 4
}

• Mapas (Dicionários/Objetos): Coleção de pares chave-valor.

Map<String, String> capitais = {
  'Brasil': 'Brasília',
  'França': 'Paris'

};

void main() {

  print(capitais['Brasil']); // Brasília

  capitais['Japão'] = 'Tóquio';
}

• Conjuntos: Coleção não ordenada de itens únicos.

Set<String> cores = {'azul', 'verde', 'vermelho'};

void main() {

  cores.add('azul'); // Não adiciona, pois 'azul' já existe

  print(cores.length); // 3

}

Operadores:

O Dart suporta os operadores comuns como:

• Aritméticos: +, -, *, / (divisão resulta em double), ~/ (divisão resulta em int), % (módulo).

• Igualdade e Relacionais: == (igual), != (diferente), >, <, >=, <=.

• Lógicos: ! (não), && (e), || (ou).

• Incremento/Decremento: ++variavel, variavel++, --variavel, variavel--.

void main() {

  int a = 5;

  int b = ++a; // 'a' é incrementado para 6, e então 'b' recebe o novo valor.

  print("Valor de 'a' depois do incremento: $a"); // Saída: 6

  print("Valor de 'b': $b"); // Saída: 6

}

void main() {

  int x = 5;

  int y = x++; // O valor original de 'x' (5) é atribuído a 'y', e só então 'x' é incrementado.

  print("Valor de 'x' depois do incremento: $x"); // Saída: 6

  print("Valor de 'y': $y"); // Saída: 5

}

• • Atribuição: =, +=, -=, *=, /=.

  • Operador Ternário: condicao ? expressao1 : expressao2.

  • Operador de coalescência nula: expr1 ?? expr2 (retorna expr1 se não for nulo; caso contrário, retorna expr2).

  • Operador de acesso seguro a nulos: variavel?.metodoOuPropriedade (chama o método/propriedade apenas se variavel não for nula).

void main() {

  int a = 5;

  int b = 2;

  print(a + b); // 7

  print(a / b); // 2.5

  print(a ~/ b); // 2

  print(a > b); // true

  String? nome;

  String nomeUsuario = nome ?? 'Convidado'; // Se nome for null, usa 'Convidado'

  print(nomeUsuario); // Convidado

  // int? tamanhoNome = nome?.length; // Se nome for null, tamanhoNome será null

  // print(tamanhoNome);

}

Estruturas de Controle de Fluxo:

• • if / else if / else:

int idade = 18;

if (idade >= 18) {

  print('Maior de idade');

} else if (idade >= 12) {

  print('Adolescente');

} else {

  print('Criança');

}

• • for loop:

for (int i = 0; i < 5; i++) {

  print('Número: $i');

}

List<String> planetas = ['Mercúrio', 'Vênus', 'Terra'];

for (String planeta in planetas) { // For-in loop

  print(planeta);

}

planetas.forEach((planeta) { // Método forEach (mais funcional que for-in)

    print('Planeta: $planeta');

});

• • while e do-while loops:

int contador = 0;

while (contador < 3) {

  print('Contagem (while): $contador');

  contador++;

}

int j = 0;

do {

    print('Contagem (do-while): $j');

    j++;

} while (j < 3);

• switch / case:

String comando = 'ABRIR';

switch (comando) {

  case 'ABRIR':

    print('Abrindo...');

    break; // break é importante

  case 'FECHAR':

    print('Fechando...');

    break;

  default:

    print('Comando não reconhecido.');

}

• break e continue: Usados para controlar o fluxo dentro de loops.

Funções:

Funções são blocos de código que realizam uma tarefa específica.

• Definição:

// Função sem retorno (procedure) e sem parâmetros 

void saudacaoSimples() {

  print('Olá!');

}

// Função com retorno e parâmetros

int somar(int a, int b) {

  return a + b;

}

// Chamando as funções

saudacaoSimples();

int resultado = somar(5, 3);

print('Resultado da soma: $resultado'); // 8

• Parâmetros:

  • Posicionais obrigatórios: int somar(int a, int b)

  • Nomeados opcionais: Envolvidos por {}. Podem ter valores padrão e podem ser marcados como required.

void exibirInfo(String nome, {int? idade, String cidade = 'Desconhecida', required String pais}) {

  print('Nome: $nome, Idade: ${idade ?? "Não informada"}, Cidade: $cidade, País: $pais');

}

exibirInfo('Ana', idade: 30, pais: 'Brasil');

exibirInfo('Carlos', pais: 'Portugal', cidade: 'Lisboa');

• • • Posicionais opcionais: Envolvidos por [].

String dizer(String de, String msg, [String? dispositivo]) {

  var resultado = '$de diz $msg';

  if (dispositivo != null) {

    resultado = '$resultado via $dispositivo';

  }

  return resultado;

}

print(dizer('João', 'Olá')); // João diz Olá

print(dizer('Maria', 'Oi', 'celular')); // Maria diz Oi via celular

• Sintaxe Curta (Arrow Syntax): Para funções que contêm apenas uma expressão.

int multiplicar(int a, int b) => a * b;

print(multiplicar(4, 5)); // 20

• Funções Anônimas (Lambdas/Closures):

var lista = ['maçãs', 'bananas', 'laranjas'];

lista.forEach((item) { // (item) { ... } é uma função anônima

  print(item.toUpperCase());

});

Comentários:

// Este é um comentário de uma linha.

/*

 Este é um

 comentário de

 múltiplas linhas.

*/

/// Este é um comentário de documentação de uma linha.

/**

 * Este é um comentário de documentação

 * de múltiplas linhas.

 * Usado para gerar documentação com `dart doc`.

 */

Classes e Objetos (Básico da Orientação a Objetos):

Dart é uma linguagem orientada a objetos. Tudo é um objeto.

class Pessoa {

  // Atributos

  String nome;

  int idade;

  // Construtor

  Pessoa(this.nome, this.idade);

  // Método

  void apresentar() {

    print('Olá, meu nome é $nome e tenho $idade anos.');

  }

}

void main() {

  var pessoa1 = Pessoa('Alice', 30); // Criando um objeto (instância da classe)

  pessoa1.apresentar(); // Chamando um método do objeto

  var pessoa2 = Pessoa('Bob', 25);

  pessoa2.apresentar();

}

Programação Assíncrona (async, await, Future)

Dart tem um forte suporte para programação assíncrona, essencial para operações que podem demorar (como chamadas de rede ou leitura de arquivos) sem bloquear a interface do usuário.

• Future: Representa um valor ou erro que estará disponível em algum momento no futuro.

• async: Marca uma função como assíncrona (retorna um Future).

• await: Pausa a execução da função async até que um Future seja concluído.

Future<String> buscarDadosUsuario() async {

  // Simula uma chamada de rede que leva 2 segundos

  await Future.delayed(Duration(seconds: 2));

  return 'Dados do usuário carregados!';

}

void main() async { // main também pode ser async

  print('Buscando dados...');

  String dados = await buscarDadosUsuario();

  print(dados);

  print('Programa continua...');

}

Input de dados no terminal

Para receber input de dados do console em um aplicativo Dart, você usa a biblioteca dart:io. Especificamente, a função stdin.readLineSync().

Como funciona:

1. Importar dart:io: Primeiro, você precisa importar a biblioteca dart:io no seu arquivo Dart.

import 'dart:io';

2. Usar stdin.readLineSync(): O objeto stdin (standard input) da biblioteca dart:io representa o fluxo de entrada padrão. O método readLineSync() lê uma linha inteira de texto que o usuário digita no console até que ele pressione a tecla "Enter". Este método é síncrono, o que significa que a execução do seu programa irá pausar e esperar até que o usuário digite algo e pressione "Enter". Ele retorna uma String? (String anulável), pois a entrada pode ser nula se o final do fluxo for alcançado (por exemplo, se a entrada for redirecionada de um arquivo e o arquivo terminar, ou se o usuário pressionar Ctrl+D no Linux/macOS ou Ctrl+Z seguido de "Enter" no Windows para indicar o fim da entrada).

Exemplo Básico:

import 'dart:io';

void main() {

  // Solicita ao usuário para digitar algo

  print('Por favor, digite seu nome:');

  // Lê a linha de entrada do console

  String? nome = stdin.readLineSync();

  // Verifica se a entrada não é nula antes de usar

  if (nome != null && nome.isNotEmpty) {

    print('Olá, $nome!');

  } else {

    print('Nenhum nome foi digitado.');

  }

  print('Digite sua idade:');

  String? idadeInput = stdin.readLineSync();

  if (idadeInput != null && idadeInput.isNotEmpty) {

    // Tenta converter a string para um inteiro

    try {

      int idade = int.parse(idadeInput);

      print('Você tem $idade anos.');

    } catch (e) {

      print('Entrada inválida para idade. Por favor, digite um número.');

    }

  } else {

    print('Nenhuma idade foi digitada.');

  }

}

Explicação do Exemplo:

• import 'dart:io';  → Importa a biblioteca necessária.

• print('Por favor, digite seu nome:');  → Exibe uma mensagem no console para o usuário.

• String? nome = stdin.readLineSync();

  • Chama readLineSync() para pausar e esperar pela entrada do usuário.

  • O valor retornado é armazenado na variável nome, que é do tipo String? para acomodar a possibilidade de um valor nulo.

• if (nome != null && nome.isNotEmpty)  → É uma boa prática verificar se a string recebida não é nula e não está vazia antes de processá-la.

Convertendo para outros tipos:

• • Se você espera um número, terá que converter a string lida (que é sempre texto) para o tipo numérico desejado (por exemplo, int ou double).

  • int.parse(idadeInput)  → tenta converter a string idadeInput para um inteiro.

  • É importante usar um bloco try-catch ao fazer parsing, pois se o usuário digitar algo que não pode ser convertido para um número (ex: "abc"), uma FormatException será lançada.

Pontos Importantes:

• • Null Safety: Lembre-se de que readLineSync() retorna String?. Você precisará lidar com a possibilidade de null, seja com uma verificação if (variavel != null), o operador ?? para fornecer um valor padrão, ou o operador ! (assertion operator) se você tiver certeza absoluta de que não será nulo (use com cuidado).

• Aplicativos de Console: A biblioteca dart:io e, consequentemente, stdin.readLineSync(), são destinados principalmente a aplicativos de linha de comando (console applications). Eles não funcionarão da mesma forma em ambientes Flutter para mobile ou web, onde a entrada do usuário é gerenciada por widgets de interface gráfica (como TextField).

• Fim do Fluxo (End-of-File - EOF): Se o programa estiver lendo de um fluxo que termina (por exemplo, entrada redirecionada de um arquivo, ou o usuário sinaliza EOF com Ctrl+D/Ctrl+Z), readLineSync() retornará null.

Este é o método padrão e mais direto para interagir com o usuário via console em Dart.

Output de dados no terminal

print('String to terminal'); // Envia o argumento para o terminal e quebra a linha em seguida

stdout.write('String to terminal');  // Envia o argumento para o terminal e não quebra a linha no final

stdout.writeln('String to terminal');  // Envia o argumento para o terminal e quebra a linha em seguida

Exemplo:

print('Digite seu nome: '); // Label

var name = stdin.readLineSync(); // Solicita a digitação abaixo da label

stdout.write('Digite sua idade: '); // Label

var age = stdin.readLineSync(); // Solicita a digitação após a label

stdout.writeln('digite seu e-mail: '); // Label

var email = stdin.readLineSync(); // Solicita a digitação abaixo da label

Tem mais, muito mais

O Dart é uma linguagem moderna, poderosa e expansível. Pesquise sobre e continue seguindo os links abaixo: