Génériques Dart

Les génériques vous permettent d'éviter de spécifier des types concrets lors de l'écriture du code, en utilisant à la place des paramètres de type comme espaces réservés, et en déterminant les types réels au moment de l'utilisation.

La valeur essentielle des génériques estla sécurité de typeetla réutilisation du code—Un même code s'adapte à plusieurs types, tandis que le compilateur vérifie les erreurs de type pour vous.


Pourquoi les génériques sont nécessaires

Tout d'abord, examinons un problème sans génériques.

Exemple

Écriture sans génériques :

// Sans génériques : on ne peut stocker que des Object, et un cast manuel est nécessaire lors de la récupération
class IntBox {
  int value;
  IntBox(this.value);
}

class StringBox {
  String value;
  StringBox(this.value);
}

// Chaque fois qu'un nouveau type est ajouté, une nouvelle classe Box doit être écrite, ce qui entraîne beaucoup de code dupliqué

void main() {
  var intBox = IntBox(42);
  var stringBox = StringBox('EXAMPLE');

  print('Integer: ${intBox.value}');
  print('String: ${stringBox.value}');
}

Existe-t-il un moyen d'écrire une classe Box pouvant contenir à la fois int et String, tout en garantissant la sûreté de type à la compilation ?

C'est le problème que les génériques visent à résoudre.


Classe générique

Une classe générique déclare des paramètres de type après le nom de la classe en utilisant des chevrons <>, et utilise ce paramètre de type à l'intérieur de la classe.

Exemple

// <T> est un paramètre de type ; T est un espace réservé représentant "un certain type"
// Convention de nommage : T (Type), E (Élément), K (Clé), V (Valeur)
class Box<T> {
  T value;

  Box(this.value);

  T getValue() {
    return value;
  }

  void setValue(T newValue) {
    value = newValue;
  }

  void printValue() {
    print('Valeur dans la boîte : $value (Type : ${value.runtimeType})');
  }
}

void main() {
  // Spécifiez un type concret lors de l'utilisation d'une classe générique
  var intBox = Box<int>(42);
  var stringBox = Box<String>('EXEMPLE Tutoriel Dart');
  var doubleBox = Box<double>(3.14);

  intBox.printValue();
  stringBox.printValue();
  doubleBox.printValue();

  // Sécurité des types : le code suivant provoquera une erreur de compilation
  // intBox.setValue('hello'); // Erreur : String ne peut pas être assigné à int

  // Inférence de type : Dart peut inférer les types à partir des arguments du constructeur
  var autoBox = Box('Automatiquement inféré comme String');
  print('Type inféré: ${autoBox.value.runtimeType}');
}
Box 中的值: 42 (类型: int)
Box 中的值: EXAMPLE Dart 教程 (类型: String)
Box 中的值: 3.14 (类型: double)
推断类型: String

Plusieurs paramètres de type

Une classe générique peut avoir plusieurs paramètres de type.

Exemple

// K représente le type des clés, V représente le type des valeurs
class Pair<K, V> {
  K key;
  V value;

  Pair(this.key, this.value);

  @override
  String toString() => 'Pair($key: $value)';
}

void main() {
  var pair1 = Pair<String, int>('exemple', 10);
  var pair2 = Pair('score', 95.5);  // Inférence de type

  print(pair1);
  print(pair2);
}
Pair(example: 10)
Pair(score: 95.5)

Méthodes génériques

En plus des classes génériques, les fonctions et les méthodes peuvent aussi utiliser des génériques.

Exemple

// Fonction générique : le type de retour et le type du paramètre correspondent
// Déclarer <T> avant le type de retour
T firstElement<T>(List<T> list) {
  if (list.isEmpty) {
    throw ArgumentError('La liste ne peut pas être vide');
  }
  return list[0];
}

// Fonction générique : échanger deux valeurs
void swap<T>(List<T> list, int i, int j) {
  T temp = list[i];
  list[i] = list[j];
  list[j] = temp;
}

void main() {
  // Dart infère automatiquement le type lors de l'appel
  var names = ['example', 'Dart', 'Flutter'];
  print('Prénom : ${firstElement(names)}');

  var scores = [95, 88, 72];
  print('Premier score : ${firstElement(scores)}');

  // Échanger les éléments
  var items = ['A', 'B', 'C'];
  print('Avant la permutation : $items');
  swap(items, 0, 2);
  print('Après la permutation : $items');
}
第一个名字: example
第一个分数: 95
交换前: [A, B, C]
交换后: [C, B, A]

Contraintes de type extends

Parfois, vous voulez qu’un paramètre de type soit restreint à des sous-types de certains types.

En utilisant le mot-clé extends, vous pouvez imposer des contraintes sur les paramètres génériques.

Exemple

// Définir une calculatrice numérique
// <T extends num> contraint T à être num ou ses sous-classes (int, double)
class Calculator<T extends num> {
  T a;
  T b;

  Calculator(this.a, this.b);

  // Comme T est contraint d’étendre num, les méthodes de num peuvent être utilisées en toute sécurité.
  double add() => (a + b).toDouble();
  double subtract() => (a - b).toDouble();
  double multiply() => (a * b).toDouble();
  double divide() => a / b;

  void printOperations() {
    print('EXEMPLE calculatrice : $a et $b');
    print(' Addition : ${add()}');
    print(' Soustraction : ${subtract()}');
    print(' Multiplication : ${multiply()}');
    print(' Division : ${divide().toStringAsFixed(2)}');
  }
}

void main() {
  var intCalc = Calculator<int>(10, 3);
  intCalc.printOperations();

  var doubleCalc = Calculator<double>(3.5, 1.5);
  doubleCalc.printOperations();

  // La ligne suivante signalera une erreur : String n'est pas une sous-classe de num.
  // var strCalc = Calculator<String>('a', 'b'); // Erreur !
}
EXAMPLE 计算器: 10 和 3
  加: 13.0
  减: 7.0
  乘: 30.0
  除: 3.33
EXAMPLE 计算器: 3.5 和 1.5
  加: 5.0
  减: 2.0
  乘: 5.25
  除: 2.33

Les contraintes de type vous permettent de conserver la flexibilité des génériques tout en utilisant les méthodes du type contraint. Par exemple, avec la contrainte T extends num ci-dessus, vous pouvez utiliser des opérateurs tels que +, -, *, / dans le corps de la méthode, car le type num prend en charge ces opérations.


Utilisation de collections génériques

Les classes de collection principales de Dart (List, Set, Map) sont toutes génériques.

L'utilisation de collections génériques permet une vérification des types à la compilation.

Exemple

void main() {
  // Spécifier le type d'élément comme String
  List<String> names = ['example', 'Dart', 'Flutter'];
  // names.add(42); // Erreur : int ne peut pas être ajouté à List<String>

  // Spécifier les types clé-valeur
  Map<String, int> scores = {
    'example': 95,
    'Alice': 87,
  };
  // scores['Bob'] = 'Excellent'; // Erreur : String ne peut pas être affecté à int

  // Spécifier le type d'élément de Set
  Set<double> prices = {9.99, 19.99, 29.99};

  // Opérations fonctionnelles sur les collections génériques
  List<int> numbers = [1, 2, 3, 4, 5, 6];

  // Filtrage et mappage sûrs au niveau du type
  List<int> evenNumbers = numbers.where((n) => n % 2 == 0).toList();
  List<String> labels = numbers.map((n) => 'EXAMPLE-$n').toList();

  print(Nombres pairs : $evenNumbers);
  print(Étiquettes : $labels);

  // Utiliser fold pour une accumulation sûre au niveau du type
  int sum = numbers.fold<int>(0, (prev, n) => prev + n);
  print(Somme : $sum);
}
偶数: [2, 4, 6]
标签: [EXAMPLE-1, EXAMPLE-2, EXAMPLE-3, EXAMPLE-4, EXAMPLE-5, EXAMPLE-6]
总和: 21

Application pratique : Repository Pattern générique

L'une des applications les plus classiques des génériques dans le développement réel est le "Repository Pattern".

Exemple

// Définir une interface Repository générique
abstract class Repository<T> {
  void add(T item);
  void remove(T item);
  T? findById(String id);
  List<T> getAll();
}

// Modèle User
class User {
  String id;
  String name;

  User(this.id, this.name);

  @override
  String toString() => 'User($id, $name)';
}

// Modèle Product
class Product {
  String id;
  String name;
  double price;

  Product(this.id, this.name, this.price);

  @override
  String toString() => 'Product($name, ¥$price)';
}

// Implémentation concrète : dépôt User
class UserRepository implements Repository<User> {
  final List<User> _users = [];

  @override
  void add(User user) => _users.add(user);

  @override
  void remove(User user) => _users.remove(user);

  @override
  User? findById(String id) {
    try {
      return _users.firstWhere((u) => u.id == id);
    } catch (_) {
      return null;
    }
  }

  @override
  List<User> getAll() => List.unmodifiable(_users);
}

// Implémentation concrète : dépôt de produits (même interface, types différents)
class ProductRepository implements Repository<Product> {
  final List<Product> _products = [];

  @override
  void add(Product product) => _products.add(product);

  @override
  void remove(Product product) => _products.remove(product);

  @override
  Product? findById(String id) {
    try {
      return _products.firstWhere((p) => p.id == id);
    } catch (_) {
      return null;
    }
  }

  @override
  List<Product> getAll() => List.unmodifiable(_products);
}

void main() {
  var userRepo = UserRepository();
  userRepo.add(User('u1', 'example'));
  userRepo.add(User('u2', 'Alice'));

  var productRepo = ProductRepository();
  productRepo.add(Product('p1', Tutoriel Dart, 29.99));
  productRepo.add(Product('p2', Tutoriel Flutter, 49.99));

  print(Liste des utilisateurs : ${userRepo.getAll()});
  print(Liste des produits : ${productRepo.getAll()});
  print(Rechercher l'utilisateur u1 : ${userRepo.findById(u1')}');
  print(Rechercher le produit p2 : ${productRepo.findById(p2')}');
}
用户列表: [User(u1, example), User(u2, Alice)]
商品列表: [Product(Dart 教程, ¥29.99), Product(Flutter 教程, ¥49.99)]
查找用户 u1: User(u1, example)
查找商品 p2: Product(Flutter 教程, ¥49.99)

Le modèle de référentiel générique vous permet de gérer différents types de données avec une interface unifiée, garantissant la sécurité des types tout en évitant la duplication de code.

autres extensions