Quelle est la différence entre les appels et de les appliquer?

Question

Quelle est la différence entre l'utilisation de l'appel et de l'appliquer pour appeler une fonction?

var func = function(){
  alert('hello!');
};

func.apply();

vs

func.call();

Sont-il des écarts de performances entre les deux méthodes? Quand est-il préférable d'utiliser l'appel en cours s'appliquent et vice versa?

Answer 1

La principale différence est que, apply vous permet d'appeler la fonction avec des arguments comme un tableau; call nécessite les paramètres énumérés explicitement.

Voir ici et ici.

Pseudo syntaxe:

theFunction.apply(valueForThis, arrayOfArgs)

theFunction.call(valueForThis, arg1, arg2, ...)

Exemple de code:

function theFunction(name, profession) {
    alert("My name is " + name + " and I am a " + profession + ".");
}
theFunction("John", "fireman");
theFunction.apply(undefined, ["Susan", "school teacher"]);
theFunction.call(undefined, "Claude", "mathematician");

Answer 2

K. Scott Allen a un bel article sur la question.

Fondamentalement, ils diffèrent sur la façon dont ils traitent les arguments de la fonction.

L'appliquer() la méthode est identique à l'appel(), sauf s'appliquent() nécessite un tableau comme second paramètre. Le tableau représente les arguments en faveur de l'objectif de la méthode."

Donc:

// assuming you have f
function f(message) { ... }
f.call(receiver, "test");
f.apply(receiver, ["test"]);

Answer 3

Pour répondre à la partie sur l'utilisation de chaque fonction, utilisez apply si vous ne connaissez pas le nombre d'arguments, vous serez en passant, ou si elles sont déjà dans un tableau ou un tableau comme objet (comme l' arguments objet à transmettre vos propres arguments. Utiliser call autrement, car il n'y a pas besoin d'envelopper les arguments dans un tableau.

f.call(thisObject, a, b, c); // Fixed number of arguments

f.apply(thisObject, arguments); // Forward this function's arguments

var args = [];
while (...) {
    args.push(some_value());
}
f.apply(thisObject, args); // Unknown number of arguments

Quand je ne suis pas la réussite de tous les arguments (comme ton exemple), je préfère call depuis que je suis à l'appel de la fonction. apply impliquerait que vous êtes à l'application de la fonction de la (inexistante) des arguments.

Il ne devrait pas y avoir de différences de rendement, sauf peut-être si vous utilisez apply et enveloppez-les arguments dans un tableau (par exemple, f.apply(thisObject, [a, b, c]) au lieu de f.call(thisObject, a, b, c)). Je n'ai pas testé, donc il pourrait y avoir des différences, mais il serait très spécifiques au navigateur. Il est probable que l' call est plus rapide si vous n'avez pas déjà les arguments dans un tableau et d' apply est plus rapide si vous le faites.

Answer 4

Voici un bon mnémonique. Unppliquez utilise Unrrays et Unoujours prend un ou deux Arguments. Lorsque vous utilisez Ctout ce que vous avez à Count le nombre d'arguments.

Answer 5

Alors que c'est un vieux sujet, je voulais juste faire remarquer que .appel est légèrement plus rapide que .s'appliquent. Je ne peux pas vous dire exactement pourquoi.

Voir jsPerf, http://jsperf.com/test-call-vs-apply/3

---

[UPDATE!]

Douglas Crockford mentionne brièvement la différence entre les deux, ce qui peut aider à expliquer la différence de performance... http://youtu.be/ya4UHuXNygM?t=15m52s

Appliquer prend un tableau d'arguments, alors que l'Appel prend zéro, un ou plusieurs paramètres individuels! Ah Ah!

.apply(this, [...])

.call(this, param1, param2, param3, param4...)