Enregistrements (Dart 3)

Fait partie de la section Programmation Orientée Objet du Journey Dart de Coddy. Leçon 86 sur 110.

Dart 3 a introduit les records : une manière légère de regrouper plusieurs valeurs sans créer une classe complète. Les records sont immuables, disposent d’une égalité intégrée et sont parfaits pour renvoyer plusieurs valeurs depuis une fonction ou regrouper temporairement des données associées.

Créez un enregistrement en plaçant les valeurs entre parenthèses :

void main() {
  // Un enregistrement simple avec deux valeurs
  var point = (10, 20);
  print(point.$1);  // 10 - accès au premier élément
  print(point.$2);  // 20 - accès au deuxième élément
  
  // Enregistrements avec des champs nommés
  var person = (name: 'Alice', age: 30);
  print(person.name);  // Alice
  print(person.age);   // 30
}

Les champs positionnels sont accessibles avec $1, $2, etc., tandis que les champs nommés utilisent directement leurs noms. Vous pouvez mélanger les deux styles dans un seul enregistrement.

Les enregistrements sont particulièrement utiles lorsqu’il faut renvoyer plusieurs valeurs depuis des fonctions : nul besoin de créer une classe simplement pour renvoyer deux éléments de données :

(int, int) divideWithRemainder(int a, int b) {
  return (a ~/ b, a % b);
}

(String name, int age) getUser() {
  return ('Bob', 25);
}

void main() {
  var (quotient, remainder) = divideWithRemainder(17, 5);
  print('$quotient remainder $remainder');  // 3 reste 2
  
  var (name, age) = getUser();
  print('$name is $age');  // Bob a 25 ans
}

Les enregistrements prennent automatiquement en charge l’égalité en fonction de leurs valeurs, ce qui les rend pratiques pour les comparaisons sans avoir à implémenter vous-même ==. Utilisez les enregistrements lorsque vous avez besoin de regroupements de données simples et immuables ; utilisez les classes lorsque vous avez besoin de méthodes, de mutabilité ou d’un comportement plus complexe.

Défi

Facile

Construisons un système de coordonnées à l'aide d'enregistrements ! Vous allez créer des fonctions qui travaillent avec des points 2D représentés sous forme d'enregistrements, afin de montrer comment les enregistrements permettent de renvoyer et de manipuler facilement plusieurs valeurs associées sans créer de classes complètes.

Vous organiserez votre code en deux fichiers :

geometry.dart : créez des fonctions qui utilisent des enregistrements pour travailler avec des données de coordonnées :
- Une fonction createPoint(int x, int y) qui renvoie un enregistrement avec les champs nommés x et y. Le type de retour doit être ({int x, int y})
- Une fonction midpoint(({int x, int y}) p1, ({int x, int y}) p2) qui calcule et renvoie le point central entre deux points sous forme d'un enregistrement avec des champs nommés. Utilisez la division entière (~/) pour le calcul
- Une fonction distance(({int x, int y}) p1, ({int x, int y}) p2) qui renvoie un enregistrement avec des champs positionnels : la distance horizontale (différence en x) et la distance verticale (différence en y). Le type de retour doit être (int, int). Calculez-les avec p2.x - p1.x et p2.y - p1.y
main.dart : importez votre fichier de géométrie et montrez les enregistrements en action :
- Créez deux points avec createPoint : le point A en (2, 4) et le point B en (10, 8)
- Affichez Point A: ([x], [y]) en utilisant les champs nommés
- Affichez Point B: ([x], [y]) en utilisant les champs nommés
- Calculez le point central et affichez Midpoint: ([x], [y])
- Calculez la distance et utilisez la déstructuration pour extraire les valeurs dans les variables dx et dy, puis affichez Distance: dx=[dx], dy=[dy]

Remarquez comment les enregistrements vous permettent de renvoyer plusieurs valeurs proprement : des champs nommés pour plus de clarté lorsque leur signification est importante, et des champs positionnels lorsque le contexte est évident !

Sortie attendue :

Point A: (2, 4)
Point B: (10, 8)
Midpoint: (6, 6)
Distance: dx=8, dy=4

Essayez vous-même

import 'geometry.dart';

void main() {
  // TODO: Créer le point A à (2, 4) en utilisant createPoint
  
  // TODO: Créer le point B à (10, 8) en utilisant createPoint
  
  // TODO: Afficher le Point A en utilisant les champs nommés : Point A: ([x], [y])
  
  // TODO: Afficher le Point B en utilisant les champs nommés : Point B: ([x], [y])
  
  // TODO: Calculer le point milieu et l'afficher : Midpoint: ([x], [y])
  
  // TODO: Calculer la distance et utiliser la déstructuration pour l'extraire dans dx et dy
  // Ensuite, afficher : Distance: dx=[dx], dy=[dy]
}