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