Call, Apply, Bind

Call, Apply 和 Bind 都能用来改变this的指向。它们之间的区别是：
call 用来明确参数个数确定的情况
apply 用在参数个数不明确的情况
bind 是传递对象
call和apply都会立即执行
bind是创建一个新的函数副本
Call 和 Apply
举例 获取数组中的最大值和最小值
1
var  numbers = [5, 458 , 120 , -215 ]; 
2
var maxInNumbers = Math.max.apply(Math, numbers),   //458
3
    maxInNumbers = Math.max.call(Math,5, 458 , 120 , -215); //458
Copied!
 举例 面试题 定义一个 log 方法，让它可以代理 console.log 方法
1
function log(){
2
  console.log.apply(console, arguments);
3
};
4
log(1);    //1
5
log(1,2);    //1 2
Copied!
接下来的要求是给每一个 log 消息添加一个"(app)"的前辍
1
function log(){
2
  var args = Array.prototype.slice.call(arguments);
3
  args.unshift('(app)');
4
 
5
  console.log.apply(console, args);
6
};
Copied!
Bind
bind的定义是，bind()方法会创建一个新函数，称为绑定函数，当调用这个绑定函数时，绑定函数会以创建它时传入 bind()方法的第一个参数作为 this，传入 bind() 方法的第二个以及以后的参数加上绑定函数运行时本身的参数按照顺序作为原函数的参数来调用原函数。
1
var bar = function(){
2
console.log(this.x);
3
}
4
var foo = {
5
x:3
6
}
7
bar(); // undefined
8
var func = bar.bind(foo);
9
func(); // 3
Copied!
对比
使用举例
1
var obj = {
2
    x: 81,
3
};
4
 
5
var foo = {
6
    getX: function() {
7
        return this.x;
8
    }
9
}
10
 
11
console.log(foo.getX.bind(obj)());  //81
12
console.log(foo.getX.call(obj));    //81
13
console.log(foo.getX.apply(obj));   //81
Copied!
三个输出的都是81，但是注意看使用 bind() 方法的，他后面多了对括号。
也就是说，区别是，当你希望改变上下文环境之后并非立即执行，而是回调执行的时候，使用 bind() 方法。而 apply/call 则会立即执行函数。
实现
Bind
参考链接 
​https://github.com/mqyqingfeng/Blog/issues/12​
ES5 实现
1
Function.prototype.bind2 = function (context) {
2
​
3
    if (typeof this !== "function") {
4
      throw new Error("Function.prototype.bind - what is trying to be bound is not callable");
5
    }
6
​
7
    var self = this;
8
    var args = Array.prototype.slice.call(arguments, 1);
9
​
10
    var fNOP = function () {};
11
​
12
    var fBound = function () {
13
        var bindArgs = Array.prototype.slice.call(arguments);
14
        return self.apply(this instanceof fNOP ? this : context, args.concat(bindArgs));
15
    }
16
​
17
    fNOP.prototype = this.prototype;
18
    fBound.prototype = new fNOP();
19
    return fBound;
20
}
Copied!
ES6 实现
1
// formerArgs 为传递给 bind 函数的第二个到之后的参数
2
Function.prototype.bind = function (ctx, ...formerArgs) {
3
    let _this = this
4
    
5
    // laterArgs 为传递给原函数的参数
6
    return (...laterArgs) => {
7
        // bind 函数的不定参数在原函数参数之前
8
        // formerArgs 本身就是数组，可以直接调用数组的 concat 方法
9
        // 无需借助 call 或 apply
10
        return _this.apply(ctx, formerArgs.concat(laterArgs))
11
    }
12
}
Copied!
Call
1
// 第三版
2
Function.prototype.call2 = function (context) {
3
    var context = context || window; // 处理null就指向window
4
    context.fn = this;
5
​
6
    // 处理参数
7
    var args = [];
8
    for(var i = 1, len = arguments.length; i < len; i++) {
9
        args.push('arguments[' + i + ']');
10
    }
11
​
12
    var result = eval('context.fn(' + args +')');
13
​
14
    delete context.fn
15
    return result;
16
}
Copied!
其中
1
var args = [];
2
for(var i = 1, len = arguments.length; i < len; i++) {
3
        args.push('arguments[' + i + ']');
4
}
Copied!
最终的数组为：
1
var args = [arguments[1], arguments[2], ...]
Copied!
然后
1
 var result = eval('context.fn(' + args +')');
Copied!
在eval中，args 自动调用 args.toString()方法，eval的效果如 jawil所说，最终的效果相当于：
1
 var result = context.fn(arguments[1], arguments[2], ...);
Copied!
call 第二种实现方式
1
Function.prototype.call = function (context, ...args) {
2
  // 检查调用```call```的对象是否为函数
3
  if (typeof this !== 'function') {
4
    throw new TypeError('not a function')
5
  }
6
​
7
  // 将函数作为传入的```context```对象的一个属性，调用该函数
8
  const fn = Symbol()
9
  context[fn] = this
10
  context[fn](...args)
11
​
12
  // 不要忘了调用之后删除该属性
13
  delete context[fn]
14
}
Copied!
Apply
1
Function.prototype.apply = function (context, arr) {
2
    var context = Object(context) || window;
3
    context.fn = this;
4
​
5
    var result;
6
    if (!arr) {
7
        result = context.fn();
8
    }
9
    else {
10
        var args = [];
11
        for (var i = 0, len = arr.length; i < len; i++) {
12
            args.push('arr[' + i + ']');
13
        }
14
        result = eval('context.fn(' + args + ')')
15
    }
16
​
17
    delete context.fn
18
    return result;
19
}
Copied!
apply 第二种实现方式
1
Function.prototype.apply = function (context, args) {
2
  // 检查调用```apply```的对象是否为函数
3
  if (typeof this !== 'function') {
4
    throw new TypeError('not a function')
5
  }
6
​
7
  // 将函数作为传入的```context```对象的一个属性，调用该函数
8
  const fn = Symbol()
9
  context[fn] = this
10
  context[fn](...args)
11
​
12
  // 不要忘了调用之后删除该属性
13
  delete context[fn]
14
}
Copied!
以前
Throttle
下一个
type
最近更新 1yr ago
复制链接
内容