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 des parenthèses directement 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 appelle 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 optionnels, ou même retourner différents types :

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'));              // Hello, Alice!
  print(hello('Bob', punctuation: '.')); // Hello, Bob.
}

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

Défi

Facile

Construisons un système de formatage de texte en utilisant des classes appelables (callable classes) ! Vous allez créer 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 en deux fichiers :

formatters.dart : Créez deux classes appelables qui transforment le texte :
- Une classe Wrapper qui enveloppe le texte avec un préfixe et un suffixe. Elle doit stocker un String prefix et un String suffix, et lorsqu'elle est appelée avec un paramètre String text, elle doit retourner le texte enveloppé entre le préfixe et le 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, elle doit retourner le texte répété ce nombre de fois avec un espace entre chaque répétition.
main.dart : Importez vos formateurs et démontrez le fonctionnement des 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 repeater avec "Go" et affichez le résultat
- Enfin, combinez-les : appelez le premier wrapper avec le résultat de l'appel du repeater avec "Dart", et affichez le résultat

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

Résultat attendu :

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

Aide-mémoire

Les classes peuvent être rendues appelables comme des fonctions en implémentant la méthode call() :

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

void main() {
  var double = Multiplier(2);
  print(double(5));   // 10 - appel de l'objet comme une fonction
}

La méthode call() peut avoir n'importe quelle signature avec plusieurs paramètres, des paramètres optionnels ou différents types de retour :

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'));              // Hello, Alice!
  print(hello('Bob', punctuation: '.')); // Hello, Bob.
}

Les classes appelables sont utiles pour créer un comportement semblable à celui d'une fonction combiné à un état ou une configuration.

Essayez vous-même

import 'formatters.dart';

void main() {
  // TODO: Créer un Wrapper avec le préfixe "[" et le suffixe "]"
  
  // TODO: Créer un autre Wrapper avec le préfixe "***" et le suffixe "***"
  
  // TODO: Créer un Repeater qui répète 3 fois
  
  // TODO: Appeler le premier wrapper avec "Hello" et afficher le résultat
  
  // TODO: Appeler le second wrapper avec "Important" et afficher le résultat
  
  // TODO: Appeler le repeater avec "Go" et afficher le résultat
  
  // TODO: Les combiner : appeler le premier wrapper avec le résultat de
  // l'appel du repeater avec "Dart", et afficher le résultat
  
}