Pattern e matching (3.0)

Fa parte della sezione Programmazione orientata agli oggetti del percorso Dart di Coddy. Lezione 87 di 110.

Dart 3 ha introdotto il pattern matching, un potente modo per destrutturare e ispezionare i dati in una singola espressione. I pattern ti permettono di estrarre valori dagli oggetti, verificarne la struttura e associare variabili, tutto in una volta.

Hai già visto il destructuring di base con i record. I pattern estendono questa funzionalità agli oggetti, alle liste e alle mappe:

void main() {
  // Pattern di lista
  var numbers = [1, 2, 3];
  var [a, b, c] = numbers;
  print('$a, $b, $c');  // 1, 2, 3
  
  // Pattern di mappa
  var user = {'name': 'Alice', 'age': 30};
  var {'name': name, 'age': age} = user;
  print('$name is $age');  // Alice is 30
}

I pattern diventano particolarmente potenti nelle espressioni switch. Puoi eseguire corrispondenze simultanee su tipo, valore e struttura:

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));        // Negative number
  print(describe(42));        // Positive number: 42
  print(describe([1, 2, 3])); // List starting with 1
}

La clausola when aggiunge condizioni ai pattern, e ... corrisponde agli elementi rimanenti in una lista. Il trattino basso _ funge da carattere jolly che corrisponde a qualsiasi cosa. Insieme alle classi sealed, i pattern consentono una gestione esaustiva e sicura rispetto ai tipi di strutture dati complesse.

Sfida

Facile

Creiamo un classificatore di dati che usa il pattern matching per analizzare e categorizzare diversi tipi di input! Creerai un sistema in grado di identificare e descrivere varie strutture di dati usando le potenti funzionalità di pattern matching di Dart 3.

Organizzerai il codice in due file:

classifier.dart: Crea una funzione chiamata classify che accetta un parametro Object e restituisce una descrizione String. Usa un'espressione switch con il pattern matching per gestire questi casi:
- Una lista vuota [] dovrebbe restituire Empty list
- Una lista con esattamente un elemento intero dovrebbe restituire Single item: [value]
- Una lista con esattamente due elementi dovrebbe restituire Pair: [first] and [second]
- Una lista che inizia con un intero seguito da altri elementi dovrebbe restituire List starting with [first], length: [total length] (usa il pattern rest ...)
- Una mappa contenente sia le chiavi 'name' che 'age' dovrebbe restituire [name] is [age] years old (usa il destructuring del pattern per le mappe)
- Un intero negativo (usa la clausola when) dovrebbe restituire Negative: [value]
- Un intero uguale a zero dovrebbe restituire Zero
- Qualsiasi altro intero dovrebbe restituire Positive: [value]
- Qualsiasi altro valore dovrebbe restituire Unknown type
main.dart: Importa il tuo classificatore e mostra il pattern matching con vari input. Stampa il risultato della classificazione di ciascuno di questi valori:
- Una lista vuota []
- Una lista con un elemento: [42]
- Una lista con due elementi: ['hello', 'world']
- Una lista più lunga: [1, 2, 3, 4, 5]
- Una mappa: {'name': 'Alice', 'age': 25}
- L'intero -10
- L'intero 0
- L'intero 99

Questa sfida combina i pattern per le liste, i pattern per le mappe, la clausola when per le guardie e il pattern rest (...): tutte le principali funzionalità di pattern matching della lezione!

Output previsto:

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

Provalo tu

import 'classifier.dart';

void main() {
  // TODO: Usa la funzione classify per classificare ogni valore
  // e stampa i risultati
  
  // Prova con una lista vuota
  print(classify([]));
  
  // TODO: Prova con una lista contenente un elemento: [42]
  
  // TODO: Prova con una lista contenente due elementi: ['hello', 'world']
  
  // TODO: Prova con una lista più lunga: [1, 2, 3, 4, 5]
  
  // TODO: Prova con una mappa: {'name': 'Alice', 'age': 25}
  
  // TODO: Prova con l'intero -10
  
  // TODO: Prova con l'intero 0
  
  // TODO: Prova con l'intero 99
}