Dart est le langage de programmation créé par Google qui sert de fondation à Flutter. Conçu pour le développement d'interfaces, il s'agit d'un langage moderne, typé et orienté objet, familier pour les développeurs venant de Java, C# ou TypeScript, tout en conservant plusieurs spécificités propres.

L'un de ses atouts majeurs tient à sa double compilation : en JIT pendant le développement, pour bénéficier du hot reload instantané, puis en AOT pour la production, sous forme de code machine natif et performant. Cette combinaison réunit les avantages des deux approches.

Un aperçu en code

void main() {
  final noms = ['Alice', 'Bob', 'Chloé'];

  for (final nom in noms) {
    print('Bonjour, $nom !');   // interpolation de chaîne
  }

  final total = noms
      .where((n) => n.length > 3)
      .map((n) => n.toUpperCase())
      .toList();

  print(total);   // [ALICE, CHLOÉ]
}

Les traits marquants

Trait Ce que ça apporte
Typage sain (sound null safety) Le compilateur garantit qu'une variable non-nullable n'est jamais null
Async/await Programmation asynchrone lisible (Future, Stream)
Tout est objet Même les nombres et fonctions ; cohérence totale
AOT + JIT Rapide en prod, hot reload en dev
Syntaxe familière Accessible depuis Java/C#/JS/TypeScript

La sûreté du null (null safety)

Il s'agit de l'une des évolutions les plus structurantes de Dart moderne : le type indique explicitement si une valeur peut être nulle ou non.

String nom = 'Synapx';     // ne peut JAMAIS être null
String? surnom;            // peut être null (le '?')

print(nom.length);         // OK
print(surnom!.length);     // '!' = "je garantis que ce n'est pas null" (à vos risques)
print(surnom?.length);     // '?.' = null si surnom est null (sûr)

Résultat : toute une catégorie de bugs (NullPointerException) est éliminée dès la compilation, au lieu d'être découverte en production.

L'asynchrone, sans douleur

import 'package:http/http.dart' as http;

Future<String> chargerProfil() async {
  final reponse = await http.get(Uri.parse('https://api.exemple.fr/me'));
  return reponse.body;
}

Future<void> main() async {
  final profil = await chargerProfil();
  print(profil);
}

Future représente une valeur disponible plus tard ; Stream, une suite de valeurs produites dans le temps, ce qui convient particulièrement aux événements ou aux WebSockets. await rend l'ensemble aussi lisible qu'un code synchrone classique.

Outils du quotidien

dart --version                 # version installée
dart pub get                   # installe les dépendances (pubspec.yaml)
dart analyze                   # analyse statique (erreurs, avertissements)
dart format .                  # formatage automatique du code
dart test                      # lance les tests

Bon à savoir : avec Flutter, on utilise généralement les commandes flutter pub get, flutter analyze, etc., qui encapsulent celles de Dart.

Pourquoi apprendre Dart ?

  • C'est la porte d'entrée de Flutter : il est incontournable, et c'est un avantage.
  • Sa null safety et son typage rendent le code robuste sans être verbeux.
  • Sa syntaxe est vite prise en main quand on connaît déjà un langage à accolades.

Dart sans Flutter reste peu fréquent ; en revanche, Dart est précisément ce qui rend Flutter agréable à utiliser. Maîtriser ses bases — types, null safety, Future/Stream — permet d'écrire des applications Flutter propres et fiables. À compléter avec l'article Flutter pour disposer d'une vue d'ensemble.