Comprendre profondément les différences entre les méthodes d'appel, d'application et de liaison en JavaScript

En JavaScript, ce pointage est modifié dynamiquement, et il est très probable que ce pointage soit accidentellement détruit pendant le processus d'écriture d'un programme. Par conséquent, nous avons besoin d'une technologie qui peut en fixer la signification, nous avons donc trois méthodes: appelez, appliquez et liant pour changer le pointage de cela à l'intérieur du corps de la fonction, car la fonction a les concepts de "contexte de définition", "contexte d'exécution" et "contexte peut être modifié"

postuler, appeler

Appliquer: appliquer une méthode d'un certain objet et remplacer l'objet actuel par un autre objet

Appel: appelez une méthode d'un objet pour remplacer l'objet actuel par un autre objet

 fonction personne () {} personne.prototype = {attr: {Âge: 18, sexe: 'girl'}, dire: function () {console.log ("mon âge est" + this.attr.age); console.log ("Je suis un" + this.attr.sex); }} var marier = new personne (); marier.say (); // mon âge a 18 ans // je suis une fille

Changer la direction

 fonction personne () {} personne.prototype = {attr: {Âge: 18, sexe: 'girl'}, dire: function () {console.log ("mon âge est" + this.attr.age); console.log ("Je suis un" + this.attr.sex); }} xiaoMing = {attr: {Âge: 20, sexe: 'boy'}}; var marier = new personne (); marier.say (); Marier.say.call (xiaoMing); // mon âge a 18 ans // je suis une fille // mon âge a 20 ans // je suis un garçon

Qu'est-ce qui est courant

Les deux peuvent être utilisés pour appeler une méthode au lieu d'un autre objet, modifiant le contexte d'objet d'une fonction du contexte initial au nouvel objet spécifié par ThisObj.

La différence

1. Appliquer: il ne peut y avoir que deux paramètres au maximum - le nouvel objet et un argument de tableau. Si vous transmettez plusieurs paramètres à cette méthode, écrivez tous les paramètres dans ce tableau. Bien sûr, même s'il n'y a qu'un seul paramètre, il doit être écrit dans le tableau. Si Argarray n'est pas un tableau valide ou n'est pas un objet d'arguments, une tactéror sera générée. Si aucun argument n'est fourni, l'objet global sera utilisé comme thisObj et ne peut être transmis aucun argument.

 fun.call (thisarg [, arg1 [, arg2 [, ...]]]) fonction f (x, y) {console.log (x + y);} f.call (null, 1, 1) // return 2

2. Appel: Il s'agit d'une liste de paramètres directe, qui est principalement utilisée lorsque diverses méthodes de l'objet JS sont appelées les unes aux autres, de sorte que le pointeur actuel reste cohérent ou dans des cas particuliers, ce pointeur doit être modifié. Si ce paramètre ce paramètre n'est pas fourni, l'objet global est utilisé comme thisObj.

 fun.apply (thisarg, [argsArray]) fonction f (x, y) {console.log (x + y);} f.call (null, [1,1]) // return 2

L'application est la même que la fonction d'appel, sauf que la liste des paramètres entrants est différente dans la forme. Thisarg est le contexte que vous souhaitez spécifier. Il peut s'agir de n'importe quel objet JavaScript (tout dans JavaScript est un objet). L'appel doit passer des paramètres dans l'ordre, tandis que l'application met les paramètres dans un tableau.

Si le nombre de paramètres d'une fonction n'est pas fixe, utilisez l'appel lorsque vos paramètres connaissent clairement la quantité, et utilisez-vous appliquer lorsqu'il est incertain, puis poussez le paramètre dans le tableau et passez-le. Lorsque le nombre de paramètres est incertain, la fonction peut également traverser tous les paramètres via le tableau d'arguments. Jetons un coup d'œil à une utilisation

Code 1

 var array1 = [12, "foo", {nom: "Joe"}, -2458]; var array2 = ["Doe", 555, 100]; array.protype.push.apply (array1, array2); console.log (array1); // [12, "foo", objet, -2458, "doe", 55, 100]

Code deux

 nombres var = [5, 458, 120, -215]; math.max.apply (null, nombres); // 458

Code trois

 log (12, "foo", {name: "Joe"}, -2458); fonction log () {var args = array.prototype.slice.call (arguments); args.unshift ('(app)'); console.log.apply (console, args);}; // (app) 12 objet foo {nom: "Joe"} -2458

lier

 fun.bind (thisarg [, arg1 [, arg2 [, ...]]]])

Contrairement à ce qui précède, Bind renverra une nouvelle fonction qui modifie ce pointage. Notez que la nouvelle fonction est soulignée ici, qui n'est pas la même adresse mémoire que celle utilisée auparavant, donc lorsque vous devez réutiliser cette fonction, vous devez l'enregistrer dans une variable pour faciliter l'appel suivant. Les deux fonctions ci-dessus sont les résultats d'exécution renvoyés, c'est-à-dire que l'appel est exécuté.

Row, en outre, une autre chose à noter est que le premier paramètre de la fonction de liaison deviendra automatiquement la valeur par défaut pour renvoyer les paramètres dans la nouvelle fonction. Ensuite, lorsque l'appel officiel est appelé, il vous suffit de donner les paramètres restants sauf le premier paramètre.

 Fonction f (x, y) {console.log (x + y);} f.call (null, [1,1]) var new_f = f.bind (null, 1,1) // return new functionnew_f (1) // return 2

Il convient de noter que le paramètre ThisArg dans tous les exemples de codes ci-dessus est remplacé par NULL. Lorsque cet objet ORG n'est pas spécifié, ce pointage est un objet global sous null et indéfini, c'est-à-dire l'environnement d'exécution du code JS

Appliquer, appeler, lier la comparaison

 var obj = {bar: 'Oups, c'est une mauvaise idée'}; var foo = {get: function () {return this.bar; }} var bind = foo.get.bind (obj), call = foo.get.call (obj), appliquer = foo.get.apply (obj); console.log (bind (), appel, appliquer); console.log (lier, appeler, s'appliquer); Console.log (type de liaison, type d'appel, type de type s'appliquer); Console.log (type de liaison (), type d'appel, typeof s'appliquer);

Je ne vois aucune différence. La différence est que lorsque vous souhaitez modifier le contexte, il n'est pas exécuté immédiatement, mais le rappel est exécuté, utilisez la méthode Bind (). Appliquer / l'appel exécutera la fonction immédiatement

 appliquer, appeler, lier sont tous utilisés pour modifier le pointage de cet objet de la fonction; Les premiers paramètres de l'application, de l'appel, de la liaison sont tous des objets auxquels cela devrait pointer, c'est-à-dire le contexte à spécifier; Appliquer, appeler, lier peut tous utiliser des paramètres ultérieurs pour passer les paramètres; Bind renvoie la fonction correspondante, ce qui est pratique pour appeler plus tard; postuler, l'appel est appelé immédiatement

L'article ci-dessus comprend profondément la différence entre les méthodes d'appel, d'application et de liaison en JavaScript est tout le contenu que je partage avec vous. J'espère que cela pourra vous donner une référence et j'espère que vous pourrez soutenir Wulin.com plus.