Patterns et Matching (3.0)

Fait partie de la section Programmation Orientée Objet du Journey Dart de Coddy — leçon 87 sur 110.

Dart 3 a introduit le filtrage de motifs (pattern matching), un moyen puissant de déstructurer et d'inspecter des données en une seule expression. Les motifs vous permettent d'extraire des valeurs d'objets, de vérifier leur structure et de lier des variables, le tout en une seule fois.

Vous avez déjà vu la déstructuration de base avec les records. Les patterns étendent cela pour fonctionner avec les objets, les listes et les maps :

void main() {
  // Patterns de liste
  var numbers = [1, 2, 3];
  var [a, b, c] = numbers;
  print('$a, $b, $c');  // 1, 2, 3
  
  // Patterns de map
  var user = {'name': 'Alice', 'age': 30};
  var {'name': name, 'age': age} = user;
  print('$name is $age');  // Alice is 30
}

Les motifs (patterns) deviennent particulièrement puissants dans les expressions switch. Vous pouvez effectuer une correspondance sur le type, la valeur et la structure simultanément :

String describe(Object obj) {
  return switch (obj) {
    int n when n < 0 => 'Negative number',
    int n => 'Positive number: $n',
    String s => 'String of length ${s.length}',
    [int first, ...] => 'List starting with $first',
    _ => 'Something else',
  };
}

void main() {
  print(describe(-5));        // Nombre négatif
  print(describe(42));        // Nombre positif : 42
  print(describe([1, 2, 3])); // Liste commençant par 1
}

La clause when ajoute des conditions aux motifs, et ... correspond aux éléments restants d'une liste. Le tiret bas _ agit comme un caractère générique qui correspond à n'importe quoi. Combinés avec des classes scellées, les motifs permettent une gestion exhaustive et sécurisée du point de vue des types (type-safe) des structures de données complexes.

Défi

Facile

Construisons un classificateur de données qui utilise le filtrage par motif (pattern matching) pour analyser et catégoriser différents types d'entrées ! Vous allez créer un système capable d'identifier et de décrire diverses structures de données en utilisant les puissantes fonctionnalités de pattern matching de Dart 3.

Vous organiserez votre code dans deux fichiers :

classifier.dart : Créez une fonction appelée classify qui prend un paramètre Object et retourne une description sous forme de String. Utilisez une expression switch avec pattern matching pour gérer ces cas :
- Une liste vide [] doit retourner Empty list
- Une liste avec exactement un élément entier doit retourner Single item: [value]
- Une liste avec exactement deux éléments doit retourner Pair: [first] and [second]
- Une liste commençant par un entier suivi d'autres éléments doit retourner List starting with [first], length: [total length] (utilisez le motif de reste ...)
- Un map contenant à la fois les clés 'name' et 'age' doit retourner [name] is [age] years old (utilisez la déstructuration de motif de map)
- Un entier négatif (utilisez la clause when) doit retourner Negative: [value]
- Un entier qui est zéro doit retourner Zero
- Tout autre entier doit retourner Positive: [value]
- Toute autre valeur doit retourner Unknown type
main.dart : Importez votre classificateur et démontrez le pattern matching avec diverses entrées. Affichez le résultat de la classification de chacune de ces valeurs :
- Une liste vide []
- Une liste avec un élément : [42]
- Une liste avec deux éléments : ['hello', 'world']
- Une liste plus longue : [1, 2, 3, 4, 5]
- Un map : {'name': 'Alice', 'age': 25}
- L'entier -10
- L'entier 0
- L'entier 99

Ce défi combine les motifs de liste, les motifs de map, la clause when pour les gardes, et le motif de reste (...) - toutes les fonctionnalités clés du pattern matching de la leçon !

Sortie attendue :

Empty list
Single item: 42
Pair: hello and world
List starting with 1, length: 5
Alice is 25 years old
Negative: -10
Zero
Positive: 99

Aide-mémoire

Dart 3 a introduit le pattern matching (filtrage par motif) pour la déstructuration et l'inspection des données dans une seule expression.

Motifs de Liste (List Patterns)

Extraire des valeurs à partir de listes :

var numbers = [1, 2, 3];
var [a, b, c] = numbers;
print('$a, $b, $c');  // 1, 2, 3

Motifs de Map (Map Patterns)

Déstructurer des maps par clé :

var user = {'name': 'Alice', 'age': 30};
var {'name': name, 'age': age} = user;
print('$name is $age');  // Alice is 30

Expressions Switch avec Motifs

Filtrer par type, valeur et structure :

String describe(Object obj) {
  return switch (obj) {
    int n when n < 0 => 'Negative number',
    int n => 'Positive number: $n',
    String s => 'String of length ${s.length}',
    [int first, ...] => 'List starting with $first',
    _ => 'Something else',
  };
}

Fonctionnalités des Motifs

Clause when : Ajoute des conditions aux motifs
... (motif de reste) : Correspond aux éléments restants dans une liste
_ (wildcard) : Correspond à n'importe quoi

Essayez vous-même

import 'classifier.dart';

void main() {
  // TODO: Utiliser la fonction classify pour catégoriser chaque valeur
  // et afficher les résultats
  
  // Tester avec une liste vide
  print(classify([]));
  
  // TODO: Tester avec une liste contenant un élément : [42]
  
  // TODO: Tester avec une liste contenant deux éléments : ['hello', 'world']
  
  // TODO: Tester avec une liste plus longue : [1, 2, 3, 4, 5]
  
  // TODO: Tester avec une map : {'name': 'Alice', 'age': 25}
  
  // TODO: Tester avec l'entier -10
  
  // TODO: Tester avec l'entier 0
  
  // TODO: Tester avec l'entier 99
}