Dart typedef et types de fonctions
typedef est le mécanisme d'alias de type dans Dart, qui permet de définir des noms courts et lisibles pour des types complexes.
Ce chapitre présente deux utilisations de typedef : l'alias de type de fonction traditionnel et l'alias de type générique introduit dans Dart 3.0.
typedef, alias de type de fonction
Lorsqu'un type de fonction est utilisé fréquemment, typedef peut lui donner un nom clair.
C'est particulièrement utile pour des scénarios tels que les fonctions de rappel et les gestionnaires d'événements.
Exemple
// Représente : une fonction qui prend deux paramètres int et renvoie int
typedef IntOperation = int Function(int a, int b);
// Définir un type de rappel
// Représente : une fonction qui reçoit un message String et ne renvoie aucune valeur
typedef MessageCallback = void Function(String message);
// Utiliser un typedef comme type de paramètre
int performOperation(int x, int y, IntOperation operation) {
return operation(x, y);
}
void logMessage(String msg, MessageCallback callback) {
print('Préparation de la sortie du message...');
callback('[EXEMPLE] $msg');
}
void main() {
// Passez une fonction qui correspond à la signature d'IntOperation
int add(int a, int b) => a + b;
int multiply(int a, int b) => a * b;
print('10 + 5 = ${performOperation(10, 5, add)}');
print('10 × 5 = ${performOperation(10, 5, multiply)}');
// Vous pouvez également passer directement une fonction anonyme
int result = performOperation(20, 4, (a, b) => a ~/ b);
print('20 ÷ 4 = $result');
// Utilisez MessageCallback
logMessage('Opération terminée', (msg) {
print('Message reçu : $msg');
});
}
10 + 5 = 15 10 × 5 = 50 20 ÷ 4 = 5 准备输出消息... 收到消息: [EXAMPLE] 操作完成
Sans typedef, vous devez écrire de manière répétée des signatures de type de fonction verbeuses à chaque position de paramètre.
Avec typedef, les déclarations de type deviennent claires et unifiées, et les modifications ne doivent être apportées qu'à un seul endroit.
typedef n'est qu'un alias pour un type ; il ne crée pas un nouveau type. IntOperation et int Function(int, int) sont complètement équivalents dans le système de types.
Type de fonction comme paramètre
En Dart, les fonctions sont des citoyens de première classe et peuvent être transmises comme des valeurs ordinaires.
Exemple
void processNumbers(
List<int> numbers,
bool Function(int) filter,
String Function(int) formatter,
) {
var filtered = numbers.where(filter);
for (var n in filtered) {
print(formatter(n));
}
}
// Une fonction d'ordre supérieur qui renvoie une fonction
int Function(int) makeMultiplier(int factor) {
// La fermeture renvoyée capture factor
return (int n) => n * factor;
}
void main() {
var scores = [55, 78, 92, 60, 45, 88];
print('--- Score de passage ---');
processNumbers(
scores,
(n) => n >= 60, // Condition de filtrage
(n) => 'EXEMPLE Score : $n points', // Formatage
);
print('--- Scores élevés (> 80) ---');
processNumbers(
scores,
(n) => n > 80,
(n) => 'Meilleur score : $n points',
);
// Fonction comme valeur de retour
var doubler = makeMultiplier(2);
var tripler = makeMultiplier(3);
print('5 × 2 = ${doubler(5)}');
print('5 × 3 = ${tripler(5)}');
}
--- 及格分数 --- EXAMPLE 分数: 78 分 EXAMPLE 分数: 92 分 EXAMPLE 分数: 60 分 EXAMPLE 分数: 88 分 --- 高分(> 80)--- 高分: 92 分 高分: 88 分 5 × 2 = 10 5 × 3 = 15
Modèle de callback
Le modèle de callback est le scénario d'application le plus courant pour les types de fonction.
Il délègue le contrôle de "ce qu'il faut faire" à l'appelant, rendant le code plus flexible et réutilisable.
Exemple
typedef ResultCallback<T> = void Function(T result);
typedef ErrorCallback = void Function(String error);
// Simuler une opération asynchrone
void fetchUserData(
String userId, {
required ResultCallback<Map<String, dynamic>> onSuccess,
required ErrorCallback onError,
}) {
// Simuler une requête réseau
print('Fetching user data...');
// Simuler un succès/un échec
if (userId == 'example') {
var data = {
'id': 'exemple',
'name': 'EXEMPLE utilisateur',
'level': 'VIP',
};
onSuccess(data);
} else {
onError('L’utilisateur $userId n’existe pas');
}
}
void main() {
// Utiliser un callback pour gérer le résultat
fetchUserData(
'example',
onSuccess: (data) {
print('Récupération réussie!');
print('Nom d’utilisateur: ${data['name']}');
print('Niveau: ${data['level']}');
},
onError: (error) {
print('Échec de la récupération: $error');
},
);
print('---');
// Skenario kegagalan pengujian
fetchUserData(
'unknown',
onSuccess: (data) {
print(Fetch);
},
onError: (error) {
print('Échec de la récupération: $error');
},
);
}
正在获取用户数据... 获取成功! 用户名: EXAMPLE 用户 等级: VIP --- 正在获取用户数据... 获取失败: 用户 unknown 不存在
Skenario aplikasi umum untuk callback:
| Scénarios | Contoh Tipe Callback |
|---|---|
| Requête réseau | onSuccess(data) / onError(error) |
| Peristiwa UI | onTap() / onLongPress() |
| Konversi data | Callback di map(), where(), select() |
| Minuteur | Timer(callback, duration) |
| Animasi selesai | onComplete() |
Bien que le modèle de rappel (callback) soit flexible, il conduit à l'enfer des callbacks lors du traitement d'opérations asynchrones à plusieurs niveaux. Dart fournit async/await pour gérer les flux asynchrones de manière plus élégante, ce que nous couvrirons en détail au chapitre 17.
Alias de type générique dans Dart 3.0
Dart 3.0 étend les capacités de typedef ; vous pouvez désormais créer des alias pour n'importe quel type, pas seulement pour les types de fonction.
Exemple
// Alias pour les types de collections complexes
typedef JsonMap = Map<String, dynamic>;
typedef UserList = List<Map<String, dynamic>>;
// Alias génériques
typedef Result<T> = ({T data, String? error});
// Alias de types de fonction (utilisation traditionnelle)
typedef Validator<T> = String? Function(T value);
// Utilisation d'alias de type
void processJson(JsonMap json) {
print('Traitement du JSON : $json');
print('Nombre de clés : ${json.length}');
}
void validateAndPrint<T>(T value, Validator<T> validator) {
var error = validator(value);
if (error != null) {
print('Échec de la validation : $error');
} else {
print('Validation réussie : $value');
}
}
void main() {
// Utilisation de l'alias JsonMap
JsonMap userData = {
'name': 'example',
'age': 10,
'isVip': true,
};
processJson(userData);
// Utilisation de l'alias Result
Result<String> successResult = (data: 'Opération réussie', error: null);
Result<String> errorResult = (data: '', error: 'Délai de connexion réseau dépassé');
print('Succès : ${successResult.data}');
print('Échec : ${errorResult.error}');
// Utilisation du Validator générique
Validator<String> nameValidator = (value) {
if (value.isEmpty) return 'Le nom ne peut pas être vide';
if (value.length < 3) return 'Le nom doit comporter au moins 3 caractères';
return null; // null signifie que la validation a réussi
};
validateAndPrint('EXAMPLE', nameValidator);
validateAndPrint('AB', nameValidator);
}
处理 JSON: {name: example, age: 10, isVip: true}
键的数量: 3
Success: 操作成功
失败: 网络连接超时
验证通过: EXAMPLE
验证失败: 名称至少 3 个字符
Les alias de type de Dart 3.0 réduisent considérablement les déclarations de type verbeuses, ce qui rend le code plus concis et lisible.
autres extensionsLes alias de type (typedef) et les types eux-mêmes sont complètement équivalents à l'exécution ; ce ne sont que des « surnoms » à la compilation. Cela signifie que vous ne pouvez pas utiliser typedef pour distinguer deux types structurellement identiques mais sémantiquement différents — ils sont traités comme le même type.