call() 方法在使用一个指定的 this 值和若干个指定的参数值的前提下调用某个函数或方法。
fun.call(thisArg[, arg1[, arg2[, ...]]])
apply() 方法调用一个函数, 其具有一个指定的this值，以及作为一个数组（或类似数组的对象）提供的参数
fun.apply(thisArg, [argsArray])
bind() 方法会创建一个新函数。当这个新函数被调用时，bind() 的第一个参数将作为它运行时的 this，之后的一序列参数将会在传递的实参前传入作为它的参数
fun.bind(thisArg[, arg1[, arg2[, ...]]])
当绑定函数被调用时，该参数会作为原函数运行时的 this 指向。当使用new 操作符调用绑定函数时，该参数无效。
特点：
返回一个函数
可以传入参数
1、理解
call方法原理
模拟Function中内置的call方法，写一个myCall方法，探讨call方法的执行原理
function sum(){
console.log(this);
}
function fn(){
console.log(this);
}
var obj = {name:'iceman'};
Function.prototype.myCall = function (context) {
// myCall方法中的this就是当前我要操作和改变其this关键字的那个函数名
// 1、让fn中的this关键字变为context的值->obj
// 让this这个函数中的"this关键字"变为context
// eval(this.toString().replace("this","obj"));
// 2、让fn方法在执行
// this();
};
fn.myCall(obj);// myCall方法中原来的this是fn
sum.myCall(obj);// myCall方法中原来的this是sum
call方法经典例子
function fn1() {
console.log(1);
}
function fn2() {
console.log(2);
}
fn1.call(fn2); // 1
首先fn1通过原型链查找机制找到Function.prototype上的call方法，并且让call方法执行，此时call这个方法中的this就是要操作的fn1。在call方法代码执行的过程过程中，首先让fn1中的“this关键字”变为fn2，然后再让fn1这个方法执行。
fn1.call.call(fn2); // 2
2、区别
三个函数存在的区别, 用一句话来说的话就是: bind是返回对应函数, 便于稍后调用; apply, call则是立即调用,apply是call的一层封装，可以传数组。所以call比较快。 除此外, 在 ES6 的箭头函数下, call 和 apply 的失效, 对于箭头函数来说:
- 函数体内的 this 对象, 就是定义时所在的对象, 而不是使用时所在的对象;
- 不可以当作构造函数, 也就是说不可以使用 new 命令, 否则会抛出一个错误;
- 不可以使用 arguments 对象, 该对象在函数体内不存在. 如果要用, 可以用 Rest 参数代替;
- 不可以使用 yield 命令, 因此箭头函数不能用作 Generator 函数;
call 方法比 apply 快的原因是 call 方法的参数格式正是内部方法所需要的格式
3、模拟
思路
- 将函数设为对象的属性
- 执行该函数
- 删除该函数
call
Function.prototype.call2 = function (context) {
var context = context || window;//null等传入指向window
context.fn = this;//将函数设为对象的属性
var args = [];
for(var i = 1, len = arguments.length; i < len; i++) {
args.push('arguments[' + i + ']');
}
var result = eval('context.fn(' + args +')');//执行该函数
delete context.fn; // 删除函数
return result;
}
apply
Function.prototype.apply = function (context, arr) {
var context = Object(context) || window;
context.fn = this;
var result;
if (!arr) {
result = context.fn();
}
else {
var args = [];
for (var i = 0, len = arr.length; i < len; i++) {
args.push('arr[' + i + ']');
}
result = eval('context.fn(' + args + ')')
}
delete context.fn
return result;
}
bind
一个绑定函数也能使用new操作符创建对象：这种行为就像把原函数当成构造器。提供的 this 值被忽略，同时调用时的参数被提供给模拟函数。
Bound.prototype = this.prototype，我们直接修改 Bound.prototype 的时候，也会直接修改绑定函数的 prototype。这个时候，我们可以通过一个空函数来进行中转
Function.prototype.bind = Function.prototype.bind || function (context) {
if (typeof this !== "function") {
throw new Error("Function.prototype.bind - what is trying to be bound is not callable");
}
var self = this;
var args = Array.prototype.slice.call(arguments, 1);//先取到bind时传参,bar.bind(foo, 'daisy');
var F = function () {};//继承用空函数来转
var Bound = function () {
var bindArgs = Array.prototype.slice.call(arguments);//在取到返回函数,bindFoo('18');
//如果是new的this指向F,this指向构造函数，如果不是指向要改变的this
return self.apply(this instanceof F ? this : context, args.concat(bindArgs)//合并参数);
}
F.prototype = this.prototype;
Bound.prototype = new F();
return Bound;
};
4、案例
1、柯里化
var currying = function( fn ){
var args = [];
return function(){
if ( arguments.length === 0 ){
return fn.apply( this, args );
}else{
[].push.apply( args, arguments );
return arguments.callee;
}
}
};
var cost = (function(){
var money = 0;
return function(){
for ( var i = 0, l = arguments.length; i < l; i++ ){
money += arguments[ i ];
}
return money;
}
})();
var cost = currying( cost ); // 转化成 currying 函数
cost( 100 ); // 未真正求值
cost( 200 ); // 未真正求值
cost( 300 ); // 未真正求值
alert ( cost() ); // 求值并输出：
var overtime = (function() {
var args = [];
return function() {
if(arguments.length === 0) {
var time = 0;
for (var i = 0, l = args.length; i < l; i++) {
time += args[i];
}
return time;
}else {
[].push.apply(args, arguments);
}
}
})();
overtime(3.5); // 第一天
overtime(4.5); // 第二天
overtime(2.1); // 第三天
//...
console.log( overtime() ); // 10.1
2、debounce 函数去抖
var debounce = function(idle, action){
var last
return function(){
var ctx = this, args = arguments
clearTimeout(last)
last = setTimeout(function(){
action.apply(ctx, args)
}, idle)
}
}
var timer = null;
window.onscroll = function(){
if (timer) {
// 清除未执行的逻辑，重新执行下一次逻辑，不论上一次是否执行完毕
clearTimeout(timer);
}
timer = setTimeout(function(){
//执行逻辑
}, 300);
};
3、throttle 函数节流
var throttle = function ( fn, interval ) {
var __self = fn, // 保存需要被延迟执行的函数引用
timer, // 定时器
firstTime = true; // 是否是第一次调用
return function () {
var args = arguments,
__me = this;
if ( firstTime ) { // 如果是第一次调用，不需延迟执行
__self.apply(__me, args);
return firstTime = false;
}
if ( timer ) { // 如果定时器还在，说明前一次延迟执行还没有完成
return false;
}
timer = setTimeout(function () { // 延迟一段时间执行
clearTimeout(timer);
timer = null;
__self.apply(__me, args);
}, interval || 5000 );
};
};
window.onresize = throttle(function(){ console.log( 1 ); }, 5000 );
var can = true;
window.onscroll = function(){
if(!can){
//判断上次逻辑是否执行完毕，如果在执行中，则直接return
return;
}
can = false;
setTimeout(function(){
//执行逻辑
can = true;
}, 100);
};
4、反柯里化(uncurring)
Function.prototype.uncurring = function() {
var self = this; //self此时是Array.prototype.push
return function() {
var obj = Array.prototype.shift.call(arguments);
//obj 是{
// "length": 1,
// "0": 1
//}
//arguments的第一个对象被截去(也就是调用push方法的对象),剩下[2]
return self.apply(obj, arguments);
//相当于Array.prototype.push.apply(obj, 2);
};
};
//测试一下
var push = Array.prototype.push.uncurring();
var obj = {
"length": 1,
"0" : 1
};
push(obj, 2);
console.log( obj ); //{0: 1,1: 2, length: 2 }
5、取数组最大值
Math.max(1,2,3,4);
利用apply可以把传数组的方法
var max = Math.max.apply(null, ary);
Math.max(1,2,3,4);
var max = eval("Math.max(" + ary.toString() + ")");
在非严格模式下，给apply的第一个参数为null的时候，会让max/min中的this指向window，然后将ary的参数一个个传给max/min
6、将类数组转换数组
slice在不穿参的情况下是复制数组
Array.prototype.slice = function() {
var result = [];
for(var i = 0; i < this.length; i++){
result[i] = this[i] };
return result;
}
[1,2,3,4].slice()
=> [1, 2, 3, 4]
var obj = {length:'2', '0': 'aa', '1': 'bb'}
[].slice.call(obj)
=> ["aa", "bb"]
function listToArray(likeAry) {
var ary = [];
try {
ary = Array.prototype.slice.call(likeAry);
} catch (e) {
for (var i = 0; i < likeAry.length; i++) {
ary[ary.length] = likeAry[i];
}
}
return ary;
}
7、push的理解
Array.prototype.push = function(str){ return this.concat(str) }
[1,2,3].push(1)
=>[1, 2, 3, 1]
[].push.call([1,2,3],3)
=> [1, 2, 3, 3]
5、caller与callee
caller
返回一个对函数的引用，该函数调用了当前函数。
对于函数来说，caller 属性只有在函数执行时才有定义。
如果函数是由顶层调用的，那么 caller 包含的就是 null 。
如果在字符串上下文中使用 caller 属性，那么结果和 functionName.toString 一样，也就是说，显示的是函数的反编译文本。
// caller demo {
function callerDemo() {
if (callerDemo.caller) {
var a= callerDemo.caller.toString();
alert(a);
} else {
alert("this is a top function");
}
}
function handleCaller() {
callerDemo(); //"function handleCaller() { callerDemo();}"
}
callee
返回正被执行的 Function 对象，也就是所指定的 Function 对象的正文。
ES5 提示: 在严格模式下，arguments.callee 会报错 TypeError，因为它已经被废除了
callee 属性是 arguments 对象的一个成员，它表示对函数对象本身的引用，这有利于匿名函数的递归或者保证函数的封装性
arguments.length是实参长度，arguments.callee.length是形参长度
在递归中有很好的应该