Cet article ne cite pas suffisamment ses sources ().
Si vous disposez d'ouvrages ou d'articles de référence ou si vous connaissez des sites web de qualité traitant du thème abordé ici, merci de compléter l'article en donnant les références utiles à sa vérifiabilité et en les liant à la section « Notes et références ».
En pratique : Quelles sources sont attendues ? Comment ajouter mes sources ?
Cet article est une ébauche concernant l’informatique.
En informatique, une fonction de rappel (callback en anglais) ou fonction de post-traitement est une fonction qui est passée en argument à une autre fonction. Cette dernière peut alors faire usage de cette fonction de rappel comme de n'importe quelle autre fonction, alors qu'elle ne la connaît pas par avance.
Principe
La technique de la fonction de rappel s'inspire du principe d'Hollywood (ou Inversion de contrôle) où l'appelant laisse ses coordonnées pour pouvoir être rappelé par la suite. L'intérêt est le passage à un modèle événementiel et modulaire.
Illustration
Prenons l'exemple d'un programme contenant une partie Analyseur effectuant par exemple l'analyse lexicale d'un document. Supposons qu'une partie Traitement du programme, soit capable de compter les occurrences des mots qui lui sont transmis. Si Traitement se déclare en attente d'événements émanant d'Analyseur pour chaque mot reconnu au moyen d'une fonction de rappel, alors le programme global permettra de compter les occurrences des mots du texte analysé. Or, la partie Analyseur ne gère pas spécifiquement le comptage des mots et ne dépend pas de Traitement. Elle peut donc être
réutilisée pour une autre tâche comme le test de la présence de mots-clés.
Pseudo-code de l'Analyseur :
// Variable de type fonction stockant la fonction de rappel
fonction(mot) traiterMot;
// Affectation de la fonction de rappel
fixerFonctionTraitementMot(fonction(mot) f) {
traiterMot <- f;
}
// Corps de l'analyseur
analyse() {
...
traiterMot(mot);
...
}
Pseudo-code du Traitement :
// Définition de la fonction qui sera rappelée
nouvelleOccurrence(mot) {
...
}
Pseudo-code du programme principal :
// préparation du rappel et fixerFonctionTraitementMot(nouvelleOccurrence); //appel de l'analyseur analyse();
Exemple
Dans un tableau de nombres, nous recherchons le premier entier supérieur strictement à 5 parmi les 5 premiers éléments du tableau. (en langage C).
La première approche sans fonction de rappel :
int i;
int length = 5;
for (i = 0; i < length; i++)
{
if (array[i] > 5)
{
printf("Item %d\n", i);
break;
}
}
if (i == length)
{
printf("Not found\n");
}
La seconde avec fonction de rappel :
/* LIBRARY CODE */
int traverseWith(int array[], size_t length,
int (*callback)(int index, int item, void *param),
void *param)
{
int exitCode = 0;
for (int i = 0; i < length; i++) {
exitCode = callback(i, array[i], param);
if (exitCode != 0) {
break;
}
}
return exitCode;
}
/* APPLICATION CODE */
int search (int index, int item, void *param)
{
if (item > 5) {
*(int *)param = index;
return 1;
} else {
return 0;
}
}
/* (in another function) */
int index;
int found;
found = traverseWith(array, length, &search, &index);
if (found) {
printf("Item %d\n", index);
} else {
printf("Not found\n");
}
Mise en œuvre par passage de fonctions en paramètre
Les fonctions de rappel ont été très utilisées en programmation système et notamment en langage C. En effet, le C a permis assez tôt de passer des pointeurs de fonctions en paramètre d'autres fonctions. Cela le rendait techniquement capable d'implémenter le mécanisme des fonctions de rappel.
Le passage de fonction en paramètre est généralisé en programmation fonctionnelle. Toutefois dans ce cadre, on ne parle plus de fonction de rappel. Dans ce paradigme, les fonctions sont des éléments de première classe (au même titre que les constantes par exemple). Aussi, les fonctions qui peuvent prendre d'autres fonctions en argument et/ou renvoyer une fonction comme valeur de retour sont alors qualifiées de fonctions d'ordre supérieur.
Évolution du principe
Avec l'apparition de la programmation objet et des interfaces, la technique de rappel a évolué. On passe maintenant en paramètre un objet qui se conforme à une interface donnée. Il n'y a donc plus une, mais autant de fonctions que l'on souhaite rappeler. De plus le fait de passer un objet permet de contextualiser en indiquant sur quoi s'effectue le rappel, tandis qu'une fonction de rappel précisait seulement comment rappeler. Cependant la technique des fonctions de rappel continue à avoir les faveurs des langages disposant de fermetures, où celles-ci offrent des capacités équivalentes aux objets en termes de contexte.
