我已经知道了，apply并且call是类似的函数，它们设置this（函数的上下文）。
不同之处在于我们发送参数的方式（手动 vs 数组）
问题：
但是我应该什么时候使用该 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));
.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 上查看真正的实现。
它们都将this附加到函数（或对象）中，区别在于函数调用（见下文）。
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将this附加到函数中，它需要像这样单独调用：
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"
以最简单的形式回答
称呼
var person1 = {firstName: 'Jon', lastName: 'Kuperman'};
var person2 = {firstName: 'Kelly', lastName: 'King'};
function say(greeting) {
console.log(greeting + ' ' + this.firstName + ' ' + this.lastName);
}
say.call(person1, 'Hello'); // Hello Jon Kuperman
say.call(person2, 'Hello'); // Hello Kelly King
申请
var person1 = {firstName: 'Jon', lastName: 'Kuperman'};
var person2 = {firstName: 'Kelly', lastName: 'King'};
function say(greeting) {
console.log(greeting + ' ' + this.firstName + ' ' + this.lastName);
}
say.apply(person1, ['Hello']); // Hello Jon Kuperman
say.apply(person2, ['Hello']); // Hello Kelly King
绑定
var person1 = {firstName: 'Jon', lastName: 'Kuperman'};
var person2 = {firstName: 'Kelly', lastName: 'King'};
function say() {
console.log('Hello ' + this.firstName + ' ' + this.lastName);
}
var sayHelloJon = say.bind(person1);
var sayHelloKelly = say.bind(person2);
sayHelloJon(); // Hello Jon Kuperman
sayHelloKelly(); // Hello Kelly King
Call 和 apply 可以互换。只需决定是否更容易发送数组或逗号分隔的参数列表。
通过记住 Call 用于逗号（分隔列表）和 Apply 用于数组，我总是记得哪个是哪个。
绑定有点不同。它返回一个新函数。Call 和 Apply 立即执行当前函数。
Bind 对很多事情都很有用。我们可以用它来柯里化上面例子中的函数。我们可以将一个简单的 hello 函数转换为 helloJon 或 helloKelly。我们还可以将它用于 onClick 之类的事件，我们不知道它们何时会被触发，但我们知道我们希望它们具有什么上下文。
我创建函数对象，函数调用之间的比较call/apply和bind前一段时间：
.bind允许您现在设置this值，同时允许您将来执行该函数，因为它返回一个新的函数对象。
特尔；博士：
简单来说，bind 创建函数，调用和应用执行函数，而应用需要数组中的参数
完整说明
假设我们有multiplication函数
function multiplication(a,b){
console.log(a*b);
}
让我们创建一些标准函数使用 bind
var multiby2 = multiplication.bind(this,2);
现在 multiby2(b) 等于 multiplication(2,b);
multiby2(3); //6
multiby2(4); //8
如果我在绑定中传递两个参数怎么办
var getSixAlways = multiplication.bind(this,3,2);
现在 getSixAlways() 等于 multiplication(3,2);
getSixAlways();//6
即使传递参数返回6；
getSixAlways(12); //6
var magicMultiplication = multiplication.bind(this);
这将创建一个新的乘法函数并将其分配给 magicMultiplication。
哦不，我们将乘法功能隐藏在 magicMultiplication 中。
调用
magicMultiplication返回空白function b()
在执行时它工作正常
magicMultiplication(6,5); //30
打电话申请怎么样？
magicMultiplication.call(this,3,2); //6
magicMultiplication.apply(this,[5,2]); //10