我已经知道apply和call是类似的函数，它们设置this(函数的上下文)。
区别在于我们发送参数的方式(manual vs array)
问题:
但是什么时候应该使用bind()方法呢?
var obj = {
x: 81,
getX: function() {
return this.x;
}
};
alert(obj.getX.bind(obj)());
alert(obj.getX.call(obj));
alert(obj.getX.apply(obj));
jsbin
当前回答
它们都将其附加到函数(或对象)中，区别在于函数调用(见下文)。
Call将此附加到函数中并立即执行函数:
var person = {
name: "James Smith",
hello: function(thing) {
console.log(this.name + " says hello " + thing);
}
}
person.hello("world"); // output: "James Smith says hello world"
person.hello.call({ name: "Jim Smith" }, "world"); // output: "Jim Smith says hello world"
Bind将它附加到函数中，需要像这样单独调用:
var person = {
name: "James Smith",
hello: function(thing) {
console.log(this.name + " says hello " + thing);
}
}
person.hello("world"); // output: "James Smith says hello world"
var helloFunc = person.hello.bind({ name: "Jim Smith" });
helloFunc("world"); // output: Jim Smith says hello world"
或者像这样:
...
var helloFunc = person.hello.bind({ name: "Jim Smith" }, "world");
helloFunc(); // output: Jim Smith says hello world"
Apply类似于call，只是它接受一个类似数组的对象，而不是一次列出一个参数:
function personContainer() {
var person = {
name: "James Smith",
hello: function() {
console.log(this.name + " says hello " + arguments[1]);
}
}
person.hello.apply(person, arguments);
}
personContainer("world", "mars"); // output: "James Smith says hello mars", note: arguments[0] = "world" , arguments[1] = "mars"
其他回答
function. prototype.call()和function. prototype.apply()都使用给定的这个值调用函数，并返回该函数的返回值。
另一方面，function .prototype.bind()使用给定的这个值创建一个新函数，并返回该函数而不执行它。
让我们取一个这样的函数:
var logProp = function(prop) {
console.log(this[prop]);
};
现在，让我们选择一个这样的对象:
var Obj = {
x : 5,
y : 10
};
我们可以像这样将函数绑定到对象上:
Obj.log = logProp.bind(Obj);
现在，我们可以在代码中的任何地方运行Obj.log:
Obj.log('x'); // Output : 5
Obj.log('y'); // Output : 10
真正有趣的是，你不仅为this绑定了一个值，还为它的参数prop绑定了一个值:
Obj.logX = logProp.bind(Obj, 'x');
Obj.logY = logProp.bind(Obj, 'y');
我们现在可以这样做:
Obj.logX(); // Output : 5
Obj.logY(); // Output : 10
Call:调用函数，允许你一个一个地传递参数
Apply: Apply调用函数并允许您将参数作为数组传递
Bind: Bind返回一个新函数，允许传入this数组和任意数量的参数。
var person1 = {firstName: 'Raju', lastName: 'king'}; var person2 = {firstName: 'chandu', lastName: 'shekar'}; function greet(greeting) { console.log(greeting + ' ' + this.firstName + ' ' + this.lastName); } function greet2(greeting) { console.log( 'Hello ' + this.firstName + ' ' + this.lastName); } greet.call(person1, 'Hello'); // Hello Raju king greet.call(person2, 'Hello'); // Hello chandu shekar greet.apply(person1, ['Hello']); // Hello Raju king greet.apply(person2, ['Hello']); // Hello chandu shekar var greetRaju = greet2.bind(person1); var greetChandu = greet2.bind(person2); greetRaju(); // Hello Raju king greetChandu(); // Hello chandu shekar
所有这些方法背后的主要概念是函数挖掘。
函数借用允许我们在不同的对象上使用一个对象的方法，而不必复制该方法并在两个不同的地方维护它。它是通过使用。调用()，。Apply()，或。Bind()，所有这些方法的存在都是为了显式地在我们所借用的方法上设置此值
Call立即调用函数，并允许您逐个传入参数 一个 Apply立即调用函数，并允许传入参数 作为一个数组。 Bind返回一个新函数，您可以通过调用函数随时调用/调用它。
下面是所有这些方法的示例
let name = {
firstname : "Arham",
lastname : "Chowdhury",
}
printFullName = function(hometown,company){
console.log(this.firstname + " " + this.lastname +", " + hometown + ", " + company)
}
CALL
第一个参数，例如调用方法中的name总是一个引用 To (this)变量和后者将是函数变量
printFullName.call(name,"Mumbai","Taufa"); //Arham Chowdhury, Mumbai, Taufa
应用
Apply方法与call方法相同 唯一的区别是，函数参数是在数组列表中传递的
printFullName.apply(name, ["Mumbai","Taufa"]); //Arham Chowdhury, Mumbai, Taufa
BIND
Bind方法与call方法相同，不同之处在于，Bind返回一个可以稍后通过调用它来使用的函数(不立即调用它)。
let printMyNAme = printFullName.bind(name,"Mumbai","Taufa");
printMyNAme(); //Arham Chowdhury, Mumbai, Taufa
printMyNAme()是调用该函数的函数
下面是jsfiddle的链接
https://codepen.io/Arham11/pen/vYNqExp
我之前创建了函数对象、函数调用、call/apply和bind之间的比较:
.bind允许您现在设置this值，同时允许您在将来执行该函数，因为它返回一个新的函数对象。
想象一下，绑定是不可用的。 你可以简单地构建如下:
var someFunction=...
var objToBind=....
var bindHelper = function (someFunction, objToBind) {
return function() {
someFunction.apply( objToBind, arguments );
};
}
bindHelper(arguments);
