我已经知道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
当前回答
TL; diana:
简单地说，bind创建函数，调用和apply执行函数，而apply期望数组中的参数
完整的解释
假设有一个乘法函数
function multiplication(a,b){
console.log(a*b);
}
让我们使用bind创建一些标准函数
var multiby2 = multiplication.bind（this，2）;
现在multiby2(b)等于乘法(2,b);
multiby2(3); //6
multiby2(4); //8
如果我在bind中传递两个参数会怎样
var getSixAlways = multiplication.bind(this,3,2);
现在getSixAlways()等于乘法(3,2);
getSixAlways();//6
即使传递参数也返回6; getSixAlways (12);/ / 6
var magicMultiplication = multiplication.bind(this);
这将创建一个新的乘法函数并将其分配给magic乘法。
哦，不，我们将乘法功能隐藏到magic乘法中。
调用 magic乘法返回一个空函数b()
在执行过程中，它运行良好 magicMultiplication (6 5);/ / 30
打电话申请怎么样?
magicMultiplication.call(这3 2);/ / 6
magicMultiplication.apply(这一点,[5,2]);/ / 10
其他回答
function sayHello() {
//alert(this.message);
return this.message;
}
var obj = {
message: "Hello"
};
function x(country) {
var z = sayHello.bind(obj);
setTimeout(y = function(w) {
//'this' reference not lost
return z() + ' ' + country + ' ' + w;
}, 1000);
return y;
}
var t = x('India')('World');
document.getElementById("demo").innerHTML = t;
call():——这里我们单独传递函数参数，而不是数组格式
var obj = {name: "Raushan"};
var greeting = function(a,b,c) {
return "Welcome "+ this.name + " to "+ a + " " + b + " in " + c;
};
console.log(greeting.call(obj, "USA", "INDIA", "ASIA"));
apply():——这里我们以数组格式传递函数参数
var obj = {name: "Raushan"};
var cal = function(a,b,c) {
return this.name +" you got " + a+b+c;
};
var arr =[1,2,3]; // array format for function arguments
console.log(cal.apply(obj, arr));
bind (): -
var obj = {name: "Raushan"};
var cal = function(a,b,c) {
return this.name +" you got " + a+b+c;
};
var calc = cal.bind(obj);
console.log(calc(2,3,4));
JavaScript中call()、apply()和bind()方法的第一个区别是它们的执行时间! Call()和apply()是相似的立即执行，而bind()创建了一个新函数，我们必须在任何稍后的时间显式调用!
另一个区别是，在传递参数时，call()允许我们用逗号分隔一个一个地传递，apply()允许我们作为参数数组传递，而bind()允许我们两者都做!
我已附上下面的示例代码!
const person = {
fullName : function (randomMessage) {
return `Hello, ${this.firstName} ${this.lastName} ${randomMessage}`;
}
}
const personOne = {
firstName : "John",
lastName : "Doe"
}
const personTwo = {
firstName : "Jack",
lastName : "Adhikari"
}
let fullNameBind = person.fullName.bind(personOne, "--Binding");
let fullNameCall = person.fullName.call({firstName : "Sarah", lastName: "Holmes"}, "--Calling");
let fullNameApply = person.fullName.apply(personTwo, ["--Applying"]);
console.log(fullNameBind());
console.log(fullNameCall);
console.log(fullNameApply);
当我们想要分配一个具有特定上下文的函数时，应该使用Bind函数。
var demo = {
getValue : function(){
console.log('demo object get value function')
}
setValue : function(){
setTimeout(this.getValue.bind(this),1000)
}
}
在上面的例子中，如果我们调用demo.setValue()函数并传递这个。getValue函数，那么它不会调用demo。setValue函数，因为setTimeout中的this指向窗口对象，所以我们需要将演示对象context传递给this。getValue函数使用bind。这意味着我们只是将demo对象的上下文传递给function，而不是实际调用function。
希望你能理解。
更多信息请参考 Javascript绑定函数详细了解
当您希望稍后在特定上下文中调用该函数(在事件中很有用)时，请使用.bind()。当您希望立即调用函数并修改上下文时，请使用.call()或.apply()。
Call/apply立即调用该函数，而bind返回的函数在稍后执行时将具有用于调用原始函数的正确上下文设置。这样你就可以在异步回调和事件中维护上下文。
我经常这样做:
function MyObject(element) {
this.elm = element;
element.addEventListener('click', this.onClick.bind(this), false);
};
MyObject.prototype.onClick = function(e) {
var t=this; //do something with [t]...
//without bind the context of this function wouldn't be a MyObject
//instance as you would normally expect.
};
我在Node.js中广泛使用它，用于我想要传递成员方法的异步回调，但仍然希望上下文是启动异步操作的实例。
bind的简单实现如下所示:
Function.prototype.bind = function(ctx) {
var fn = this;
return function() {
fn.apply(ctx, arguments);
};
};
还有更多关于它的内容(比如传递其他参数)，但您可以阅读更多关于它的内容，并查看MDN上的实际实现。
