JavaScript深入之bind的模拟实现
bind() 方法会创建一个函数,当这个新函数被调用的时候,bind() 的第一个参数将作为他运行时的this,之后的一序列参数将会在传递的参数前作为他的参数
其实这也可以看出bind函数的两个特点
- 返回一个新函数
- 可以传入参数
先看一个例子----返回函数的实现
var foo = {
value : 2
}
function bar(){
console.log(this.value)
}
var bindBar = bar.bind(foo)
bindBar();
// 2
我们定义的bind2 的函数要定义在Function.prototype,这是因为我们函数都是由Function创建的,window也是Function.prototype的实例
window.__proto__.__proto__.__proto__.__proto__.__proto__ == Object.prototype.__proto__
//true
Object.__proto__ == Function.prototype
//true
window.__proto__.__proto__.__proto__.__proto__ == Function.prototype.__proto__
//true
Function.prototype.bind2 = function(context){
console.log(111, this)
//这个this就指向调用者。如果是bar函数,就指向bar函数
//context表示的是传入的对象 也就是说
//bar函数中的this指向context中的this
var self = this
return function(){
self.apply(context)
}
}
var foo = {
value:3
}
function bar(){
console.log(this.value)
}
var bindFoo = bar.bind2(foo);
//bind2 返回的只是bind2中的新函数,所以需要再调用一次
console.log(bindFoo()) //3
传参的模拟实现
先看骚骚的bind传参,继续刚才的骚例子
var foos = {
value:4
}
function foo(name,age){
console.log(name)
console.log(age)
console.log(this.value)
}
var bindFoo = foo.bind(foos, 'xiaolizi')
bindFoo(18)
// xiaolizi
//18
// 4
foo需要传入name和age两个参数,而且可以在bind的时候,只传一个name,然后再执行返回的函数的时候再传入另一个参数age
所以我们再第二版需要对arguments进行处理
第二版
Function.prototype.bind2 = function(context){
var self = this;
//因为arguments是类数组对象,不能使用slice,所以使用call改变this的指向
//从slice(1) 是截取第一个参数之后的参数,因为第一个参数是传入的对象context。
var args = Array.prototype.slice.call(arguments,1)
return function(){
//这个是截取第二个调用的函数,所以截取全部的参数
var bindArgs = Array.prototype.slice.call(arguments)
return self.apply(context,args.concat(bindArgs))
}
}
var foos = {
value:4
}
function foo(name,age){
console.log(name)
console.log(age)
console.log(this.value)
}
var bindFoo = foo.bind2(foos, 'xiaolizi')
bindFoo(18)
构造函数效果的模拟实现
一个绑定函数也能使用new操作符创建对象,这种行为就像把函数当做构造器,提供的this值被忽略,同时调用时的参数被提供给模拟函数
其实也就是说bind返回的函数作为构造函数的时候,bind时指定的this值会失效,但传入的参数依然有效。
var value = 2;
var foo = {
value: 1
};
function bar(name, age) {
this.habit = 'shopping';
console.log(this.value);
console.log(name);
console.log(age);
}
bar.prototype.friend = 'kevin';
var bindFoo = bar.bind(foo, 'daisy');
var obj = new bindFoo('18');
// undefined
// daisy
// 18
console.log(obj.habit);
console.log(obj.friend);
// shopping
// kevin
注意:尽管在全局和 foo 中都声明了 value 值,最后依然返回了 undefind,说明绑定的 this 失效了,如果大家了解 new 的模拟实现,就会知道这个时候的 this 已经指向了 obj。
// 第三版
Function.prototype.bind2 = function (context) {
var self = this;
var args = Array.prototype.slice.call(arguments, 1);
var fBound = function () {
var bindArgs = Array.prototype.slice.call(arguments);
// 当作为构造函数时,this 指向实例,此时结果为 true,将绑定函数的 this 指向该实例,可以让实例获得来自绑定函数的值
// 以上面的是 demo 为例,如果改成 `this instanceof fBound ? null : context`,实例只是一个空对象,将 null 改成 this ,实例会具有 habit 属性
// 当作为普通函数时,this 指向 window,此时结果为 false,将绑定函数的 this 指向 context
return self.apply(this instanceof fBound ? this : context, args.concat(bindArgs));
}
// 修改返回函数的 prototype 为绑定函数的 prototype,实例就可以继承绑定函数的原型中的值
//这里实际吧fBound 作为function,也就是第一调用的时候就返回一个函数,函数里面再根据调用的方式,确定this的指向,当第二次指向的时候,this指向的开始改变并赋值给fBound.prototype 就可以改变this的指向
fBound.prototype = this.prototype;
return fBound;
}
构造函数效果的优化实现
但是在这个写法中,我们直接将 fBound.prototype = this.prototype,我们直接修改 fBound.prototype 的时候,也会直接修改绑定函数的 prototype。这个时候,我们可以通过一个空函数来进行中转:
// 第四版
Function.prototype.bind2 = function (context) {
var self = this;
var args = Array.prototype.slice.call(arguments, 1);
var fNOP = function () {};
var fBound = function () {
var bindArgs = Array.prototype.slice.call(arguments);
return self.apply(this instanceof fNOP ? this : context, args.concat(bindArgs));
}
fNOP.prototype = this.prototype;
fBound.prototype = new fNOP();
return fBound;
}
最终版
Function.prototype.bind2 = 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);
var fNOP = function () {};
var fBound = function () {
var bindArgs = Array.prototype.slice.call(arguments);
return self.apply(this instanceof fNOP ? this : context, args.concat(bindArgs));
}
fNOP.prototype = this.prototype;
fBound.prototype = new fNOP();
return fBound;
}
以上参考一下文章加了一些自己的理解