Aide-mémoire Dart
Dernière mise à jour
Hello World et structure d'un programme
Chaque programme Dart démarre à la fonction main de premier niveau.
| Opération | Syntaxe |
|---|---|
| Point d'entrée | void main() { ... } |
| Afficher une ligne | print("Hello, World!"); |
| Interpolation de chaîne | print("Hi $name"); |
| Expression dans l'interpolation | print("Sum: ${a + b}"); |
| Commentaire | // this is a comment |
| Commentaire multiligne | /* ... */ |
| Importer une bibliothèque | import 'dart:math'; |
| Exécuter un fichier | dart run main.dart |
Variables et types
Dart est typé statiquement mais peut inférer les types avec var.
| Opération | Syntaxe |
|---|---|
| Variable inférée | var age = 30; |
| Type explicite | int age = 30; |
| Constante de compilation | const pi = 3.14; |
| Constante d'exécution | final name = getName(); |
| Types de base | int, double, String, bool |
| Type dynamique | dynamic x = 5; |
| Conversion de type | int.parse("42"), n.toString() |
| Vérifier le type | x is String, x as String |
Null safety
Les types sont non nullables par défaut ; ajoutez ? pour autoriser null.
| Opération | Syntaxe |
|---|---|
| Non nullable (par défaut) | int count = 0; |
| Type nullable | String? name; |
| Accès tenant compte de null | user?.name |
| Coalescence des nuls | name ?? "default" |
| Affectation coalescente | name ??= "default"; |
| Affirmer non null | name! |
| Initialisation tardive | late String value; |
| Spread tenant compte de null | [...?maybeList] |
Chaînes
Les chaînes prennent en charge les guillemets simples, doubles et triples.
| Opération | Syntaxe |
|---|---|
| Longueur | s.length |
| Majuscules / minuscules | s.toUpperCase(), s.toLowerCase() |
| Interpolation | "Total: $price" |
| Concaténer | "foo" + "bar" |
| Contient | s.contains("ell") |
| Commence / se termine par | s.startsWith("he") |
| Découper | "a,b,c".split(",") |
| Remplacer | s.replaceAll("a", "b") |
| Sous-chaîne | s.substring(0, 3) |
| Élaguer (trim) | s.trim() |
Collections (List, Map, Set)
Trois types de collection principaux avec une syntaxe littérale.
| Opération | Syntaxe |
|---|---|
| Littéral de liste | var nums = [1, 2, 3]; |
| Ajouter à la liste | nums.add(4); |
| Accès / longueur | nums[0], nums.length |
| Map / where | nums.map((n) => n * 2), nums.where((n) => n > 1) |
| Littéral de map | var ages = {"Ada": 30}; |
| Accès à la map | ages["Ada"] |
| Littéral d'ensemble | var ids = {1, 2, 3}; |
| Opérateur de spread | var all = [...a, ...b]; |
| If / for de collection | [if (show) 1, for (n in xs) n] |
Contrôle de flux
Les conditions vont entre parenthèses ; switch prend en charge les motifs.
| Opération | Syntaxe |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| Ternaire | var r = x > 0 ? "pos" : "neg"; |
| Switch | switch (n) { case 1: ...; default: ... } |
| Boucle for | for (var i = 0; i < 10; i++) { ... } |
| Boucle for-in | for (var item in items) { ... } |
| forEach | items.forEach((x) => print(x)); |
| Boucle while | while (x < 100) { ... } |
| Do-while | do { ... } while (x < 100); |
| Break / continue | break;, continue; |
Fonctions
Les fonctions sont de première classe ; la syntaxe fléchée raccourcit les expressions uniques.
| Opération | Syntaxe |
|---|---|
| Définir une fonction | int add(int a, int b) { return a + b; } |
| Fonction fléchée | int square(int x) => x * x; |
| Positionnel optionnel | void log(String m, [int? code]) { ... } |
| Paramètres nommés | void box({int w = 0, int h = 0}) { ... } |
| Nommé requis | void box({required int w}) { ... } |
| Fonction anonyme | var f = (x) => x * 2; |
| Passer en argument | nums.map((n) => n * 2) |
| Typedef | typedef IntOp = int Function(int); |
Classes et constructeurs
Les classes contiennent l'état et le comportement ; les constructeurs existent sous plusieurs formes.
| Opération | Syntaxe |
|---|---|
| Définir une classe | class Point { int x; int y; } |
| Constructeur | Point(this.x, this.y); |
| Constructeur nommé | Point.origin() : x = 0, y = 0; |
| Créer une instance | var p = Point(1, 2); |
| Méthode | double dist() { ... } |
| Getter | int get area => w * h; |
| Héritage | class Circle extends Shape { ... } |
| Appeler super | super(args) |
| Classe abstraite | abstract class Shape { ... } |
| Implémenter une interface | class Dog implements Animal { ... } |
Async (Future / async-await)
Les futures représentent des valeurs disponibles plus tard ; await met en pause jusqu'à leur résolution.
| Opération | Syntaxe |
|---|---|
| Fonction async | Future<int> load() async { ... } |
| Attendre une future | var data = await load(); |
| Renvoyer une valeur | return 42; dans une fonction async |
| Délai | await Future.delayed(Duration(seconds: 1)); |
| Gérer les erreurs | try { await load(); } catch (e) { ... } |
| Chaînage avec then | load().then((v) => print(v)); |
| Exécuter en parallèle | await Future.wait([a(), b()]); |
| Stream async | await for (var x in stream) { ... } |
La syntaxe Dart que vous utilisez le plus, sur une seule page. Cet aide-mémoire Dart est une référence rapide pour le cœur du langage - variables et types, null safety, chaînes, collections, contrôle de flux, fonctions, classes, ainsi que les futures et async/await que vous utilisez pour écrire les applications derrière Flutter.
Tout ce qui figure ici est du Dart standard et s'exécute sur le SDK officiel. Copiez ce dont vous avez besoin, ou essayez chaque extrait en direct dans le playground Dart - aucune installation requise.
FAQ de l'aide-mémoire Dart
Cet aide-mémoire Dart est-il gratuit ?
Oui. Cet aide-mémoire Dart est entièrement gratuit, sans inscription. Mettez-le en favori et revenez dès que vous devez retrouver un opérateur de null safety, une méthode de collection ou un motif async.
Comment fonctionne la null safety en Dart ?
En Dart, chaque type est non nullable par défaut -
int count ne peut jamais contenir null. Pour autoriser null, vous ajoutez un ? (String? name), et le compilateur vous oblige alors à gérer le cas null. Des utilitaires rendent cela concis : ?. pour un accès tenant compte de null, ?? pour une valeur de repli, et ! pour affirmer qu'une valeur est non nulle lorsque vous en êtes certain. Cela détecte les erreurs de null à la compilation plutôt qu'à l'exécution.Qu'est-ce qu'une Future et comment fonctionnent async et await ?
Une
Future représente une valeur qui sera disponible plus tard, comme le résultat d'un appel réseau. Marquer une fonction async vous permet d'utiliser await, qui met l'exécution en pause jusqu'à ce que la future se termine, puis vous donne la valeur - vous écrivez ainsi du code asynchrone qui se lit de haut en bas comme du code synchrone. Entourez les await de try/catch pour gérer les erreurs.Puis-je m'entraîner à Dart en ligne ?
Oui. Ouvrez le playground Dart pour exécuter n'importe quel extrait de cet aide-mémoire dans votre navigateur - aucun SDK à installer. Quand vous voulez de la structure, le cours Dart interactif gratuit de Coddy vous emmène de la null safety et des collections jusqu'aux classes et à async/await, étape par étape.
Cet aide-mémoire convient-il aux débutants ?
Oui. Il est organisé des sujets les plus courants (variables, null safety, contrôle de flux) jusqu'aux plus avancés (classes, futures, async/await), pour que vous puissiez utiliser les premières sections dès le premier jour et progresser vers le reste.
Ressources connexes
Plus d'aide-mémoires
