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

// Définir un alias de type de fonction
// 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

// Utiliser directement les types de fonction pour déclarer des paramètres (sans typedef)
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

// Définir le type de callback
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énariosContoh Tipe Callback
Requête réseauonSuccess(data) / onError(error)
Peristiwa UIonTap() / onLongPress()
Konversi dataCallback di map(), where(), select()
MinuteurTimer(callback, duration)
Animasi selesaionComplete()

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

// Dart 3.0 : typedef peut créer des alias pour n'importe quel type

// 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.

Les 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.

autres extensions