Fonction de rappel - Définition

Introduction

En informatique, une fonction de rappel (callback en anglais) 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 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.

Exemple

Dans un tableau de nombres, nous recherchons le premier entier supérieur à 5. (en langage C)

La première approche sans fonction de rappel:

        int i;              for (i = 0; i < length; i++)       {           if (array[i] > 5)            {                break;           }       }              if (i < length)        {           printf("Item %d\n", i);       }       else       {           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");       }      

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();      

É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.