Kāda ir atšķirība starp call
un apply
, lai izsauktu funkciju?
var func = function() {
alert('hello!');
};
func.apply();
vs func.call();
Vai starp abām iepriekš minētajām metodēm ir veiktspējas atšķirības? Kad labāk izmantot call
, nevis apply
un kad otrādi?
Atšķirība ir tāda, ka apply
ļauj izsaukt funkciju ar argumentiem
kā masīvu, bet call
pieprasa, lai parametri būtu skaidri uzskaitīti. Noderīga mnemonika ir "A kā amatu un C kā comma.".
Skatīt MDN'dokumentāciju par apply un call.
Pseidsintakse:
theFunction.apply(valueForThis, arrayOfArgs)
theFunction.call(valueForThis, arg1, arg2, ...)
No ES6 ir arī iespēja `izplatīt
masīvu, lai to izmantotu ar `call`` funkciju, saderību var apskatīt šeit.
Koda paraugs:
function theFunction(name, profession) {
console.log("My name is " + name + " and I am a " + profession +".");
}
theFunction("John", "fireman");
theFunction.apply(undefined, ["Susan", "school teacher"]);
theFunction.call(undefined, "Claude", "mathematician");
theFunction.call(undefined, ...["Matthew", "physicist"]); // used with the spread operator
K. Scott Allen ir jauks rakstījums par šo jautājumu.
Būtībā tās atšķiras ar to, kā tās apstrādā funkciju argumentus.
Metode apply() ir identiska metodei call(), tikai apply() kā otro parametru pieprasa masīvu. Šis masīvs attēlo mērķa metodes argumentus."
Tātad:
// assuming you have f
function f(message) { ... }
f.call(receiver, "test");
f.apply(receiver, ["test"]);
Lai atbildētu uz jautājumu par to, kad lietot katru funkciju, izmantojiet apply
, ja nezināt, cik argumentu tiks nodoti, vai ja tie jau ir masīvā vai masīvam līdzīgā objektā (piemēram, arguments
objektā, lai pārsūtītu savus argumentus. Pretējā gadījumā izmantojiet call
, jo argumentus nav nepieciešams ietīt masīvā.
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
Ja es nenododu nekādus argumentus (kā tavā piemērā), es dodu priekšroku call
, jo es izsaucu funkciju. apply
nozīmētu, ka jūs piemērojat funkciju (neesošajiem) argumentiem.
Nevajadzētu būt nekādām veiktspējas atšķirībām, izņemot, ja jūs izmantojat apply
un argumentus ietinat masīvā (piemēram, f.apply(thisObject, [a, b, c])
, nevis f.call(thisObject, a, b, c)
). Es to neesmu pārbaudījis, tāpēc var būt atšķirības, bet tas būtu ļoti specifiski pārlūkprogrammai. Iespējams, ka call
ir ātrāks, ja jums vēl nav argumentu masīvā, un apply
ir ātrāks, ja jums jau ir.