本文详细解析JavaScript中Function.prototype继承的call、apply和bind三个核心方法。重点阐述三者如何改变函数执行时的this指向，对比它们在参数传递形式（直接传参vs数组传参）及执行时机（立即执行vs返回新函数）上的关键区别，并结合查找数组最大值、转换类数组对象等实际案例说明具体应用场景。
call/apply/bind方法的来源
本文内容将按以下章节展开：
1. call/apply/bind方法的来源
2. Function.prototype.call()
3. Function.prototype.apply()
3.1：找出数组中的最大数
3.2：将数组的空元素变为undefined
3.3：转换类似数组的对象
4. Function.prototype.bind()
5. 绑定回调函数的对象
6. call，apply，bind方法的联系和区别
1. call/apply/bind方法的来源
在使用call、apply和bind方法之前，有必要了解这三个方法的来源及其存在的原因。
call、apply和bind这三个方法均继承自Function.prototype，属于实例方法。
console.log(Function.prototype.hasOwnProperty('call')) //true
console.log(Function.prototype.hasOwnProperty('apply')) //true
console.log(Function.prototype.hasOwnProperty('bind')) //true上述代码验证显示，三种方法均返回true，证明它们都继承自Function.prototype。普通对象、函数和数组都继承了Function.prototype中的这三个方法，因此可以在对象、数组和函数中调用它们。
关于继承的概念，将在后续内容中与大家分享。
Function.prototype.call()
2. Function.prototype.call()
函数实例的call方法可以指定函数内部this的指向（即函数执行时所在的作用域），并在指定的作用域中调用该函数，且会立即执行该函数。
通过以下示例来深入理解这一概念。
var keith = {
rascal: 123
};
var rascal = 456;
function a() {
console.log(this.rascal);
}
a(); //456
a.call(); //456
a.call(null); //456
a.call(undefined); //456
a.call(this); //456
a.call(keith); //123在上述代码中，若a函数中的this关键字指向全局对象，返回结果为456。可见，当call方法没有参数，或参数为null、undefined或this时，等同于指向全局对象。若使用call方法将this关键字指向keith对象，即将函数执行时的作用域设为keith对象，则返回结果为123。
call()方法可以传递两个参数。第一个参数用于指定函数内部this的指向（即函数执行时的作用域），第二个参数是调用函数时需要传递的参数。
function keith(a, b) {
console.log(a + b);
}
keith.call(null, 1, 2); //3第一个参数是必须的，可以是null、undefined或this，但不能为空。设置为null、undefined或this表明函数keith此时处于全局作用域。在第二个参数中，必须逐个添加参数；而在apply方法中，必须以数组形式添加。
call方法的一个应用是调用对象的原生方法，也可用于将类数组对象转换为数组。
var obj = {};
console.log(obj.hasOwnProperty('toString')); //false
obj.hasOwnProperty = function() {
return true;
}
console.log(obj.hasOwnProperty('toString')); //true
console.log(Object.prototype.hasOwnProperty.call(obj, 'toString')); //false在上述代码中，hasOwnProperty是obj对象继承的方法，如果该方法被覆盖，则无法得到正确结果。call方法可以解决此问题，它将hasOwnProperty方法的原始定义放到obj对象上执行，这样无论obj上是否有同名方法，都不会影响结果。需要注意的是，hasOwnProperty是Object.prototype原生对象的方法，而call是继承自Function.prototype的方法。
Function.prototype.apply()
3. Function.prototype.apply()
apply方法的作用与call方法类似，也是改变this指向（即函数执行时的作用域），并在指定的作用域中调用该函数，同时也会立即执行该函数。唯一的区别在于，它接收一个数组作为函数执行时的参数。
apply方法的第一个参数同样是this所要指向的那个对象，如果设为null、undefined或this，则等同于指定全局对象。第二个参数是一个数组，该数组的所有成员依次作为参数，在调用时传入原函数。原函数的参数在call方法中必须逐个添加，但在apply方法中，必须以数组形式添加。
以下代码展示了call和apply的细微差别。
function keith(a, b) {
console.log(a + b);
}
keith.call(null, 2, 3); //5
keith.apply(null, [2, 3]); //5
在上述代码中，第一个参数为null，指向全局作用域；第二个参数的传入形式略有不同。
apply方法有以下应用场景。
3.1：找出数组中的最大数
var a = [2, 4, 5, 7, 8, 10];
console.log(Math.max.apply(null, a)); //10
console.log(Math.max.call(null,2, 4, 5, 7, 8, 10)); //10 JavaScript中未提供直接找出数组中最大值的方法，结合使用继承自Function.prototype的apply和Math.max方法，即可返回数组的最大值。
3.2：将数组的空元素变为undefined
通过apply方法，利用Array构造函数将数组的空元素变成undefined。
console.log(Array.apply(null, [1, , 3])); // [1, undefined, 3]
空元素与undefined的区别在于，数组的forEach方法会跳过空元素，但不会跳过undefined和null。因此，在遍历内部元素时，会得到不同的结果。
var a = [1, , 3];
a.forEach(function(index) {
console.log(index); //1,3 ，跳过了空元素。
})
Array.apply(null,a).forEach(function(index){
console.log(index); ////1,undefined,3 ，将空元素设置为undefined
})3.3：转换类似数组的对象
此外，利用数组对象的slice方法，可以将一个类似数组的对象（如arguments对象）转为真正的数组。当然，slice方法的一个重要应用就是将类似数组的对象转为真正的数组，call和apply都可以实现该应用。
console.log(Array.prototype.slice.apply({0:1,length:1})); //[1]
console.log(Array.prototype.slice.call({0:1,length:1})); //[1]
console.log(Array.prototype.slice.apply({0:1,length:2})); //[1,undefined]
console.log(Array.prototype.slice.call({0:1,length:2})); //[1,undefined]
function keith(a,b,c){
return arguments;
}
console.log(Array.prototype.slice.call(keith(2,3,4))); //[2,3,4]上述代码中，call和apply方法的参数都是对象，但返回结果都是数组，从而起到了将对象转成数组的目的。从上述代码可以看出，该方法起作用的前提是被处理的对象必须有length属性以及相对应的数字键。
Function.prototype.bind()
4. Function.prototype.bind()
bind方法用于指定函数内部this的指向（执行时所在的作用域），然后返回一个新函数。bind方法并非立即执行一个函数。
var keith = {
a: 1,
count: function() {
console.log(this.a++);
}
};
keith.count(); //1
keith.count(); //2
keith.count(); //3在上述代码中，如果this.a指向keith对象内部的a属性，若将此方法赋值给另一个变量，调用时就会出错。
var keith = {
a: 1,
count: function() {
console.log(this.a++);
}
};
var f = keith.count;
f(); //NaN在上述代码中，如果把count方法赋值给f变量，那么this对象指向不再是keith对象，而是window对象。而window.a默认为undefined，进行递增运算后undefined++等于NaN。
为解决此问题，可以使用bind方法，将keith对象里的this绑定到keith对象上，或者直接调用。
var f = keith.count.bind(keith);
f(); //1
f(); //2
f(); //3
keith.count.bind(keith)() //1
keith.count.bind(keith)() //2
keith.count.bind(keith)() //3当然，this也可以绑定到其他对象上。
var obj = {
a: 100
};
var f = keith.count.bind(obj);
f(); //100
f(); //101
f(); //102同样，我们也可以给bind方法传递参数，第一个参数如果为null、undefined或this，会将函数内部的this对象指向全局环境；第二个为调用时需要的参数，并且传递参数的形式与call方法相同。
function keith(a, b) {
return a + b;
}
console.log(keith.apply(null,[1,4])); //5
console.log(keith.call(null,1,4)); //5
console.log(keith.bind(null, 1, 4)); //keith()
console.log(keith.bind(null, 1, 4)()); //5上述代码可以看出call、apply和bind三者的区别：call和apply方法都是在调用之后立即执行的。而bind调用之后是返回原函数，需要再调用一次才行，有点像闭包的味道。如果对闭包概念不熟悉，可以浏览这两篇文章：深入理解javascript函数参数与闭包，浅谈JavaScript的闭包函数。
绑定回调函数的对象
5. 绑定回调函数的对象
在文章javascript中this关键字详解中，有谈及如果在回调函数中使用this对象，那么this对象会指向DOM对象，即button对象。若要解决回调函数中this指向问题，可采用如下方法。
var o = {
f: function() {
console.log(this === o);
}
}
$('#button').on('click', function() {
o.f.apply(o);
//或者 o.f.call(o);
//或者 o.f.bind(o)();
});点击按钮后，控制台将显示true。由于apply方法（或call方法）不仅绑定函数执行时所在的对象，还会立即执行函数（而bind方法不会立即执行，注意区别），因此不得不把绑定语句写在一个函数体内。
call，apply，bind方法的联系和区别
6. call，apply，bind方法的联系和区别
其实用于指定函数内部this指向的问题，这三个方法都差不多，只是存在形式上的差别。读者可以将以上的例子用三种方法尝试用三种方法实现。
总结一下call，apply，bind方法：
a：第一个参数都是指定函数内部中this的指向（函数执行时所在的作用域），然后根据指定的作用域，调用该函数。
b：都可以在函数调用时传递参数。call，bind方法需要直接传入，而apply方法需要以数组的形式传入。
c：call，apply方法是在调用之后立即执行函数，而bind方法没有立即执行，需要将函数再执行一遍。有点闭包的味道。
d：改变this对象的指向问题不仅有call，apply，bind方法，也可以使用that变量来固定this的指向。如有疑问，请访问javascript中this关键字详解
以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，同时也希望多多支持本站！