Folha de Consulta Dart
Última atualização
Hello World e estrutura do programa
Todo programa Dart começa na função main de nível superior.
| Operação | Sintaxe |
|---|---|
| Ponto de entrada | void main() { ... } |
| Exibir uma linha | print("Hello, World!"); |
| Interpolação de string | print("Hi $name"); |
| Expressão na interpolação | print("Sum: ${a + b}"); |
| Comentário | // this is a comment |
| Comentário de várias linhas | /* ... */ |
| Importar uma biblioteca | import 'dart:math'; |
| Executar um arquivo | dart run main.dart |
Variáveis e tipos
Dart é tipado estaticamente, mas pode inferir tipos com var.
| Operação | Sintaxe |
|---|---|
| Variável inferida | var age = 30; |
| Tipo explícito | int age = 30; |
| Constante de tempo de compilação | const pi = 3.14; |
| Constante de tempo de execução | final name = getName(); |
| Tipos básicos | int, double, String, bool |
| Tipo dynamic | dynamic x = 5; |
| Conversão de tipo | int.parse("42"), n.toString() |
| Verificar tipo | x is String, x as String |
Null safety
Os tipos são não anuláveis por padrão; adicione ? para permitir null.
| Operação | Sintaxe |
|---|---|
| Não anulável (padrão) | int count = 0; |
| Tipo anulável | String? name; |
| Acesso ciente de null | user?.name |
| Coalescência de null | name ?? "default" |
| Atribuição de coalescência de null | name ??= "default"; |
| Afirmar não nulo | name! |
| Inicialização tardia | late String value; |
| Spread ciente de null | [...?maybeList] |
Strings
Strings oferecem suporte a aspas simples, duplas e triplas.
| Operação | Sintaxe |
|---|---|
| Comprimento | s.length |
| Maiúsculas / minúsculas | s.toUpperCase(), s.toLowerCase() |
| Interpolação | "Total: $price" |
| Concatenar | "foo" + "bar" |
| Contém | s.contains("ell") |
| Começa / termina com | s.startsWith("he") |
| Dividir | "a,b,c".split(",") |
| Substituir | s.replaceAll("a", "b") |
| Substring | s.substring(0, 3) |
| Trim | s.trim() |
Coleções (List, Map, Set)
Três tipos centrais de coleção com sintaxe de literal.
| Operação | Sintaxe |
|---|---|
| Literal de list | var nums = [1, 2, 3]; |
| Adicionar à list | nums.add(4); |
| Acesso / comprimento | nums[0], nums.length |
| Map / where | nums.map((n) => n * 2), nums.where((n) => n > 1) |
| Literal de map | var ages = {"Ada": 30}; |
| Acesso ao map | ages["Ada"] |
| Literal de set | var ids = {1, 2, 3}; |
| Operador spread | var all = [...a, ...b]; |
| Collection if / for | [if (show) 1, for (n in xs) n] |
Controle de fluxo
As condições vão entre parênteses; o switch oferece suporte a padrões.
| Operação | Sintaxe |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| Ternário | var r = x > 0 ? "pos" : "neg"; |
| Switch | switch (n) { case 1: ...; default: ... } |
| Laço for | for (var i = 0; i < 10; i++) { ... } |
| Laço for-in | for (var item in items) { ... } |
| forEach | items.forEach((x) => print(x)); |
| Laço while | while (x < 100) { ... } |
| Do-while | do { ... } while (x < 100); |
| Break / continue | break;, continue; |
Funções
Funções são de primeira classe; a sintaxe de arrow encurta expressões únicas.
| Operação | Sintaxe |
|---|---|
| Definir uma função | int add(int a, int b) { return a + b; } |
| Arrow function | int square(int x) => x * x; |
| Posicional opcional | void log(String m, [int? code]) { ... } |
| Parâmetros nomeados | void box({int w = 0, int h = 0}) { ... } |
| Nomeado obrigatório | void box({required int w}) { ... } |
| Função anônima | var f = (x) => x * 2; |
| Passar como argumento | nums.map((n) => n * 2) |
| Typedef | typedef IntOp = int Function(int); |
Classes e construtores
Classes guardam estado e comportamento; construtores vêm em várias formas.
| Operação | Sintaxe |
|---|---|
| Definir uma classe | class Point { int x; int y; } |
| Construtor | Point(this.x, this.y); |
| Construtor nomeado | Point.origin() : x = 0, y = 0; |
| Criar instância | var p = Point(1, 2); |
| Método | double dist() { ... } |
| Getter | int get area => w * h; |
| Herança | class Circle extends Shape { ... } |
| Chamar super | super(args) |
| Classe abstrata | abstract class Shape { ... } |
| Implementar interface | class Dog implements Animal { ... } |
Async (Future / async-await)
Futures representam valores disponíveis mais tarde; await pausa até que eles sejam resolvidos.
| Operação | Sintaxe |
|---|---|
| Função async | Future<int> load() async { ... } |
| Await em um future | var data = await load(); |
| Retornar um valor | return 42; dentro de uma função async |
| Atraso | await Future.delayed(Duration(seconds: 1)); |
| Tratar erros | try { await load(); } catch (e) { ... } |
| Encadeamento com then | load().then((v) => print(v)); |
| Executar em paralelo | await Future.wait([a(), b()]); |
| Stream assíncrono | await for (var x in stream) { ... } |
A sintaxe de Dart que você mais usa, em uma única página. Esta folha de consulta Dart é uma referência rápida para o núcleo da linguagem - variáveis e tipos, null safety, strings, coleções, controle de fluxo, funções, classes, e os futures e o async/await que você usa para escrever os apps por trás do Flutter.
Tudo aqui é Dart padrão e roda no SDK oficial. Copie o que precisar ou teste cada trecho ao vivo no playground de Dart - sem necessidade de instalação.
Perguntas frequentes sobre a folha de consulta Dart
Esta folha de consulta Dart é gratuita?
Sim. Esta folha de consulta Dart é totalmente gratuita, sem necessidade de cadastro. Salve nos favoritos e volte sempre que precisar consultar um operador de null safety, um método de coleção ou um padrão assíncrono.
Como funciona a null safety em Dart?
Em Dart, todo tipo é não anulável por padrão -
int count nunca pode conter null. Para permitir null você adiciona um ? (String? name), e o compilador então o obriga a tratar o caso de null. Os auxiliares tornam isso conciso: ?. para acesso ciente de null, ?? para um valor de fallback e ! para afirmar que um valor não é nulo quando você tem certeza. Isso captura erros de null em tempo de compilação em vez de em tempo de execução.O que é um Future e como funcionam o async e o await?
Um
Future representa um valor que estará disponível mais tarde, como o resultado de uma chamada de rede. Marcar uma função como async permite usar await, que pausa a execução até o future ser concluído e então fornece o valor - assim você escreve código assíncrono que se lê de cima para baixo como código síncrono. Envolva os awaits em try/catch para tratar erros.Posso praticar Dart online?
Sim. Abra o playground de Dart para executar qualquer trecho desta folha de consulta no seu navegador - sem SDK para instalar. Quando quiser estrutura, o curso interativo e gratuito de Dart da Coddy leva você passo a passo de null safety e coleções a classes e async/await.
Esta folha de consulta é boa para iniciantes?
Sim. Ela está organizada dos tópicos mais comuns (variáveis, null safety, controle de fluxo) até os avançados (classes, futures, async/await), de modo que você pode usar as seções de cima já no primeiro dia e ir avançando para o resto.
Recursos relacionados
Mais folhas de consulta
