Dart Cheat Sheet
Ultimo aggiornamento
Hello World e struttura del programma
Ogni programma Dart parte dalla funzione main di primo livello.
| Operazione | Sintassi |
|---|---|
| Punto di ingresso | void main() { ... } |
| Stampare una riga | print("Hello, World!"); |
| Interpolazione di stringhe | print("Hi $name"); |
| Espressione nell'interpolazione | print("Sum: ${a + b}"); |
| Commento | // this is a comment |
| Commento su più righe | /* ... */ |
| Importare una libreria | import 'dart:math'; |
| Eseguire un file | dart run main.dart |
Variabili e tipi
Dart è tipizzato staticamente ma può dedurre i tipi con var.
| Operazione | Sintassi |
|---|---|
| Variabile con tipo dedotto | var age = 30; |
| Tipo esplicito | int age = 30; |
| Costante a tempo di compilazione | const pi = 3.14; |
| Costante a runtime | final name = getName(); |
| Tipi di base | int, double, String, bool |
| Tipo dinamico | dynamic x = 5; |
| Conversione di tipo | int.parse("42"), n.toString() |
| Controllare il tipo | x is String, x as String |
Null safety
I tipi non sono nullable per impostazione predefinita; aggiungi ? per permettere null.
| Operazione | Sintassi |
|---|---|
| Non nullable (predefinito) | int count = 0; |
| Tipo nullable | String? name; |
| Accesso null-aware | user?.name |
| Null-coalescing | name ?? "default" |
| Assegnazione null-coalescing | name ??= "default"; |
| Asserire che non è null | name! |
| Inizializzazione late | late String value; |
| Spread null-aware | [...?maybeList] |
Stringhe
Le stringhe supportano apici singoli, doppi e tripli.
| Operazione | Sintassi |
|---|---|
| Lunghezza | s.length |
| Maiuscolo / minuscolo | s.toUpperCase(), s.toLowerCase() |
| Interpolazione | "Total: $price" |
| Concatenare | "foo" + "bar" |
| Contiene | s.contains("ell") |
| Inizia / finisce con | s.startsWith("he") |
| Dividere | "a,b,c".split(",") |
| Sostituire | s.replaceAll("a", "b") |
| Sottostringa | s.substring(0, 3) |
| Rimuovere gli spazi | s.trim() |
Collezioni (List, Map, Set)
Tre tipi di collezione principali con sintassi letterale.
| Operazione | Sintassi |
|---|---|
| Letterale List | var nums = [1, 2, 3]; |
| Aggiungere a una lista | nums.add(4); |
| Accesso / lunghezza | nums[0], nums.length |
| Map / where | nums.map((n) => n * 2), nums.where((n) => n > 1) |
| Letterale Map | var ages = {"Ada": 30}; |
| Accesso a una Map | ages["Ada"] |
| Letterale Set | var ids = {1, 2, 3}; |
| Operatore spread | var all = [...a, ...b]; |
| If / for nelle collezioni | [if (show) 1, for (n in xs) n] |
Controllo del flusso
Le condizioni vanno tra parentesi; switch supporta i pattern.
| Operazione | Sintassi |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| Ternario | var r = x > 0 ? "pos" : "neg"; |
| Switch | switch (n) { case 1: ...; default: ... } |
| Ciclo for | for (var i = 0; i < 10; i++) { ... } |
| Ciclo for-in | for (var item in items) { ... } |
| forEach | items.forEach((x) => print(x)); |
| Ciclo while | while (x < 100) { ... } |
| Do-while | do { ... } while (x < 100); |
| Break / continue | break;, continue; |
Funzioni
Le funzioni sono di prima classe; la sintassi a freccia accorcia le espressioni singole.
| Operazione | Sintassi |
|---|---|
| Definire una funzione | int add(int a, int b) { return a + b; } |
| Funzione a freccia | int square(int x) => x * x; |
| Posizionali opzionali | void log(String m, [int? code]) { ... } |
| Parametri con nome | void box({int w = 0, int h = 0}) { ... } |
| Con nome obbligatori | void box({required int w}) { ... } |
| Funzione anonima | var f = (x) => x * 2; |
| Passare come argomento | nums.map((n) => n * 2) |
| Typedef | typedef IntOp = int Function(int); |
Classi e costruttori
Le classi contengono stato e comportamento; i costruttori esistono in diverse forme.
| Operazione | Sintassi |
|---|---|
| Definire una classe | class Point { int x; int y; } |
| Costruttore | Point(this.x, this.y); |
| Costruttore con nome | Point.origin() : x = 0, y = 0; |
| Creare un'istanza | var p = Point(1, 2); |
| Metodo | double dist() { ... } |
| Getter | int get area => w * h; |
| Ereditarietà | class Circle extends Shape { ... } |
| Chiamare super | super(args) |
| Classe astratta | abstract class Shape { ... } |
| Implementare un'interfaccia | class Dog implements Animal { ... } |
Async (Future / async-await)
I future rappresentano valori disponibili più tardi; await mette in pausa finché non si risolvono.
| Operazione | Sintassi |
|---|---|
| Funzione async | Future<int> load() async { ... } |
| Attendere un future | var data = await load(); |
| Restituire un valore | return 42; dentro una funzione async |
| Ritardo | await Future.delayed(Duration(seconds: 1)); |
| Gestire gli errori | try { await load(); } catch (e) { ... } |
| Concatenare con then | load().then((v) => print(v)); |
| Eseguire in parallelo | await Future.wait([a(), b()]); |
| Stream asincrono | await for (var x in stream) { ... } |
La sintassi di Dart che usi di più, in una sola pagina. Questa cheat sheet di Dart è un riferimento rapido per il linguaggio di base: variabili e tipi, null safety, stringhe, collezioni, controllo del flusso, funzioni, classi e i future e async/await che usi per scrivere le app con Flutter.
Tutto quello che trovi qui è Dart standard e gira sull'SDK ufficiale. Copia quello che ti serve oppure prova ogni frammento dal vivo nel playground Dart, senza installare nulla.
Domande frequenti sulla cheat sheet di Dart
Questa cheat sheet di Dart è gratuita?
Sì. Questa cheat sheet di Dart è completamente gratuita e non richiede registrazione. Salvala nei preferiti e torna quando devi controllare un operatore di null safety, un metodo delle collezioni o uno schema async.
Come funziona la null safety in Dart?
In Dart ogni tipo è non nullable per impostazione predefinita:
int count non può mai contenere null. Per permettere null aggiungi un ? (String? name) e il compilatore ti obbliga a gestire il caso null. Alcuni operatori rendono tutto più conciso: ?. per l'accesso null-aware, ?? per un valore di riserva e ! per asserire che un valore non è null quando ne sei certo. Così gli errori di null emergono in fase di compilazione invece che a runtime.Cos'è un Future e come funzionano async e await?
Un
Future rappresenta un valore che sarà disponibile più tardi, come il risultato di una chiamata di rete. Se marchi una funzione come async puoi usare await, che mette in pausa l'esecuzione finché il future non si completa e poi ti restituisce il valore: così scrivi codice asincrono che si legge dall'alto verso il basso come codice sincrono. Racchiudi gli await in un try/catch per gestire gli errori.Posso esercitarmi con Dart online?
Sì. Apri il playground Dart per eseguire nel browser qualsiasi frammento di questa cheat sheet, senza installare nessun SDK. Quando vuoi un percorso strutturato, il corso interattivo gratuito di Dart di Coddy ti porta passo dopo passo da null safety e collezioni fino a classi e async/await.
Questa cheat sheet va bene per chi inizia?
Sì. È organizzata dagli argomenti più comuni (variabili, null safety, controllo del flusso) fino a quelli avanzati (classi, future, async/await), così puoi usare le prime sezioni fin dal primo giorno e arrivare al resto con il tempo.
Risorse correlate
Altre cheat sheet
