Dart : qu'est-ce que c'est, les caractéristiques du langage Flutter et la programmation

Qu'est-ce que Dart ?

Dart est un langage de programmation à la syntaxe proche du C, développé par Google sous la direction de Lars Bak (créateur d'Eclipse). La première version est sortie en 2011, mais Dart a gagné en popularité en 2018 avec la sortie de Flutter 1.0. Le langage est conçu pour créer des interfaces utilisateur : il prend en charge nativement les streams, les futures et les patterns réactifs.

La philosophie de Dart est « l'équilibre entre performance et productivité ». Le langage prend en charge deux stratégies de compilation : JIT (Just-In-Time) pour le développement avec rechargement à chaud et AOT (Ahead-Of-Time) pour les builds de production avec des performances natives. Le compilateur JIT injecte du code modifié dans une application en cours d'exécution en millisecondes, sans nécessiter de recompilation de l'APK — c'est l'avantage clé de Dart par rapport aux autres langages dans le développement mobile.

Une fonctionnalité clé de Dart est sound null safety, introduite dans Dart 2.12 (2021). Le système de types garantit qu'une variable ne peut pas être null sans déclaration explicite (int?). Cela élimine NullPointerException à la compilation. Selon Google, l'adoption de null safety a réduit le taux de crash dans les applications Flutter de 30% en environnement de production.

Écosystème Dart

L'écosystème Dart comprend trois domaines principaux : Flutter (applications mobiles et desktop), AngularDart (applications web) et Dart Server (solutions serveur). Flutter est la plateforme dominante : selon Statista (2025), Flutter est utilisé dans 46% des projets mobiles multiplateformes, devant React Native (38%) et Xamarin (8%).

Syntaxe de Dart : types, fonctions et classes

La syntaxe de Dart ressemble à Java et JavaScript, mais possède ses propres constructions uniques. Tout dans Dart est un objet — même int, double et bool héritent d'Object. Le typage est facultatif : une variable déclarée comme var infère le type automatiquement, mais il est recommandé de spécifier les types explicitement pour la lisibilité et les performances.

Types et déclarations de base

Dart prend en charge int, double, String, bool, List, Set, Map, Record, Symbol et Runes. Type nullable — tout type avec le suffixe ? (int?, String?). L'opérateur ?? (null-aware) retourne la valeur de droite si celle de gauche est null. La notation en cascade (..) permet d'appeler plusieurs méthodes sur le même objet sans répéter la référence.

// Types et déclarations de base dans Dart
void main() {
  // Typage explicite
  int age = 25;
  double price = 19.99;
  String name = 'Dart';
  bool isValid = true;

  // Null safety — la variable peut être null
  int? nullableAge = null;
  int result = nullableAge ?? 0; // Opérateur null-aware

  // Collections avec génériques
  List<String> items = ['Dart', 'Flutter', 'Mobile'];
  Map<String, dynamic> config = {
    'version': '3.0',
    'mode': 'debug',
  };

  // Notation en cascade
  final list = <String>[]
    ..add('one')
    ..add('two')
    ..sort();
}

// Record — type immuable anonyme
(String, int) user = ('Alice', 30);
print(user.$1); // 'Alice'

Le type dynamic désactive la vérification des types — utilisez-le uniquement lorsque vous travaillez avec JSON ou des données dynamiques. Record est un nouveau type dans Dart 3.0 qui permet de regrouper des valeurs sans créer de classe séparée. L'opérateur null-aware ?? est la méthode standard pour travailler avec des valeurs nullables, remplaçant les longues vérifications if-else.

Classes et mixins

Les classes dans Dart — héritage unique (extends), multiple via les mixins (mixin). Dart ne prend pas en charge les interfaces en tant que concept séparé — toute classe peut être implémentée (implements). Un mixin est une classe sans constructeur dont les méthodes et les champs peuvent être ajoutés à n'importe quelle classe en utilisant le mot-clé with.

// Classes, héritage et mixins dans Dart
abstract class Animal {
  void sound(); // méthode abstraite
}

mixin Swimmer {
  void swim() => print('Swimming...');
}

mixin Flyer {
  void fly() => print('Flying...');
}

class Duck extends Animal with Swimmer, Flyer {
  @override
  void sound() => print('Quack!');
}

void main() {
  final duck = Duck();
  duck.sound(); // Quack!
  duck.swim();  // Swimming...
  duck.fly();   // Flying...
}

// Constructeur nommé
class Config {
  final String env;

  Config.development() : env = 'dev';
  Config.production()  : env = 'prod';
}

La classe Duck hérite de Animal et utilise deux mixins — Swimmer et Flyer. Cela démontre l'héritage multiple sans problème de losange : les mixins sont résolus linéairement (super chain). Les constructeurs nommés (Config.development) sont une alternative aux méthodes de fabrique statiques pour créer des objets avec des paramètres prédéfinis.

Asynchronie dans Dart : Future, Stream et async/await

L'asynchronie dans Dart est implémentée via Future (valeur unique), Stream (séquence de valeurs) et async/await. Dart utilise un modèle monotâche avec une boucle d'événements, similaire à JavaScript, mais avec une différence importante : les calculs longs ne bloquent pas l'UI car le code Dart s'exécute dans un Isolate — un thread séparé sans mémoire partagée.

Future représente une opération asynchrone qui se terminera après un certain temps. Un Future peut être en état d'attente, terminé avec une valeur ou terminé avec une erreur. La chaîne .then().catchError() est une alternative à async/await, mais il est recommandé d'utiliser await pour la lisibilité.

// Chargement asynchrone de données avec Future et Stream
import 'dart:convert';
import 'package:http/http.dart' as http;

class ApiService {
  final String baseUrl;

  ApiService(this.baseUrl);

  // Future pour une seule requête
  Future<Map<String, dynamic>> fetchUser(int id) async {
    final response = await http.get(
      Uri.parse('$baseUrl/users/$id'),
    );

    if (response.statusCode == 200) {
      return jsonDecode(response.body);
    } else {
      throw Exception('Failed to load user: ${response.statusCode}');
    }
  }

  // Stream pour une séquence de données
  Stream<int> countStream(int max) async* {
    for (var i = 1; i <= max; i++) {
      await Future.delayed(Duration(seconds: 1));
      yield i;
    }
  }
}

void main() async {
  final api = ApiService('https://api.example.com');

  // Utilisation de await
  final user = await api.fetchUser(1);
  print('User: ${user['name']}');

  // Traitement de Stream avec await for
  await for (final count in api.countStream(5)) {
    print('Count: $count');
  }
}

La classe ApiService démontre deux types d'asynchronie : Future pour une requête HTTP (réponse unique) et Stream pour un compteur séquentiel (générateur avec async* et yield). Stream est efficace pour travailler avec les capteurs, la géolocalisation, Firebase Realtime Database — partout où les données arrivent en continu. Isolate utilise une mémoire séparée — les données sont transmises via SendPort/ReceivePort.

Dart et Flutter : architecture d'application

Dart et Flutter forment une pile unique : Flutter est le framework UI, Dart est le langage de description de l'UI. Dans Flutter, tout est un widget — d'un bouton à une application entière. Les widgets peuvent être stateful (avec état mutable) et stateless (immuables). Dart décrit une UI déclarative : build() retourne un arbre de widgets que Flutter rend avec Skia (ou Impeller sur iOS).

Structure d'une application Flutter

Une application Flutter en Dart consiste en main() → runApp(MyApp()) → MaterialApp. MaterialApp inclut le routage (routes), le thème (theme) et la localisation. Chaque écran est un Scaffold contenant AppBar, Body (généralement Column/ListView) et BottomNavigationBar. Navigation via Navigator.push/pop ou des routes nommées.

// Application Flutter simple en Dart
import 'package:flutter/material.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Dart Demo',
      theme: ThemeData(primarySwatch: Colors.blue),
      home: HomeScreen(),
    );
  }
}

class HomeScreen extends StatefulWidget {
  @override
  _HomeScreenState createState() => _HomeScreenState();
}

class _HomeScreenState extends State<HomeScreen> {
  int _counter = 0;

  void _increment() {
    setState(() {
      _counter++;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Dart + Flutter')),
      body: Center(
        child: Text('Counter: $_counter'),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: _increment,
        child: Icon(Icons.add),
      ),
    );
  }
}

Le widget HomeScreen est un StatefulWidget avec un état interne _counter. L'appel de setState() notifie à Flutter de reconstruire l'UI — le code Dart réexécute build(), créant un nouvel arbre de widgets. Flutter compare (diff) efficacement l'ancien et le nouvel arbre, mettant à jour uniquement les parties modifiées de l'écran. Hot Reload remplace build() sans réinitialiser l'état _counter.

Compilation de Dart : JIT vs AOT

La compilation de Dart est hybride : JIT pour le développement et AOT pour la production. En mode débogage, la Dart VM exécute un compilateur JIT qui interprète le bytecode avec la capacité d'échanger du code à chaud. En mode release, dart compile exe ou flutter build crée un binaire AOT natif pour une architecture spécifique (arm64, x86_64, armv7).

La compilation JIT de Dart en mode débogage offre un rechargement à chaud en ~1 seconde — les développeurs voient les changements d'UI sans perdre l'état de l'application. La compilation AOT offre des performances proches des applications natives Swift/Kotlin. Selon Google, Flutter sur Dart AOT atteint 60 FPS d'animations même sur des appareils de milieu de gamme.

Outils du développeur Dart

Les outils du développeur Dart incluent le Dart SDK (compilateur dart, dartanalyzer, dartfmt, pub), le Flutter SDK et les plugins IDE. Le Dart SDK est installé avec le Flutter SDK dans le dossier flutter/bin/cache/dart-sdk. Pub est le gestionnaire de paquets qui lit pubspec.yaml et télécharge les dépendances depuis pub.dev.

Outils clés

dart analyze — analyseur statique qui vérifie les types, les importations inutilisées et les erreurs potentielles. dart format — formateur qui formate automatiquement le code dans un style cohérent. dart doc — générateur de documentation à partir des commentaires ///. Flutter DevTools — profileur avec inspecteur d'arbre de widgets, logs, mémoire et réseau. Dart VM Service — débogage d'une application en cours d'exécution via WebSocket.

# pubspec.yaml — configuration du projet Dart
name: my_flutter_app
description: A new Flutter project.
version: 1.0.0

environment:
  sdk: '>=3.0.0 <4.0.0'

dependencies:
  flutter:
    sdk: flutter
  http: ^1.2.0
  provider: ^6.1.0
  shared_preferences: ^2.2.0
  json_annotation: ^4.8.0

dev_dependencies:
  flutter_test:
    sdk: flutter
  build_runner: ^2.4.0
  json_serializable: ^6.7.0
  flutter_lints: ^3.0.0

Le fichier pubspec.yaml décrit les dépendances d'un projet Dart. Le champ environment:sdk spécifie la version de Dart — la version stable actuelle est 3.x. Dependencies sont les bibliothèques principales, dev_dependencies sont pour les tests et la génération de code. json_annotation + json_serializable génèrent du code de sérialisation JSON via build_runner. flutter_lints est un ensemble de règles pour l'analyseur.