Aller au contenu
YouTurkey Tech
Tous les sujets JavaScript

call, apply & bind

Intermédiaire

Comment call, apply et bind choisissent le this d'une fonction, ce qui les distingue, et comment écrire bind soi-même avec une closure.S'appuie sur The this Keyword, Closures

Pile d'appels

Vide

Portées

Vide

Tas

Vide

Console

Vide

0/18Appuyez sur Lecture, ou avancez pas à pas avec les flèches, pour commencer.
Étape 0 sur 18

Explication

Lecture : 2 min

Sur cette page

Que sont call, apply et bind en JavaScript ?

call, apply et bind sont des méthodes dont chaque fonction hérite via Function.prototype. Elles permettent de choisir soi-même le this d'une fonction, au lieu de le laisser dépendre de la façon dont elle est appelée :

  • fn.call(thisArg, a, b) exécute fn tout de suite, avec les arguments un par un.
  • fn.apply(thisArg, [a, b]) exécute fn tout de suite, avec les arguments dans un tableau.
  • fn.bind(thisArg, a) n'exécute rien. Elle renvoie une nouvelle fonction dont le this est fixé, et dont les premiers arguments peuvent être remplis à l'avance (application partielle).

Un moyen simple de retenir les deux premières : Apply prend un Array (tableau), Call prend des Commas (virgules).

Comment call, apply et bind fixent-ils this ?

  • call et apply sont une liaison explicite : pour cet appel-là, this est le premier argument.
  • bind est une closure autour de apply. La nouvelle fonction retient la fonction d'origine, le this et les arguments prédéfinis, et appelle fn.apply(thisArg, [...preset, ...args]) à chaque exécution.
  • Le this d'une fonction liée est définitif. L'appeler avec call ou apply, ou la lier de nouveau, ne le change pas. Seul new passe outre, car new crée toujours un objet neuf.
  • Les fonctions fléchées ignorent le thisArg des trois : elles n'ont pas de this propre à fixer.

Quelles erreurs fait-on souvent avec call, apply et bind ?

Mini-exemple

const multiply = (a, b) => a * b;const double = multiply.bind(null, 2); // partial applicationconsole.log(double(5)); // 10 function listArgs() {  // Borrow an array method for the array-like `arguments`.  return Array.prototype.join.call(arguments, ' + ');}console.log(listArgs(1, 2, 3)); // '1 + 2 + 3'

Test rapide

Si who renvoie this.id, que renvoie who.bind({ id: "a" }).call({ id: "b" }) ?

Pour aller plus loin

Toutes les étapes en texte
  1. Étape 1:

    Le contexte global démarre. Chaque fonction hérite de Function.prototype, où vivent les call, apply et bind intégrés.

  2. Étape 2:

    Phase de création : introduce est enregistrée comme fonction reliée à Function.prototype, et ali et hiAli sont réservées.

    Lignes 3–18

  3. Étape 3:

    ali pointe vers un nouvel objet.

    Ligne 6

  4. Étape 4:

    Les fonctions sont des objets. introduce.call n'est pas sur introduce elle-même : la recherche suit son [[Prototype]] et trouve call sur Function.prototype.

    Ligne 8

  5. Étape 5:

    call exécute introduce tout de suite, avec this égal à son premier argument, ali. Les autres arguments sont passés un par un.

    Ligne 8

  6. Étape 6:

    this.name vaut Ali : Hi, I'm Ali! s'affiche.

    Lignes 4–8

  7. Étape 7:

    apply fait la même chose, mais prend les arguments sous forme d'un tableau et les répartit dans les paramètres.

    Ligne 9

  8. Étape 8:

    introduce se termine, et console.log affiche Hello, I'm Ali.

    Lignes 4–9

  9. Étape 9:

    Place à notre propre bind. myBind est ajoutée à Function.prototype : toute fonction peut l'utiliser, comme le bind intégré.

    Lignes 11–16

  10. Étape 10:

    introduce.myBind est trouvée comme call : un cran plus haut dans la chaîne, sur Function.prototype.

    Ligne 18

  11. Étape 11:

    Dans myBind, this est introduce : l'objet avant le point. ctx vaut ali, et le paramètre du reste preset regroupe l'argument en plus.

    Ligne 11

  12. Étape 12:

    const fn = this range introduce dans une variable, car la fonction renvoyée ensuite aura son propre this.

    Ligne 12

  13. Étape 13:

    myBind renvoie une nouvelle fonction dans hiAli. Sa portée reste en vie, donc la nouvelle fonction garde fn, ctx et preset : une closure.

    Lignes 13–18

  14. Étape 14:

    hiAli('?') est un appel simple : son propre this vaut undefined. Peu importe, elle n'utilise jamais this.

    Ligne 19

  15. Étape 15:

    fn n'est pas dans la portée de hiAli : la recherche remonte et la trouve dans celle de myBind. ctx et preset sont trouvées de la même façon.

    Ligne 14

  16. Étape 16:

    fn.apply(ctx, …) appelle introduce avec this égal à ali et les arguments 'Hey' et '?'.

    Ligne 14

  17. Étape 17:

    introduce se termine, hiAli renvoie son résultat, et Hey, I'm Ali? s'affiche.

    Lignes 4–19

  18. Étape 18:

    call et apply exécutent une fonction tout de suite, avec le this choisi. bind renvoie une nouvelle fonction au this verrouillé, et la nôtre le fait avec une closure et apply.