Le mot-clé late et la Null Safety

Fait partie de la section Programmation Orientée Objet du Journey Dart de Coddy — leçon 26 sur 110.

Parfois, vous avez besoin d'une variable non-nullable, mais vous ne pouvez pas lui assigner sa valeur immédiatement. Le mot-clé late indique à Dart : « Je promets d'initialiser ceci avant de l'utiliser. »

late String description;

void setup() {
  description = 'Initialized later';
}

void main() {
  setup();
  print(description);  // Fonctionne - initialisé avant utilisation
}

Sans late, Dart se plaindrait que description n'est pas initialisée. Avec late, vous prenez la responsabilité de vous assurer qu'elle a une valeur avant d'y accéder. Si vous essayez de la lire avant l'initialisation, vous obtiendrez une erreur d'exécution.

Un cas d'utilisation courant concerne les calculs coûteux que vous souhaitez retarder jusqu'à ce qu'ils soient réellement nécessaires :

class DataProcessor {
  late List<int> data = _loadData();
  
  List<int> _loadData() {
    print('Loading data...');
    return [1, 2, 3, 4, 5];
  }
}

DataProcessor processor = DataProcessor();
// 'Loading data...' hasn't printed yet
print(processor.data);  // Now it loads and prints

La méthode _loadData() s'exécute uniquement lorsque data est accédé pour la première fois, et non lors de la création de l'objet. Cette initialisation paresseuse peut améliorer les performances lorsque la valeur pourrait ne jamais être nécessaire.

Utilisez late lorsque vous êtes certain qu'une variable sera initialisée avant son utilisation mais que vous ne pouvez pas le faire lors de la déclaration. C'est une promesse faite au compilateur - rompez cette promesse, et votre programme plante.

Défi

Facile

Construisons un gestionnaire de configuration qui démontre la puissance des variables late pour l'initialisation différée. Vous allez créer un système où les opérations de configuration coûteuses ne se produisent que lorsque la configuration est réellement nécessaire.

Vous organiserez votre code en deux fichiers :

config_manager.dart : Définissez une classe ConfigManager qui gère les paramètres de l'application. La classe doit avoir :
- Un String appName passé via le constructeur
- Un late String databaseUrl qui sera initialisé plus tard via une méthode de configuration
- Un late int maxConnections avec une initialisation paresseuse (lazy) qui affiche Calculating max connections... lors du premier accès et retourne 100
- Une méthode setupDatabase(String url) qui initialise le databaseUrl
- Une méthode displayConfig() qui affiche la configuration actuelle
main.dart : Importez votre gestionnaire de configuration et démontrez le fonctionnement des variables late :
- Créez un ConfigManager avec le nom d'application 'MyApp'
- Affichez Config created
- Appelez setupDatabase avec l'URL 'localhost:5432/mydb'
- Affichez Accessing max connections...
- Affichez la valeur de maxConnections
- Affichez Accessing max connections again...
- Affichez à nouveau la valeur de maxConnections (remarquez que le message de calcul ne se répète pas)
- Appelez displayConfig()

La méthode displayConfig() doit afficher sous ce format :

--- Configuration ---
App: [appName]
Database: [databaseUrl]
Max Connections: [maxConnections]

Remarquez comment le calcul paresseux de maxConnections ne s'exécute qu'une seule fois - la première fois que vous y accédez. C'est l'avantage de late avec un initialiseur !

Sortie attendue :

Config created
Accessing max connections...
Calculating max connections...
100
Accessing max connections again...
100
--- Configuration ---
App: MyApp
Database: localhost:5432/mydb
Max Connections: 100

Aide-mémoire

Le mot-clé late vous permet de déclarer des variables non-nullables qui seront initialisées plus tard, avant d'être utilisées :

late String description;

void setup() {
  description = 'Initialized later';
}

void main() {
  setup();
  print(description);  // Works - initialized before use
}

Sans late, Dart nécessite une initialisation immédiate. Avec late, vous promettez d'initialiser la variable avant d'y accéder. La lecture d'une variable late non initialisée provoque une erreur d'exécution.

Initialisation paresseuse (Lazy Initialization) : Lorsqu'une variable late possède un initialiseur, l'initialisation est différée jusqu'à ce que la variable soit accédée pour la première fois :

class DataProcessor {
  late List<int> data = _loadData();
  
  List<int> _loadData() {
    print('Loading data...');
    return [1, 2, 3, 4, 5];
  }
}

DataProcessor processor = DataProcessor();
// 'Loading data...' hasn't printed yet
print(processor.data);  // Now it loads and prints

La méthode _loadData() ne s'exécute que lorsque data est accédée pour la première fois, et non lors de la création de l'objet. Cela améliore les performances lorsque la valeur pourrait ne jamais être nécessaire ou lorsque l'initialisation est coûteuse.

Essayez vous-même

import 'config_manager.dart';

void main() {
  // TODO: Créer un ConfigManager avec le nom d'application 'MyApp'
  
  // TODO: Afficher 'Config created'
  
  // TODO: Appeler setupDatabase avec l'URL 'localhost:5432/mydb'
  
  // TODO: Afficher 'Accessing max connections...'
  
  // TODO: Afficher la valeur de maxConnections
  
  // TODO: Afficher 'Accessing max connections again...'
  
  // TODO: Afficher à nouveau la valeur de maxConnections
  // (remarquez que le message de calcul ne se répète pas)
  
  // TODO: Appeler displayConfig()
}