Classes appelables

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

En Dart, vous pouvez rendre les instances d’une classe appelables comme des fonctions en implémentant la méthode call(). Cela vous permet d’utiliser un objet avec la syntaxe d’appel de fonction, en utilisant directement des parenthèses sur l’instance.

class Multiplier {
  final int factor;
  
  Multiplier(this.factor);
  
  int call(int value) {
    return value * factor;
  }
}

void main() {
  var double = Multiplier(2);
  var triple = Multiplier(3);
  
  print(double(5));   // 10 - appeler l'objet comme une fonction
  print(triple(5));   // 15
}

Lorsque vous écrivez double(5), Dart invoque automatiquement la méthode call() avec 5 comme argument. L’objet se comporte comme une fonction tout en conservant son état (le champ factor).

La méthode call() peut avoir n’importe quelle signature : plusieurs paramètres, des paramètres facultatifs, ou même retourner des types différents :

class Greeter {
  final String greeting;
  
  Greeter(this.greeting);
  
  String call(String name, {String punctuation = '!'}) {
    return '$greeting, $name$punctuation';
  }
}

void main() {
  var hello = Greeter('Hello');
  print(hello('Alice'));              // Bonjour, Alice !
  print(hello('Bob', punctuation: '.')); // Bonjour, Bob.
}

Les classes appelables sont utiles lorsque vous avez besoin d’un comportement semblable à celui d’une fonction, associé à un état ou à une configuration. Elles sont couramment utilisées pour créer des opérations, des validateurs ou des transformations réutilisables qui doivent conserver des paramètres entre les appels.

Défi

Facile

Construisons un système de formatage de texte à l'aide de classes appelables ! Vous créerez des objets qui peuvent être appelés comme des fonctions pour transformer du texte de différentes manières, tout en conservant leurs propres paramètres de configuration.

Vous organiserez votre code dans deux fichiers :

formatters.dart : créez deux classes appelables qui transforment le texte :
- Une classe Wrapper qui entoure le texte d'un préfixe et d'un suffixe. Elle doit stocker un String prefix et un String suffix et, lorsqu'elle est appelée avec un paramètre String text, renvoyer le texte entouré du préfixe et du suffixe.
- Une classe Repeater qui répète le texte un certain nombre de fois. Elle doit stocker une valeur int times et, lorsqu'elle est appelée avec un paramètre String text, renvoyer le texte répété ce nombre de fois, avec un espace entre chaque répétition.
main.dart : importez vos formateurs et montrez comment fonctionnent les classes appelables :
- Créez un Wrapper avec le préfixe "[" et le suffixe "]"
- Créez un autre Wrapper avec le préfixe "***" et le suffixe "***"
- Créez un Repeater qui répète 3 fois
- Appelez le premier wrapper avec "Hello" et affichez le résultat
- Appelez le deuxième wrapper avec "Important" et affichez le résultat
- Appelez le répéteur avec "Go" et affichez le résultat
- Enfin, combinez-les : appelez le premier wrapper avec le résultat de l'appel du répéteur avec "Dart", puis affichez le résultat

Remarquez comment chaque objet formateur mémorise sa configuration et peut être appelé directement avec des parenthèses, exactement comme une fonction !

Résultat attendu :

[Hello]
***Important***
Go Go Go
[Dart Dart Dart]

Essayez vous-même

import 'formatters.dart';

void main() {
  // TODO: Créez un Wrapper avec le préfixe "[" et le suffixe "]"
  
  // TODO: Créez un autre Wrapper avec le préfixe "***" et le suffixe "***"
  
  // TODO: Créez un Repeater qui répète 3 fois
  
  // TODO: Appelez le premier wrapper avec "Hello" et affichez le résultat
  
  // TODO: Appelez le second wrapper avec "Important" et affichez le résultat
  
  // TODO: Appelez le repeater avec "Go" et affichez le résultat
  
  // TODO: Combinez-les : appelez le premier wrapper avec le résultat de
  // l'appel du repeater avec "Dart", et affichez le résultat
  
}