40道this面试题+手写new,call,apply,bind

this指针是JavaScript的一大特色，对于this的理解很考验一个人对于JavaScript这门语言的理解，增改自【建议👍】再来40道this面试题酸爽继续(1.2w字用手整理)

通过阅读本篇文章你可以学习到：

this的默认绑定
隐式绑定
隐式绑定的隐式丢失问题
显式绑定
显式绑定的其它用法
new绑定
箭头函数绑定
综合题
手写new,call,apply,bind

0.前期准备

this的5种绑定方式：

默认绑定(非严格模式下this指向全局对象, 严格模式下this会绑定到undefined)
隐式绑定(当函数引用有上下文对象时, 如 obj.foo()的调用方式, foo内的this指向obj)
显示绑定(通过call()或者apply()方法直接指定this的绑定对象, 如foo.call(obj))
new绑定
箭头函数绑定(this的指向由外层作用域决定的)

1. 默认绑定

先介绍一种最简单的绑定方式吧：默认绑定。

也就是我们常说的：在非严格模式下this指向的是全局对象window，而在严格模式下会绑定到undefined。

1.1 题目一

来看个最基本的案例：

var a = 10;
function foo () {
	console.log(this.a)
}
foo(); // 10

我们知道在使用var创建变量的时候(不在函数里)，会把创建的变量绑定到window上，所以此时a是window下的属性。

而函数foo也是window下的属性。

因此上面的代码其实就相当于是这样:

window.a = 10;
function foo() {
	console.log(this.a);
}
window.foo();

在这里，调用foo()函数的是window对象，且又是在非严格模式下，所以foo()中this的指向是window对象，因此this.a会输出10。

答案：

1.2 题目二

改造下题目一，看看在严格模式下。

(想要开启严格模式，只要在需要开启的地方写上"use strict")

"use strict";
var a = 10;
function foo () {
    console.log('this1', this); // 'this1' undefined
    console.log(window.a); // 10
    console.log(this.a); // Uncaught TypeError: Cannot read property 'a' of undefined
}
console.log(window.foo); // f foo() {...}
console.log('this2', this); // 'this2' Window{...}
foo();

需要注意的点：

开启了严格模式，只是说使得函数内的this指向undefined，它并不会改变全局中this的指向。因此this1中打印的是undefined，而this2还是window对象。
另外，它也不会阻止a被绑定到window对象上。

所以最后的执行结果：

f foo() {...}
'this2' Window{...}
'this1' undefined
10
Uncaught TypeError: Cannot read property 'a' of undefined

1.3 题目三

let a = 10;
const b = 20;

function foo () {
    console.log(this.a);
    console.log(this.b);
}
foo(); // undefined\Nundefined
console.log(window.a) // undefined

如果把var改成了let 或者 const，变量是不会被绑定到window上的，所以此时会打印出三个undefined。

答案：

1
2
3

undefined
undefined
undefined

1.4 题目四

var a = 1;
function foo () {
    var a = 2;
    console.log(this);
    console.log(this.a);
}

foo();

这里我们很容易就知道，foo()函数内的this指向的是window，因为是window调用的foo。

但是打印出的this.a呢？注意，是this.a，不是a，因此是window下的a。

并且由于函数作用域的原因我们知道window下的a还是1。

因此答案为：

1 2	Window{...} 1

1.5 题目五

把题目1.4改造一下。

var a = 1;
function foo () {
    var a = 2;
    function inner () { 
    	console.log(this.a);
    }
    inner();
}

foo();

其实这里和1.4很像，不过一看到函数内的函数，就很容易让人联想到闭包，然后… 然后就脱口而出，答案是2啊，这还不简单。

小伙伴们，审题可得仔细啊，这里问你的是this.a，不是a，而在函数inner中，this指向的还是window。

答案：

(我知道有的小伙伴不满这种题目，这吖的不就是和人玩文字游戏吗？有什么技术含量，但是现实就是这样，很多面试官会喜欢问这种细节题来考察你细心不细心。在没能力改变这种情况的前提下，你只能试着接受它…)

2. 隐式绑定

介绍完了默认绑定之后，让我们来看看第二种隐式绑定。

其实大佬 sunshine小小倩教了我们一个简单的规则，this 永远指向最后调用它的那个对象。

谁最后调用的函数，函数内的this指向的就是谁(不考虑箭头函数)。

下面你可以用这个规则来做题。

2.1 题目一

function foo () {
	console.log(this.a);
}
var obj = {
    a: 1,
    foo
};
var a = 2;
obj.foo();

var obj = { foo }就相当于是var obj = { foo: foo }

在这道题中，函数foo()虽然是定义在window下，但是在obj对象中引用了它，并将它重新赋值到obj.foo上。

且调用它的是obj对象，因此打印出来的this.a应该是obj中的a。

上面这段代码是不是就相当于是这样：

var obj = {
    a: 1,
    foo: function () {
    	console.log(this.a);
    }
}
var a = 2;
obj.foo();

在这里foo函数内的this指向的就是obj，和题目效果一样。

答案都是：

有小伙伴就会有有疑问了，obj.foo()不就相当于是window.obj.foo()吗？

那foo()内的this到底是算window呢，还是obj呢？

请注意我前面说的，是最后调用函数的对象，显然，obj要比window更后面一点。

3. 隐式绑定的隐式丢失问题

隐式绑定的基本概念大家应该都清楚了，不过其实有一个关于隐式绑定的常用考点，那就是隐式丢失问题。

隐式丢失其实就是被隐式绑定的函数在特定的情况下会丢失绑定对象。

有两种情况容易发生隐式丢失问题：

使用另一个变量来给函数取别名
将函数作为参数传递时会被隐式赋值，回调函数丢失this绑定

我们一种一种来看哈。

3.1 题目一

使用另一个变量来给函数取别名会发生隐式丢失。

function foo () {
	console.log(this.a);
};
var obj = {
	a: 1,
	foo
};
var a = 2;
var foo2 = obj.foo;

obj.foo(); // 1
foo2(); // 2

执行这段代码会打印出啥呢？

在这里我们已经知道了，obj.foo()中this的指向是为obj的(可以看第二部分隐式绑定)，所以obj.foo()执行的时候，打印出来的是obj对象中的a，也就是1。

但是foo2它不也是obj.foo吗？我只不过是用了一个变量foo2来盛放了它而已。所以你是不是认为它打印的也是1呢？

其实这里不是的，它打印出的是window下的a。

答案：

1
2

1
2

这是因为虽然foo2指向的是obj.foo函数，不过调用它的却是window对象，所以它里面this的指向是为window。

其实也就相当于是window.foo2()，如果你不相信的话，可以看下面一题👇。

3.2 题目二

让我们在一个新的变量obj2中也定义一个foo2看看：

function foo () {
	console.log(this.a);
};
var obj = {
	a: 1,
	foo
};
var a = 2;
var foo2 = obj.foo;
var obj2 = {
	a: 3,
	foo2: obj.foo
};

obj.foo(); // 1
foo2(); // 2
obj2.foo2(); // 3

这三种不同的foo()打印出来的分别是什么呢？

答案：

1
2
3

1
2
3

obj.foo()中的this指向调用者obj
foo2()发生了隐式丢失，调用者是window，使得foo()中的this指向window
foo3()发生了隐式丢失，调用者是obj2，使得foo()中的this指向obj2

3.3 题目三

再就是如果你把一个函数当成参数传递时，也会被隐式赋值，发生意想不到的问题。

来看看这道题目：

function foo () {
	console.log(this.a);
}
function doFoo (fn) {
    console.log(this); // Window{...}
    fn(); // 2
}
var obj = {
	a: 1,
	foo
};
var a = 2;
doFoo(obj.foo);

这里我们将obj.foo当成参数传递到doFoo函数中，在传递的过程中，obj.foo()函数内的this发生了改变，指向了window。

因此结果为：

1 2	Window{...} 2

注意，我这里说的是obj.foo()函数，而不是说doFoo()。doFoo()函数内的this本来就是指向window的，因为这里是window调用的它。

但是你不要以为是doFoo()函数内的this影响了obj.foo()，不信你看下一题。

3.4 题目四

现在我们不用window调用doFoo，而是放在对象obj2里，用obj2调用：

function foo () {
	console.log(this.a);
}
function doFoo (fn) {
    console.log(this); // obj2 { a:3, doFoo: f }
    fn(); // 2
}
var obj = {
	a: 1,
	foo
};
var a = 2;
var obj2 = {
	a: 3,
	doFoo
};

obj2.doFoo(obj.foo);

现在调用obj2.doFoo()函数，里面的this指向的应该是obj2，因为是obj2调用的它。

但是obj.foo()打印出来的a依然是2，也就是window下的。

执行结果为：

1 2	{ a:3, doFoo: f } 2

所以说，如果你把一个函数当成参数传递到另一个函数的时候，也会发生隐式丢失的问题，且与包裹着它的函数的this指向无关。在非严格模式下，会把该函数的this绑定到window上，严格模式下绑定到undefined。

一样的代码，试试严格模式下：

"use strict"
function foo () {
	console.log(this.a);
}
function doFoo (fn) {
    console.log(this); // obj2 { a:3, doFoo: f }
    fn(); // Uncaught TypeError: Cannot read property 'a' of undefined
}
var obj = {
	a: 1,
	foo
};
var a = 2;
var obj2 = {
    a: 3,
    doFoo
};

obj2.doFoo(obj.foo);

执行结果：

1 2	{ a:3, doFoo: f } Uncaught TypeError: Cannot read property 'a' of undefined

4. 显式绑定

功能如其名，就是强行使用某些方法，改变函数内this的指向。

通过call()、apply()或者bind()方法直接指定this的绑定对象, 如foo.call(obj)。

这里有几个知识点需要注意：

使用.call()或者.apply()的函数是会直接执行的
bind()是创建一个新的函数，需要手动调用才会执行
.call()和.apply()用法基本类似，不过call接收若干个参数，而apply接收的是一个数组

来看看题目一。

4.1 题目一

function foo () {
	console.log(this.a);
}
var obj = {
	a: 1
};
var a = 2;

foo();  // 2
foo.call(obj); // 1
foo.apply(obj); // 1
foo.bind(obj);

第一个foo() 都很好理解，这不就是默认绑定吗？

而第二个和第三个foo都使用了call或apply来改变this的指向，并且是立即执行的。

第四个foo，仅仅是使用bind创建了一个新的函数，且这个新函数也没用别的变量接收并调用，因此并不会执行。

答案：

1
2
3

2
1
1

这里想要提一嘴，如果call、apply、bind接收到的第一个参数是空或者null、undefined的话，则会忽略这个参数。

例如：

function foo () {
	console.log(this.a);
}
var a = 2;
foo.call(); // 2
foo.call(null); // 2
foo.call(undefined); // 2

输出的是：

1
2
3

2
2
2

4.2 题目二

了解了显式绑定的基本使用之后，让我们来看看它的妙用。

首先，是这个例子：

var obj1 = {
	a: 1
};
var obj2 = {
    a: 2,
    foo1: function () {
    	console.log(this.a);
    },
    foo2: function () {
        setTimeout(function () {
            console.log(this);
            console.log(this.a);
        }, 0);
    }
};
var a = 3;

obj2.foo1(); // 2
obj2.foo2(); // Window{...} 3

对于obj2.foo1()，我们很清楚，它就是打印出2。

但是对于obj2.foo2呢？在这个函数里，设置了一个定时器，并要求我们打印出this和this.a。

想想我前面说过的话，谁调用的函数，函数内的this指向的就是谁。

而对于setTimeout中的函数，这里存在隐式绑定的隐式丢失，也就是当我们将函数作为参数传递时会被隐式赋值，回调函数丢失this绑定，因此这时候setTimeout中的函数内的this是指向window的。

(之前呆呆一直认为的是定时器里的函数和定时器是有关系的，所以有一些错误的理解，感谢掘友朝游夕宴和l.jx的指出)

所以最终的结果是：

1
2
3

2
Window{...}
3

4.3 题目三

面对上面这种情况我们就可以使用call、apply 或者bind来改变函数中this的指向，使它绑定到obj1上，从而打印出1。

var obj1 = {
	a: 1
};
var obj2 = {
    a: 2,
    foo1: function () {
    	console.log(this.a);
    },
    foo2: function () {
        setTimeout(function () {
            console.log(this);
            console.log(this.a);
        }.call(obj1), 0);
    }
}
var a = 3;
obj2.foo1(); // 2
obj2.foo2(); // 1

现在的执行结果就是：

1
2
3

2
{ a: 1 }
1

但是看看我这里的写法，我是将.call运用到setTimeout里的回调函数上，并不是运用到obj2.foo2()上。

所以有小伙伴就会问了，我下面的这种写法不可以吗？

1	obj2.foo2.call(obj1);

注意⚠️：如果是这种写法的话，我改变的就是foo2函数内的this的指向了，但是我们知道，foo2函数内this的指向和setTimeout里函数的this是没有关系的，因为调用定时器的始终是window。

并且这里使用.bind()也是可以的，因为定时器里的函数在时间到了之后本就是会自动执行的。

4.4 题目四

OK，我们不用定时器，把它干掉，换成一个函数：

var obj1 = {
	a: 1
};
var obj2 = {
    a: 2,
    foo1: function () {
    	console.log(this.a);
    },
    foo2: function () {
        function inner () {
            console.log(this);
            console.log(this.a);
        }
        inner();
    }
}
var a = 3;
obj2.foo1(); // 2
obj2.foo2(); // Window{...} 3

其实这里有点像题目1.5有木有，都是函数内包裹着函数。

调用inner函数的依然是window，所以结果为：

1
2
3

2
Window{...}
3

如果给inner()函数显式绑定的话：

1	inner.call(obj1);

结果为

1
2
3

2
{ a: 1 }
1

4.5 题目五

其实在实际面试中，面试官喜欢以这样的方式考你：看看这道题，会输出什么呢？

function foo () {
	console.log(this.a);
}
var obj = { a: 1 };
var a = 2;

foo(); // 2
foo.call(obj); // 1
foo().call(obj); // 2 Uncaught TypeError: Cannot read property 'call' of undefined

也就是使用.call()方法位置的不同。

结果：

2
1
2
Uncaught TypeError: Cannot read property 'call' of undefined

foo()会正常打印出window下的a，也就是2
foo.call(obj)由于显式绑定了this，所以会打印出obj下的a，也就是1
foo().call(obj)开始会执行foo()函数，打印出2，但是会对foo()函数的返回值执行.call(obj)操作，可是我们可以看到foo()函数的返回值是undefined，因此就会报错了。

所以我们可以看到foo.call()和foo().call()的区别了，一个是针对于函数，一个是针对于函数的返回值。

4.6 题目六

既然刚刚4.5是因为函数没有返回值才报的错，那我现在给它加上返回值看看：

function foo () {
    console.log(this.a);
    return function () {
    	console.log(this.a);
    }
}
var obj = { a: 1 };
var a = 2;

foo(); // 2
foo.call(obj); // 1
foo().call(obj); // 2 1

你能想到现在会输出什么吗？

答案是：

第一个数字2自然是foo()输出的，虽然foo()函数也返回了一个匿名函数，但是并没有调用它呀，只有写成foo()()，这样才算是调用匿名函数。
第二个数字1是foo.call(obj)输出的，由于.call()是紧跟着foo的，所以改变的是foo()内this的指向，并且.call()是会使函数立即执行的，因此打印出1，同理，它也没有调用返回的函数。
第三个数字2是foo().call(obj)先执行foo()时打印出来的，此时foo()内this还是指向window。
在执行完foo()之后，会返回一个匿名函数，并且后面使用了.call(obj)来改变这个匿名函数的this指向并调用了它，所以输出了1。

4.7 题目七

想想我们把call换成bind会怎么样呢？

先来回忆一下它们的区别：call是会直接执行函数的，bind是返回一个新函数，但不会执行。

function foo () {
    console.log(this.a);
    return function () {
    	console.log(this.a);
    }
}
var obj = { a: 1 }
var a = 2;

foo(); // 2
foo.bind(obj);
foo().bind(obj); // 2

结果自然就是：

1
2

2
2

foo()会执行没错，打印出了2。
但是foo.bind(obj)却不会执行，它返回的是一个新函数。
foo().bind(obj)只会执行前面的foo()函数，打印出2，.bind(obj)只是将foo()返回的匿名函数显式绑定this而已，并没有调用。

4.8 题目八

说实话，做上面这类题目，会让我有一种疑惑。

这种函数内返回的函数，它的this会和它外层的函数有关吗？

也就是内层函数它的this到底是谁呢？

还是那句话，谁最后调用的它，this就指向谁。

function foo () {
    console.log(this.a);
    return function () {
    	console.log(this.a);
    }
}
var obj = { a: 1 }
var a = 2;

foo.call(obj)(); // 1 2

就像是这道题，foo()函数内的this虽然指定了是为obj，但是调用最后调用匿名函数的却是window。

所以结果为：

1
2

1
2

4.9 题目九

一直都在做函数返回函数的题目，让我们来看看把它们加到对象里，会有哪些有趣的题目吧。

var obj = {
    a: 'obj',
    foo: function () {
        console.log('foo:', this.a);
        return function () {
        	console.log('inner:', this.a);
        }
    }
}
var a = 'window';
var obj2 = { a: 'obj2' };

obj.foo()(); // foo:obj inner:window
obj.foo.call(obj2)(); // foo:obj2 inner:window
obj.foo().call(obj2); // foo:obj inner:obj1

现在，没和你玩文字游戏了，每个foo返回的函数我都调用了，但是你能知道每次调用，打印出的都是什么吗？

obj.foo()自然是打印出foo: obj和inner: window，这个没什么疑惑的。
obj.foo.(obj2)()其实也没啥可疑惑的了，打印出foo: obj2和inner: window(类似4.8)。
那么obj.foo().call(obj2)就更没啥可疑惑的了，打印出foo: obj和inner: obj2。

4.10 题目十

var obj = {
    a: 1,
    foo: function (b) {
        b = b || this.a;
        return function (c) {
        	console.log(this.a + b + c);
        }
    }
}
var a = 2;
var obj2 = { a: 3 };

obj.foo(a).call(obj2, 1); // 3 + 2 + 1 = 6
obj.foo.call(obj2)(1); // 2 + 3 + 1 = 6

执行结果：

1
2

6
6

开始调用obj.foo(a)将2传入foo函数并赋值给型参b，并且由于闭包的原因，使得匿名函数内能访问到b，之后调用匿名函数的时候，用call()改变了this的指向，使得匿名函数内this.a为3，并传入最后一个参数1，所以第一行输出的应该是3 + 2 + 1，也就是6。
而第二行，obj.foo.call(obj2)这里是将foo函数内的this指向了obj2，同时并没有传递任何参数，所以b开始是undefined的，但是又因为有一句b = b || this.a，使得b变为了3；同时最后一段代码(1)，是在调用匿名函数，且和这个匿名函数内的this应该是指向window的，因此输出也为3+2+1，为6。

var obj = {
    a: 1,
    foo: function (b) {
        b = b || this.a;
        return function (c) {
        	console.log(this.a);
        	console.log(b);
        	console.log(c);
        }
    }
}
var a = 2;
var obj2 = { a: 3 };

obj.foo(a).call(obj2, 1); // 3 2 1 
obj.foo.call(obj2)(1); // 2 3 1

执行结果：

5. 显式绑定的其它用法

除了上面那几道题的用法之外，我们还可以有一些其它的用法。

例如，我们可以在一个函数内使用call来显式绑定某个对象，这样无论怎样调用它，其内部的this总是指向这个对象。(可见题目5.1)

5.1 题目一

function foo1 () {
	console.log(this.a);
};
var a = 1;
var obj = {
	a: 2
};

var foo2 = function () {
	foo1.call(obj);
}

foo2(); // 2
foo2.call(window); // 2

这里foo2函数内部的函数foo1我们使用call来显式绑定obj，就算后面再用call来绑定window也没有用了。

结果为：

1
2

2
2

5.2 题目二

function foo1 (b) {
    console.log(`${this.a} + ${b}`);
    return this.a + b;
}
var a = 1;
var obj = {
	a: 2
};

var foo2 = function () {
	return foo1.call(obj, ...arguments);
}

var num = foo2(3); // 2 + 3
console.log(num); // 5

答案：

1
2

'2 + 3'
5

5.3 题目三

接下我想要介绍一个比较冷门的知识。

相信大家对forEach、map、filter都不陌生吧，它们是JS内置的一些函数，但是你知道它们的第二个参数也是能绑定this的吗？ 😁

来看看下面👇的题目：

function foo (item) {
	console.log(item, this.a);
}
var obj = {
	a: 'obj'
};
var a = 'window';
var arr = [1, 2, 3];

// arr.forEach(foo, obj)
// arr.map(foo, obj)
arr.filter(function (i) {
    console.log(i, this.a);
    return i > 2;
}, obj);

这里的答案为：

1
2
3

1 "obj"
2 "obj"
3 "obj"

如果我们没有传递第二个参数obj的话，this.a打印出来的肯定就是window下的a了，但是传入了之后将obj显示绑定到第一个参数函数上。

(关于arr.filter为什么也会打印出1, 2, 3，那是因为虽然我们使用了return i > 2，不过在执行阶段filter还是把每一项都打印出来)

function foo (item) {
	console.log(item, this.a);
}
var obj = {
	a: 'obj'
};
var a = 'window';
var arr = [1, 2, 3];

// arr.forEach(foo, obj)
// arr.map(foo, obj)
arr.filter(function (i) {
    console.log(i, this.a);
    return i > 2;
});

答案为：

1
2
3

1 "window"
2 "window"
3 "window"

换成箭头函数

function foo (item) {
	console.log(item, this.a);
}
var obj = {
	a: 'obj'
};
var a = 'window';
var arr = [1, 2, 3];

// arr.forEach(foo, obj)
// arr.map(foo, obj)
arr.filter((i) => {
    console.log(i, this.a);
    return i > 2;
});

答案为：

1
2
3

1 "window"
2 "window"
3 "window"

总结

总结一下这部分的知识点好了：

this 永远指向最后调用它的那个对象
匿名函数的this永远指向window
使用.call()或者.apply()的函数是会直接执行的
bind()是创建一个新的函数，需要手动调用才会执行
如果call、apply、bind接收到的第一个参数是空或者null、undefined的话，则会忽略这个参数
forEach、map、filter函数的第二个参数也是能显式绑定this的

6. new 绑定

让我们来看看另一种this的绑定形式，也就是new绑定。

使用new来调用一个函数，会构造一个新对象并把这个新对象绑定到调用函数中的this。

例如第一题。

6.1 题目一

使用new来调用Person，构造了一个新对象person1并把它(person1)绑定到Person调用中的this。

function Person (name) {
	this.name = name;
}
var name = 'window';
var person1 = new Person('LinDaiDai');
console.log(person1.name);

答案：

1	'LinDaiDai'

6.2 题目二

构造函数中不仅可以添加属性，也可以添加方法：

function Person (name) {
    this.name = name;
    this.foo1 = function () {
    	console.log(this.name);
    }
    this.foo2 = function () {
        return function () {
        	console.log(this.name);
        }
    }
}
var person1 = new Person('person1');
person1.foo1(); // person1
person1.foo2()(); // ''

这道题的写法不得不让我想到题目4.9：

var obj = {
    a: 'obj',
    foo: function () {
        console.log('foo:', this.a);
        return function () {
        	console.log('inner:', this.a);
        }
    }
}

好像都是函数包裹着函数，没错，其实它们的解法都差不多。

所以这道题的结果为：

1 2	'person1' ''

第一个this.name打印的肯定是person1对象中的name，也就是构造person1对象时传递进去的person1字符串。
第二个this.name打印的应该就是window下的name了，但是这里window对象中并不存在name属性，所以打印出的是空。

6.3 题目三

使用new函数创建的对象和字面量形式创建出来的对象好像没什么大的区别，如果对象中有属性是函数类型的话，并且不是箭头函数，那么解法都一样。在后面说到箭头函数的时候就有区别了，不过我们一步一步来。

先看看下面👇这道题：

var name = 'window';
function Person (name) {
    this.name = name;
    this.foo = function () {
        console.log(this.name);
        return function () {
        	console.log(this.name);
        }
    }
}
var person2 = {
    name: 'person2',
    foo: function() {
        console.log(this.name);
        return function () {
        	console.log(this.name);
        }
    }
}
  
var person1 = new Person('person1');
person1.foo()(); // person1 window
person2.foo()(); // person2 window

在这道题中，person1.foo和person2就没有什么区别。

打印出来的结果为：

'person1'
'window'
'person2'
'window'

6.4 题目四

当new绑定结合显示绑定，例如call函数的话，解起来其实也不难。

来看看下面的题目。

var name = 'window';
function Person (name) {
    this.name = name;
    this.foo = function () {
        console.log(this.name);
        return function () {
        	console.log(this.name);
        }
    }
}
var person1 = new Person('person1');
var person2 = new Person('person2');

person1.foo.call(person2)(); // person2 window
person1.foo().call(person2); // person1 person2

在做这类题的时候，你就把Person生成的person1脑补成：

var person1 = {
	name: 'person1',
	foo: function () {
		console.log(this.name);
		return function () {
			console.log(this.name);
		}
	}
}

所以答案很容易就出来了：

'person2'
'window'
'person1'
'person2'

解题分析：

person1.foo.call(person2)()将foo()函数内的this指向了person2，所以打印出person2，而内部返回的匿名函数是由window调用的，所以打印出window。(类似题目4.9)
person1.foo().call(person2)是将匿名函数的this显式绑定到了person2上，所以打印出来的会是person2。

7. 箭头函数绑定

终于到了期待已久的箭头函数绑定 😁。

在上面👆，我们有学到一个诀窍：this 永远指向最后调用它的那个对象。

但是对于箭头函数就不是这样咯，它里面的this是由外层作用域来决定的，且指向函数定义时的this而非执行时。

它里面的this是由外层作用域来决定的啥意思呢？来看看这句话：

箭头函数中没有 this 绑定，必须通过查找作用域链来决定其值，如果箭头函数被非箭头函数包含，则 this 绑定的是最近一层非箭头函数的 this，否则，this 为 undefined。

而且指向函数定义时的this而非执行时这句话可以等会儿看题目7.4。

读了这句话相信你已经能解决80%的题目了，让我们看完了第一题7.1之后，再来看看箭头函数可以分为哪几类题目来说吧，这是目录：

字面量对象中普通函数与箭头函数的区别: 只有一层函数的题目
字面量对象中普通函数与箭头函数的区别：函数嵌套的题目
构造函数对象中普通函数和箭头函数的区别：只有一层函数的题目
构造函数对象中普通函数和箭头函数的区别：函数嵌套的题目
箭头函数结合.call的题目

7.1 题目一

var obj = {
    name: 'obj',
    foo1: () => {
    	console.log(this.name);
    },
    foo2: function () {
        console.log(this.name);
        return () => {
        	console.log(this.name);
        }
    }
}
var name = 'window';
obj.foo1(); // window
obj.foo2()(); // obj obj

这道题就非常有代表性，它明确了箭头函数内的this是由外层作用域决定的。

对于obj.foo1()函数的调用，它的外层作用域是window，对象obj当然不属于作用域了(我们知道作用域只有全局作用域window和局部作用域函数)。所以会打印出window
obj.foo2()()，首先会执行obj.foo2()，这不是个箭头函数，所以它里面的this是调用它的obj对象，因此打印出obj，而返回的匿名函数是一个箭头函数，它的this由外层作用域决定，那也就是函数foo2咯，那也就是它的this会和foo2函数里的this一样，就也打印出了obj。

答案：

1
2
3

'window'
'obj'
'obj'

做完了这道题心里是不是有点谱了，感觉也不是那么难嘛…😁

让我们来拆分一下看看区别。

7.2 题目二

字面量对象中普通函数与箭头函数的区别: 只有一层函数的题目

var name = 'window';
var obj1 = {
	name: 'obj1',
	foo: function () {
		console.log(this.name);
	}
}

var obj2 = {
	name: 'obj2',
	foo: () => {
		console.log(this.name);
	}
}

obj1.foo(); // obj1
obj2.foo(); // window

解题分析：

不使用箭头函数的obj1.foo()是由obj1调用的，所以this.name为obj1。
使用箭头函数的obj2.foo()的外层作用域是window，所以this.name为window。

答案：

1 2	'obj1' 'window'

7.3 题目三

字面量对象中普通函数与箭头函数的区别：函数嵌套的题目

如果用普通函数和箭头函数来做一层嵌套关系的话，一共有四种情况，让我们把每种情况都考虑一遍 😁：

var name = 'window';
var obj1 = {
    name: 'obj1',
    foo: function () {
        console.log(this.name);
        return function () {
        	console.log(this.name);
        }
    }
}
var obj2 = {
    name: 'obj2',
    foo: function () {
        console.log(this.name);
        return () => {
        	console.log(this.name);
        }
    }
}
var obj3 = {
    name: 'obj3',
    foo: () => {
        console.log(this.name);
        return function () {
        	console.log(this.name);
        }
    }
}
var obj4 = {
    name: 'obj4',
    foo: () => {
        console.log(this.name)
        return () => {
        	console.log(this.name)
        }
    }
}

obj1.foo()(); // obj1 window
obj2.foo()(); // obj2 obj2
obj3.foo()(); // window window
obj4.foo()(); // window obj4

解题分析：

obj1.foo()()两层都是普通函数，类似于题目4.6，分别打印出obj1和window。
obj2.foo()()外层为普通函数，内层为箭头，类似于题目7.1，都是打印出obj2。
obj3.foo()()外层为箭头函数，内层为普通函数，箭头函数的this由外层作用域决定，因此为window，内层普通函数由调用者决定，调用它的是window，因此也为window。
obj4.foo()()两层都是箭头函数，第一个箭头函数的this由外层作用域决定，因此为window，第二个箭头函数的this也由外层作用域决定，它的外层作用域是第一个箭头函数，而第一个箭头函数的this是window，因此内层的this也是window。

哈哈 😄，其实大家不用担心，做这类题只要谨记法则，找到规律，什么题都可以解了！

7.4 题目四

构造函数对象中普通函数和箭头函数的区别：一层函数的题目

var name = 'window';
function Person (name) {
    this.name = name；
    this.foo1 = function () {
    	console.log(this.name)；
    }
    this.foo2 = () => {
    	console.log(this.name)；
    }
}
var person2 = {
    name: 'person2',
    foo2: () => {
    	console.log(this.name)；
    }
}
var person1 = new Person('person1');
person1.foo1(); // person1
person1.foo2(); // person1
person2.foo2();  // window

解题思路：

person1.foo1()是个普通函数，this由最后调用它的对象决定，即person1。
person1.foo2()为箭头函数，this由外层作用域决定，且指向函数定义时的this而非执行时，在这里它的外层作用域是函数Person，且这个是构造函数，并且使用了new来生成了对象person1，所以此时this的指向是为person1。
person2.foo2()字面量创建的的对象person2中的foo2是个箭头函数，由于person2是直接在window下创建的，你可以理解为它所在的作用域就是在window下，因此person2.foo2()内的this应该是window。

答案：

1
2
3

'person1'
'person1'
'window'

7.5 题目五

构造函数对象中普通函数和箭头函数的区别：函数嵌套的题目

var name = 'window';
function Person (name) {
    this.name = name;
    this.foo1 = function () {
        console.log(this.name);
        return function () {
        	console.log(this.name);
        }
    }
    this.foo2 = function () {
        console.log(this.name);
        return () => {
        	console.log(this.name);
        }
    }
    this.foo3 = () => {
        console.log(this.name);
        return function () {
        	console.log(this.name);
        }
    }
    this.foo4 = () => {
        console.log(this.name);
        return () => {
        	console.log(this.name);
        }
    }
}
var person1 = new Person('person1');
person1.foo1()(); // person1 window
person1.foo2()(); // person1 person1
person1.foo3()(); // person1 window
person1.foo4()(); // person1 person1

解题分析：

person1.foo1()()两层都是普通函数，这个不再重复说了，打印出person1和window。(类似题目6.2)
person1.foo2()()第一层普通函数，它的this是由最后调用它的对象决定也就是person1，第二层为箭头函数，它的this由外层作用域决定，也就是foo2这个函数，因此也为person1。
person1.foo3()()第一层为箭头函数，this由外层作用域决定，因此为person1，第二层为普通函数，由最后调用者决定，因此为window。
person1.foo4()()两层都是箭头函数，this由外层作用域决定，所以都是person1。

7.6 题目六

箭头函数结合.call的题目

箭头函数的this无法通过bind、call、apply来直接修改，但是可以通过改变作用域中this的指向来间接修改。

var name = 'window';
var obj1 = {
    name: 'obj1',
    foo1: function () {
        console.log(this.name);
        return () => {
        	console.log(this.name);
        }
    },
    foo2: () => {
        console.log(this.name);
        return function () {
        	console.log(this.name);
        }
    }
}
var obj2 = {
	name: 'obj2'
}
obj1.foo1.call(obj2)(); // obj2 obj2 
obj1.foo1().call(obj2); // obj1 obj1
obj1.foo2.call(obj2)(); // window window
obj1.foo2().call(obj2); // window obj2

解题分析：

obj1.foo1.call(obj2)()第一层为普通函数，并且通过.call改变了this指向为obj2，所以会打印出obj2，第二层为箭头函数，它的this和外层作用域中的this相同，因此也是obj2。
obj1.foo().call(obj2)第一层打印出obj1，第二层为箭头函数，使用了.call想要修改this的指向，但是并不能成功，因此.call(obj2)对箭头函数无效，还是打印出obj1。
obj1.foo2.call(obj2)()第一层为箭头函数，并且想要通过.call(obj2)改变this指向，但是无效，且它的外层作用域是window，所以会打印出window，第二层为普通函数，this是最后调用者window，所以也会打印出window。
obj1.foo2().call(obj2)第一层为箭头函数，外层作用域是window，打印出window，第二层为普通函数，且使用了.call(obj2)来改变this指向，所以打印出了obj2。

在这道题中，obj1.foo1.call(obj2)()就相当于是通过改变作用域间接改变箭头函数内this的指向。

总结

OK👌，来总结一下箭头函数需要注意的点吧：

它里面的this是由外层作用域来决定的，且指向函数定义时的this而非执行时
字面量创建的对象，作用域是window，如果里面有箭头函数属性的话，this指向的是window
构造函数创建的对象，作用域是可以理解为是这个构造函数，且这个构造函数的this是指向新建的对象的，因此this指向这个对象。
箭头函数的this是无法通过bind、call、apply来直接修改，但是可以通过改变作用域中this的指向来间接修改。

优点

箭头函数写代码拥有更加简洁的语法(当然也有人认为这是缺点)
this由外层作用域决定，所以在某些场合我们不需要写类似const that = this这样的代码

避免使用的场景

根据箭头函数的特性，所以我们应该避免在以下四种场景中使用它：

1.使用箭头函数定义对象的方法

let obj = {
    value: 'LinDaiDai',
    getValue: () => console.log(this.value)
}
obj.getValue(); // undefined

2.定义原型方法

function Foo (value) {
    this.value = value;
}
Foo.prototype.getValue = () => console.log(this.value);

const foo1 = new Foo(1);
foo1.getValue(); // undefined

3.构造函数使用箭头函数

const Foo = (value) => {
    this.value = value;
}
const foo1 = new Foo(1);
// 事实上直接就报错了 Uncaught TypeError: Foo is not a constructor
console.log(foo1);

4.作为事件的回调函数

const button = document.getElementById('myButton');
button.addEventListener('click', () => {
    console.log(this === window); // => true
    this.innerHTML = 'Clicked button';
});

8. 综合题

哈哈哈～

this大法已练成，接下来到了我们最喜欢的综合题环节。

让我们来做些难点的题巩固巩固吧！

8.1 题目一

字面量对象中的各种场景

var name = 'window';
var person1 = {
    name: 'person1',
    foo1: function () {
    	console.log(this.name);
    },
    foo2: () => console.log(this.name),
    foo3: function () {
        return function () {
        	console.log(this.name);
        }
    },
    foo4: function () {
        return () => {
        	console.log(this.name);
        }
    }
}
var person2 = { name: 'person2' };

person1.foo1(); // person1
person1.foo1.call(person2); // person2

person1.foo2(); // window
person1.foo2.call(person2); // window

person1.foo3()(); // window
person1.foo3.call(person2)(); // window
person1.foo3().call(person2); // person2

person1.foo4()(); // person1
person1.foo4.call(person2)(); // person2
person1.foo4().call(person2); // person1

这里我就不写题解了，因为如果你认真看了前面的题目的话，我相信一定能做的来，其实就是将原本分散的知识点汇总在一起。

person1.foo1()类似题目4.5
person1.foo2()类似题目7.1
person1.foo3()类似题目7.3
person1.foo4()类似题目7.3

8.2 题目二

构造函数中的各种场景

var name = 'window';
function Person (name) {
    this.name = name;
    this.foo1 = function () {
    	console.log(this.name);
    },
    this.foo2 = () => console.log(this.name),
    this.foo3 = function () {
        return function () {
        	console.log(this.name);
        }
    },
    this.foo4 = function () {
        return () => {
        	console.log(this.name);
        }
    }
}
var person1 = new Person('person1');
var person2 = new Person('person2');

person1.foo1(); // person1
person1.foo1.call(person2); // person2

person1.foo2(); // person1
person1.foo2.call(person2); // person1

person1.foo3()(); // window
person1.foo3.call(person2)(); // window
person1.foo3().call(person2); // person2

person1.foo4()(); // person1
person1.foo4.call(person2)(); // person2
person1.foo4().call(person2); // person1

person1.foo1()类似题目7.4
person1.foo2()类似题目7.4
person1.foo3()类似题目7.5
person1.foo4()类似题目7.5

8.3 题目三

var name = 'window';
function Person (name) {
    this.name = name;
    this.obj = {
        name: 'obj',
        foo1: function () {
            return function () {
            	console.log(this.name);
            }
        },
        foo2: function () {
            return () => {
            	console.log(this.name);
            }
        }
    }
}
var person1 = new Person('person1');
var person2 = new Person('person2');

person1.obj.foo1()(); // window
person1.obj.foo1.call(person2)(); // window
person1.obj.foo1().call(person2); // person2

person1.obj.foo2()(); // obj
person1.obj.foo2.call(person2)(); // person2
person1.obj.foo2().call(person2); // obj

这道题还是蛮有意思的，可以仔细说下。

首先是定义了一个构造函数Person，不过它与前面几题的区别就是，函数是放在其中的一个叫obj的对象里面。

在这里我提醒一句：this 永远指向最后调用它的那个对象。

解题分析：

person1.obj.foo1()()返回的是一个普通的匿名函数，调用它的是window，所以打印出window。
person1.obj.foo1.call(person2)()中是使用.call(person2)改变第一层函数中的this，匿名函数和它没关系，依旧是window调用的，所以打印出window。
person1.obj.foo1().call(person2)是通过.call(person2)改变匿名函数内的this，所以绑定有效，因此打印出person2。
person1.obj.foo2()()第一层为普通函数，第二层为匿名箭头函数。首先让我们明确匿名箭头函数内的this是由第一层普通函数决定的，所以我们只要知道第一层函数内的this是谁就可以了。而这里，第一层函数最后是由谁调用的呢 🤔️？是由obj这个对象，所以打印出obj。
person1.obj.foo2.call(person2)()中使用.call(person2)改变了第一层函数中的this指向，所以第二层的箭头函数会打印出person2。
person1.obj.foo2().call(person2)中使用.call(person2)想要改变内层箭头函数的this指向，但是失败了，所以还是为外层作用域里的this，打印出obj。

8.4 题目四

这道题是在评论区看到的，觉得挺不错的，所以加到文章中(感谢👀小伙伴提供的题目)

来看看这里会打印出什么呢？

function foo() {
	console.log( this.a );
}
var a = 2;
(function(){
    "use strict";
    foo();
})();

答案并不是undefined，也不会报错，而是打印出了2。

哈哈😄，其实这里是有一个迷惑点的，那就是"use strict"。

我们知道，使用了"use strict"开启严格模式会使得"use strict"以下代码的this为undefined，也就是这里的立即执行函数中的this是undefined。

但是调用foo()函数的依然是window，所以foo()中的this依旧是window，所以会打印出2。

如果你是使用this.foo()调用的话，就会报错了，因为现在立即执行函数中的this是undefined。

或者将"use strict"放到foo()函数里面，也会报错。

9. 几道手写题

面试中，还有一些和this相关的手写函数也是经常会被考到的，比如实现new、call、apply、bind。

我在学习过程中发现最主要的还是要理解你要实现的这个东西，到底是有什么功能的，或者有什么特性，然后我们在构建的时候看能用什么方法来达到这样的功能。

9.1 手写一个new实现

我们要实现一个new，首先要明白它有哪些特性。

看下面这个例子：

function Person (name) {
	this.name = name;
}
Person.prototype.eat = function () {
	console.log('Eatting');
}
var lindaidai = new Person('LinDaiDai');
console.log(lindaidai);
lindaidai.eat();

使用new创建的实例：

能访问到构造函数里的属性(name)
能访问原型中的属性(eat)

new操作符做了这些事：

创建一个全新的对象，这个对象的__proto__要指向构造函数的原型对象
执行构造函数
返回值为object类型则作为new方法的返回值返回，否则返回上述全新对象

根据特性，我们可以这样实现：

function myNew() {
    // 1. 获取构造函数，并且删除 arguments 中的第一项
    var fn = [].shift.call(arguments);
    // 2. 创建一个空的对象并链接到构造函数的原型，使它能访问原型中的属性
    var obj = Object.create(fn.prototype);
    // 3. 使用apply改变构造函数中this的指向实现继承，使obj能访问到构造函数中的属性
    var res = fn.apply(obj, arguments);
    // 4. 优先返回构造函数返回的对象
    return res instanceof Object ? res : obj;
}

可以简化写作

function myNew(fn, ...args) {
    var obj = Object.create(fn.prototype);
    var res = fn.apply(obj, args);
    return typeof res === 'object' ? res: obj;
}

这里要提一嘴，第四步中为什么要做这么一个判断呢？

主要是你要考虑构造函数它有没有返回值。

像我们案例中的构造函数Person它是没有返回值的。

// 1.有返回值且为对象
function Person (name, sex) {
	this.name = name;
	return {
		sex: sex
	}
}
// 2. 没有返回值
function Person (name) {
	this.name = name;
}
// 3. 返回值为基本类型
function Person (name) {
	this.name = name;
	return 'str';
}

构造函数中有返回值且为对象，那么创建的实例就只能访问到返回对象中的属性，所以要判断一下ret的类型，如果是对象的话，则返回这个对象。
构造函数中没有返回值，那么创建的实例就能访问到这个构造函数中的所有属性了，此时ret就会为undefined，所以返回obj。
构造函数中有返回值但是返回值是undefined以外的其它基本类型(比如字符串)，这种情况当成第二种情况(没有返回值)来处理。

验证：

来验证一下可行性：

function Person (name) {
	this.name = name;
}
Person.prototype.eat = function () {
	console.log('Eatting');
}
function myNew() {
    // 1. 获取构造函数，并且删除 arguments 中的第一项
    var fn = [].shift.call(arguments);
    // 2. 创建一个空的对象并链接到构造函数的原型，使它能访问原型中的属性
    var obj = Object.create(fn.prototype);
    // 3. 使用apply改变构造函数中this的指向实现继承，使obj能访问到构造函数中的属性
    var res = fn.apply(obj, arguments);
    // 4. 优先返回构造函数返回的对象
    return res instanceof Object ? res : obj;
}
var lindaidai = myNew(Person, 'LinDaiDai');
console.log(lindaidai); // Person{ name: 'LinDaiDai' }
lindaidai.eat(); // 'Eatting'

9.2 手写一个call函数实现

ES5实现及过程分析：

function fnFactory(context) {
    var unique_fn = "fn";
    while (context.hasOwnProperty(unique_fn)) {
    	unique_fn = "fn" + Math.random();
    }
    return unique_fn;
}
Function.prototype.myCall1 = function(context) {
    // 1. 若是传入的context是null或者undefined时指向window;
    // 2. 若是传入的是原始数据类型, 原生的call会调用 Object() 转换
    context = (context !== null && context !== undefined) ? Object(context) : window;
    // 3. 创建一个独一无二的fn函数的命名
    var fn = fnFactory(context);
    // 4. 这里的this就是指调用call的那个函数
    // 5. 将调用的这个函数赋值到context中, 这样之后执行context.fn的时候, fn里的this就是指向context了
    context[fn] = this;
    // 6. 定义一个数组用于放arguments的每一项的字符串: ['agruments[1]', 'arguments[2]']
    var args = [];
    // 7. 要从第1项开始, 第0项是context
    for (var i = 1, l = arguments.length; i < l; i++) {
    	args.push("arguments[" + i + "]");
    }
    // 8. 使用eval()来执行fn并将args一个个传递进去
    var result = eval("context[fn](" + args + ")");
    // 9. 给context额外附件了一个属性fn, 所以用完之后需要删除
    delete context[fn];
    // 10. 函数fn可能会有返回值, 需要将其返回
    return result;
};

ES6实现：

模拟实现call

1.判断当前this是否为函数，防止Function.prototype.myCall() 直接调用

2.context 为可选参数，如果不传的话默认上下文为 window

3.为context 创建一个 Symbol（保证不会重名）属性，将当前函数赋值给这个属性

4.处理参数，传入第一个参数后的其余参数

5.调用函数后即删除该Symbol属性

/*
* context为函数运行时要使用的this值 默认将context指向window 注意仅在非严格模式下会有这种行为
* args 为一个数组或者类数组对象，是调用函数时的参数列表
*/
Function.prototype.myCall2 = function (context = window, ...args) {
	// 用于防止 Function.prototype.myCall() 直接调用
	if (this === Function.prototype) return undefined;
	// context = context || window;
    // 为了防止原来的属性被覆盖，用Symbol去创建一个独一无二的值
	let fn = Symbol();
    // 这里this指向调用myCall的函数
	context[fn] = this;
    // 重点代码，利用this指向，调用myCall的函数,并接收返回值
	let result = context[fn](...args);
    // 最后删除这个临时属性
	delete context[fn];
    // 返回结果
	return result;
}

测试代码

var obj = {
	name: "objName"
};

function consoleInfo(sex, weight) {
	console.log(this.name, sex, weight);
}
var name = "globalName";
consoleInfo.myCall1(obj, "man", 100); // 'objName' 'man' 100
consoleInfo.myCall2(obj, "woman", 120); // 'objName' 'woman' 120

9.3 手写一个apply实现

ES5实现及过程分析：

function fnFactory(context) {
    var unique_fn = "fn";
    while (context.hasOwnProperty(unique_fn)) {
    	unique_fn = "fn" + Math.random();
    }
    return unique_fn;
}
Function.prototype.apply2 = function(context, arr) {
    // 1. 若是传入的context是null或者undefined时指向window;
    // 2. 若是传入的是原始数据类型, 原生的call会调用 Object() 转换
    context = context ? Object(context) : window;
    // 3. 创建一个独一无二的fn函数的命名
    var fn = fnFactory(context);
    // 4. 这里的this就是指调用call的那个函数
    // 5. 将调用的这个函数赋值到context中, 这样之后执行context.fn的时候, fn里的this就是指向context了
    context[fn] = this;

    var result;
    // 6. 判断有没有第二个参数
    if (!arr) {
    	result = context[fn]();
    } else {
        // 7. 有的话则用args放每一项的字符串: ['arr[0]', 'arr[1]']
        var args = [];
        for (var i = 0, len = arr.length; i < len; i++) {
            args.push("arr[" + i + "]");
        }
        // 8. 使用eval()来执行fn并将args一个个传递进去
        result = eval("context[fn](" + args + ")");
    }
    // 9. 给context额外附件了一个属性fn, 所以用完之后需要删除
    delete context[fn];
    // 10. 函数fn可能会有返回值, 需要将其返回
    return result;
};

ES6实现：

/*
* context为函数运行时要使用的this值 默认将context指向window 注意仅在非严格模式下会有这种行为
* args 为一个数组或者类数组对象，是调用函数时的参数列表
*/
Function.prototype.myApply2 = function (context = window, args) {
	// 用于防止 Function.prototype.myApply() 直接调用
    if (this === Function.prototype) return undefined;
    // context = context || window;
    // 为了防止原来的属性被覆盖，用Symbol去创建一个独一无二的值
    let fn = Symbol();
    // 这里this指向调用myApply的函数
    context[fn] = this;
    // 重点代码，利用this指向，相当于context.caller(...args)
    let result = context[fn](...args);
    // 最后删除这个临时属性
    delete context[fn];
    // 返回结果
    return result;
}

9.4 手写一个bind函数实现

提示:

函数内的this表示的就是调用的函数
可以将上下文传递进去, 并修改this的指向
返回一个函数
可以传入参数
柯里化
一个绑定的函数也能使用new操作法创建对象, 且提供的this会被忽略

ES5实现及过程分析：

Function.prototype.myBind1 = function(context) {
    // 1. 判断调用bind的是不是一个函数
    if (typeof this !== "function") {
        throw new Error(
        	"Function.prototype.bind - what is trying to be bound is not callable"
        );
    }
    // 2. 外层的this指向调用者(也就是调用的函数)
    var self = this;
    // 3. 收集调用bind时的其它参数
    var args = Array.prototype.slice.call(arguments, 1);

    // 4. 创建一个返回的函数
    var fBound = function() {
        // 6. 收集调用新的函数时传入的其它参数
        var innerArgs = Array.prototype.slice.call(arguments);
        // 7. 使用apply改变调用函数时this的指向
        // 作为构造函数调用时this表示的是新产生的对象, 不作为构造函数用的时候传递context
        return self.apply(
            this instanceof fNOP ? this : context,
            args.concat(innerArgs)
        );
    };
    // 5. 创建一个空的函数, 且将原型指向调用者的原型(为了能用调用者原型中的属性)
    // 下面三步的作用有点类似于 fBoun.prototype = this.prototype 但有区别
    var fNOP = function() {};
    fNOP.prototype = this.prototype;
    fBound.prototype = new fNOP();
    // 8. 返回最后的结果
    return fBound;
};

ES6实现：

1.处理参数，返回一个闭包

2.判断是否为构造函数调用，如果是则使用new调用当前函数

3.如果不是，使用apply，将context和处理好的参数传入

Function.prototype.myBind = function (context = window, ...args) {
	if (this === Function.prototype) return undefined;
	const _this = this
    // 返回一个函数
    return function F(...arguments) {
        // 因为返回了一个函数，我们可以 new F()，所以需要判断
        if (this instanceof F) {
            return new _this(...args, ...arguments)
        }
        return _this.apply(context, args.concat(...arguments))
    }
}

/*
* context为函数运行时要使用的this值 默认将context指向window 注意仅在非严格模式下会有这种行为
* args 为一个数组或者类数组对象，是调用函数时的参数列表
*/
Function.prototype.myBind = function (context = window, ...args) {
    // 为了防止原来的属性被覆盖，用Symbol去创建一个独一无二的值
    let fn = Symbol();
    // 这里this指向调用myApply的函数
    context[fn] = this;
    // 返回闭包函数
    return function (..._args) {
        // 与当前参数组合
        args = args.concat(_args);
        // 重点代码，执行函数
        context[fn](...args);
        // 最后删除这个临时属性
        delete context[fn];   
    }
}

友情链接

关于手写实现的具体实现方式可以查看木易杨大大这里：

《木易杨前端进阶-深度解析bind原理、使用场景及模拟实现》