Passage de fonctions en arguments

Fait partie de la section Logique & Flux du Journey Dart de Coddy — leçon 45 sur 65.

En programmation, les fonctions peuvent faire plus que simplement accepter des valeurs simples comme des nombres ou des chaînes de caractères - elles peuvent également accepter d'autres fonctions comme paramètres. Ce concept puissant est appelé une fonction d'ordre supérieur, et il ouvre de toutes nouvelles façons d'écrire du code flexible et réutilisable.

Lorsque vous passez une fonction en tant qu'argument, vous donnez essentiellement à une autre fonction la capacité de décider quelle opération effectuer. Considérez cela comme le fait de donner un outil à quelqu'un et de le laisser choisir comment l'utiliser sur différents matériaux.

void processNumbers(List<int> numbers, Function operation) {
  for (int number in numbers) {
    operation(number);
  }
}

Dans cet exemple, processNumbers prend une liste et une fonction comme paramètres. Le paramètre de fonction operation peut être n'importe quelle fonction qui accepte un entier. Cela signifie que vous pourriez passer une fonction qui affiche des nombres, les double, ou effectue toute autre opération dont vous avez besoin.

Cette approche rend votre code incroyablement flexible : au lieu d'écrire des fonctions distinctes pour chaque opération possible, vous écrivez une seule fonction qui peut fonctionner avec de nombreuses opérations différentes en les acceptant comme paramètres.

Défi

Facile

Créez un programme qui démontre le passage de fonctions en tant qu'arguments en construisant un processeur de nombres flexible. Votre programme créera différentes fonctions de traitement et les passera à une fonction de traitement principale qui applique l'opération à une liste de nombres.

Lisez une entrée de type chaîne de caractères contenant des nombres séparés par des virgules (par exemple, "1,2,3,4,5")
Lisez une entrée de type chaîne de caractères représentant le type d'opération ("double", "square", ou "increment")
Divisez la première entrée en une liste de chaînes de caractères et convertissez chacune en un entier
Créez trois fonctions distinctes :

doubleNumber - prend un entier et le retourne multiplié par 2
squareNumber - prend un entier et le retourne multiplié par lui-même
incrementNumber - prend un entier et le retourne plus 1

Créez une fonction principale appelée processNumbers qui prend une liste d'entiers et une fonction comme paramètres
La fonction processNumbers doit appliquer la fonction donnée à chaque nombre de la liste et retourner une nouvelle liste avec les résultats
En fonction du type d'opération saisi, passez la fonction appropriée à processNumbers
Affichez les résultats exactement dans le format indiqué ci-dessous

Par exemple, si les entrées sont "2,4,6,8" et "double", votre programme doit afficher :

Number Processor
================
Original numbers: [2, 4, 6, 8]
Operation: double
Processing numbers...
Result: [4, 8, 12, 16]
Operation completed successfully

Si les entrées sont "3,5,7" et "square", votre programme doit afficher :

Number Processor
================
Original numbers: [3, 5, 7]
Operation: square
Processing numbers...
Result: [9, 25, 49]
Operation completed successfully

Si les entrées sont "10,20,30" et "increment", votre programme doit afficher :

Number Processor
================
Original numbers: [10, 20, 30]
Operation: increment
Processing numbers...
Result: [11, 21, 31]
Operation completed successfully

Votre programme doit démontrer le concept de fonctions d'ordre supérieur en passant l'une des trois fonctions d'opération comme argument à la fonction processNumbers. Utilisez des instructions conditionnelles pour déterminer quelle fonction passer en fonction du type d'opération saisi. La fonction processNumbers doit parcourir la liste d'entrée, appliquer la fonction donnée à chaque élément et collecter les résultats dans une nouvelle liste.

Aide-mémoire

Les fonctions d'ordre supérieur sont des fonctions qui peuvent accepter d'autres fonctions comme paramètres, permettant ainsi un code flexible et réutilisable.

Pour passer une fonction en tant qu'argument, définissez un paramètre de type Function :

void processNumbers(List<int> numbers, Function operation) {
  for (int number in numbers) {
    operation(number);
  }
}

Cela vous permet de passer différentes fonctions pour effectuer diverses opérations sur les mêmes données, rendant votre code plus modulaire et évitant d'avoir à écrire des fonctions distinctes pour chaque opération possible.

Essayez vous-même

import 'dart:io';

void main() {
  // Lire l'entrée
  String? numbersInput = stdin.readLineSync();
  String? operation = stdin.readLineSync();
  
  // Convertir l'entrée de type chaîne en une liste d'entiers
  List<int> numbers = numbersInput!.split(',').map((e) => int.parse(e.trim())).toList();
  
  // TODO: Créer les trois fonctions d'opération (doubleNumber, squareNumber, incrementNumber)
  
  // TODO: Créer la fonction processNumbers qui prend une liste et une fonction comme paramètres
  
  // TODO: Utiliser des instructions conditionnelles pour déterminer quelle fonction passer en fonction du type d'opération
  
  // TODO: Appeler processNumbers avec la fonction appropriée et stocker le résultat
  
  // Afficher les résultats au format requis
  print('Number Processor');
  print('================');
  print('Original numbers: $numbers');
  print('Operation: $operation');
  print('Processing numbers...');
  // TODO: Afficher la liste de résultats ici
  print('Operation completed successfully');
}