Gestion des exceptions en Dart
Une exception est un événement d'erreur qui se produit lors de l'exécution d'un programme.
Une bonne gestion des exceptions permet au programme de se dégrader gracieusement lorsqu'il rencontre des erreurs, plutôt que de planter directement.
Ce chapitre présente try/catch/finally en Dart, le lancement d'exceptions avec throw, la capture de types spécifiques avec on, et le relancement avec rethrow.
Bases de try / catch / finally
Le bloc try contient du code susceptible de lever des exceptions, le bloc catch capture et gère les exceptions, et le bloc finally s'exécute indépendamment du fait qu'une exception se produise ou non.
Exemple
// try-catch de base
try {
int result = 10 ~/ 0; // La division par zéro lève une exception
print(Résultat: $result); // Cette ligne ne s'exécutera pas
} catch (e) {
// e est l'objet exception
print(Exception capturée: $e);
}
// Obtenir les informations sur l'exception et la trace de la pile
try {
List<int> numbers = [1, 2, 3];
print(numbers[10]); // Accès à un index hors limites
} catch (e, stackTrace) {
// e est l'exception, stackTrace est la pile d'appels
print(EXEMPLE d'exception : $e);
print(Informations sur la trace de pile :\n$stackTrace');
}
// finally : s'exécute indépendamment de la survenue d'une exception
try {
print(Tentative d'exécution de l'opération...);
int result = 5 ~/ 0;
print(Cette ligne ne s'exécutera pas : $result);
} catch (e) {
print(Erreur : $e);
} finally {
// Le code dans le bloc finally s'exécute toujours, souvent utilisé pour nettoyer les ressources
print(Nettoyage des ressources terminé (finally s'exécute toujours));
}
}
捕获到异常: IntegerDivisionByZeroException EXAMPLE 异常: RangeError (index): Invalid value: Not in inclusive range 0..2: 10 堆栈信息: #0 List.[] (dart:core-patch/growable_array.dart:264) #1 main (file:///...) ... 尝试执行操作... 出错: IntegerDivisionByZeroException 清理资源完成(finally 总是执行)
Le bloc finally est idéal pour le nettoyage des ressources, comme la fermeture de fichiers, la libération de connexions à une base de données, etc. Même s'il y a une instruction return dans try ou catch, finally s'exécute quand même.
throw : Lancer une exception
L'utilisation du mot-clé throw permet de lancer activement une exception.
Dart permet de lancer n'importe quel objet comme exception (pas seulement des sous-classes d'Exception), mais la meilleure pratique est de lancer des sous-classes d'Exception ou d'Error.
Exemple
class InvalidAgeException implements Exception {
final int age;
final String message;
InvalidAgeException(this.age)
: message = Âge invalide : $age (l'âge doit être compris entre 0 et 150);
@override
String toString() => 'InvalidAgeException: $message';
}
// Fonction qui utilise une exception personnalisée
void validateAge(int age) {
if (age < 0) {
throw InvalidAgeException(age);
}
if (age > 150) {
throw InvalidAgeException(age);
}
print(Âge $age validé avec succès);
}
// Lancer une exception intégrée
int divide(int a, int b) {
if (b == 0) {
throw ArgumentError(Le diviseur ne peut pas être 0); // Utiliser une exception intégrée
}
return a ~/ b;
}
void main() {
// Tester une exception personnalisée
try {
validateAge(-5);
} catch (e) {
print(e);
}
try {
validateAge(200);
} catch (e) {
print(e);
}
validateAge(25); // Cas normal
// Tester le lancement d'une exception intégrée
try {
divide(10, 0);
} catch (e) {
print(Exemple d'erreur : $e);
}
}
InvalidAgeException: 无效的年龄: -5(年龄必须在 0 到 150 之间) InvalidAgeException: 无效的年龄: 200(年龄必须在 0 到 150 之间) 年龄 25 验证通过 EXAMPLE 错误: Invalid argument(s): 除数不能为 0
La différence entre Exception et Error : Exception est une erreur prévisible que le programme peut gérer (comme un délai d'attente réseau, un fichier introuvable) ; Error est un problème imprévisible qui indique généralement un bogue dans le programme (comme des erreurs de type, un pointeur nul). Votre code doit intercepter Exception, et non Error.
on: Intercepter un type spécifié
Le mot-clé on peut intercepter les exceptions par type, ce qui rend la gestion des erreurs plus granulaire.
Exemple
// Intercepter différentes exceptions par type
try {
// Simuler différents types d'exceptions
int result = performOperation('divide_by_zero');
print(Résultat : $result);
} on IntegerDivisionByZeroException {
// Intercepter uniquement l'exception de division par zéro
print(EXEMPLE erreur : impossible de diviser par zéro);
} on FormatException catch (e) {
// Intercepter l'exception de format et obtenir les informations sur l'exception
print('EXEMPLE erreur de format : ${e.message}');
} on RangeError {
// Ne capturer que les erreurs de plage
print('EXEMPLE erreur : index hors limites');
} catch (e) {
// Repli : capturer toutes les autres exceptions
print('Erreur inconnue : $e');
} finally {
print('Opération terminée\n');
}
// Exemple de correspondance dans l'ordre
print('--- Test de différentes opérations ---');
for (var op in ['divide_by_zero', 'parse_error', 'out_of_range', 'normal']) {
try {
performOperation(op);
} on IntegerDivisionByZeroException {
print('$op -> exception de division par zéro');
} on FormatException {
print('$op -> exception de format');
} on RangeError {
print('$op -> exception de plage');
} catch (e) {
print('$op -> autre exception : $e');
}
}
}
int performOperation(String operation) {
switch (operation) {
case 'divide_by_zero':
return 10 ~/ 0; // Lancer IntegerDivisionByZeroException
case 'parse_error':
int.parse('not_a_number'); // Lancer FormatException
return 0;
case 'out_of_range':
var list = [1, 2, 3];
return list[100]; // Lancer RangeError
case 'normal':
return 42;
default:
throw Exception('Opération inconnue');
}
}
EXAMPLE 错误: 不能除以零 操作结束 --- 测试不同的操作 --- divide_by_zero -> 除零异常 parse_error -> 格式异常 out_of_range -> 范围异常
L'ordre des on et catch est important : Dart fait correspondre les types d'exception de haut en bas. Les types d'exception plus spécifiques doivent être placés en premier, et les plus généraux en dernier. Si catch (e) est placé au début, les clauses on suivantes ne seront jamais exécutées.
rethrow: Relancer l'exception
Parfois, vous devez effectuer un traitement après avoir attrapé une exception (comme la journalisation), puis laisser l'exception continuer à se propager vers le haut.
Le mot-clé rethrow est utilisé pour relancer l'exception actuellement attrapée, en préservant les informations de pile d'origine.
Exemple
void databaseOperation() {
print(' Connexion à la base de données...');
throw Exception('La connexion à la base de données EXAMPLE a échoué');
}
void serviceLayer() {
try {
print(' Couche service : appel de l’opération de base de données');
databaseOperation();
} catch (e) {
// Journaliser d’abord, puis relancer
print(' [Log] exception d’opération de base de données : $e');
rethrow; // Préserver l’exception d’origine et la pile, continuer à propager vers le haut
}
}
void controllerLayer() {
try {
print('Couche contrôleur : traitement de la requête');
serviceLayer();
} catch (e, stackTrace) {
// La couche la plus externe intercepte et gère
print('La couche contrôleur a intercepté une exception');
print('Message d’erreur : $e');
print('Retour à l’utilisateur : "Service temporairement indisponible, veuillez réessayer plus tard"');
}
}
void main() {
controllerLayer();
print('\n--- Différence entre rethrow et throw e ---');
// Démontrer la différence entre rethrow et throw e
try {
try {
throw FormatException('Exception d'origine');
} catch (e) {
// throw e : réinitialise la trace de pile, perdant l'emplacement d'appel d'origine
print('Utilisation de throw e (perd la trace de pile d'origine)...');
throw e; // La trace de pile commence ici
}
} catch (e, stack) {
print('Attrapé : $e');
print('La trace de pile pointe ici (pas l'emplacement d'origine) :\n$stack');
}
}
控制器层: 处理请求 服务层: 调用数据库操作 正在连接数据库... [日志] 数据库操作异常: Exception: EXAMPLE 数据库连接失败 控制器层捕获到异常 错误信息: Exception: EXAMPLE 数据库连接失败 给用户返回: "服务暂时不可用,请稍后重试" --- rethrow vs throw e 的区别 --- 使用 throw e(丢失原始堆栈)... 捕获: FormatException: 原始异常 堆栈指向这里(不是原始位置): ...
La différence entre rethrow et throw e est cruciale : rethrow préserve la trace de pile complète de l'exception d'origine, ce qui facilite la localisation de la cause racine ; throw e réinitialise la pile et repart de la position actuelle. Lorsque vous devez continuer à propager l'exception après l'avoir journalisée, utilisez rethrow.
Bonnes pratiques pour la gestion des exceptions
| Pratique | Description |
|---|---|
| Ne capturez que les exceptions que vous pouvez gérer. | Ne capturez pas aveuglément toutes les exceptions juste pour « éviter les erreurs ». Si vous ne savez pas comment gérer une exception, laissez-la se propager vers le haut. |
| Capturez par type | Utilisez on pour spécifier le type d'exception, en évitant un seul catch qui avale toutes les exceptions. |
| finally : Nettoyez les ressources | Les ressources telles que les fichiers et les connexions réseau doivent être fermées dans finally. |
| N'avalez pas les exceptions | Capturer une exception et ne rien faire (bloc catch vide) est dangereux ; au minimum, journalisez-la. |
| Utilisez rethrow | Lorsque vous devez journaliser et continuer à propager l'exception, utilisez rethrow au lieu de throw e. |
| Les messages d'exception doivent être spécifiques | throw Exception('Database connection failed: 192.168.1.1:3306') est plus utile que throw Exception('An error occurred') |