一、定义

函数的 this 关键字在 JavaScript 中的表现略有不同，此外，在严格模式和非严格模式之间也会有一些差别

在绝大多数情况下，函数的调用方式决定了 this 的值（运行时绑定）

this 关键字是函数运行时自动生成的一个内部对象，只能在函数内部使用，总指向调用它的对象

举个例子：

复制
1function baz() {
2    // 当前调用栈是：baz
3    // 因此，当前调用位置是全局作用域
4    
5    console.log( "baz" );
6    bar(); // <-- bar的调用位置
7}
8
9function bar() {
10    // 当前调用栈是：baz --> bar
11    // 因此，当前调用位置在baz中
12    
13    console.log( "bar" );
14    foo(); // <-- foo的调用位置
15}
16
17function foo() {
18    // 当前调用栈是：baz --> bar --> foo
19    // 因此，当前调用位置在bar中
20    
21    console.log( "foo" );
22}
23
24baz(); // <-- baz的调用位置

同时，this在函数执行过程中，this一旦被确定了，就不可以再更改

复制
1var a = 10;
2var obj = {
3  a: 20
4}
5
6function fn() {
7  this = obj; // 修改this，运行后会报错
8  console.log(this.a);
9}
10
11fn();

二、绑定规则

根据不同的使用场合，this有不同的值，主要分为下面几种情况：

• 默认绑定

• 隐式绑定

• new绑定

• 显示绑定

默认绑定

全局环境中定义person函数，内部使用this关键字

复制
1var name = 'Jenny';
2function person() {
3    return this.name;
4}
5console.log(person());  //Jenny

上述代码输出Jenny，原因是调用函数的对象在游览器中位window，因此this指向window，所以输出Jenny

注意：

严格模式下，不能将全局对象用于默认绑定，this会绑定到undefined，只有函数运行在非严格模式下，默认绑定才能绑定到全局对象

隐式绑定

函数还可以作为某个对象的方法调用，这时this就指这个上级对象

复制
1function test() {
2  console.log(this.x);
3}
4
5var obj = {};
6obj.x = 1;
7obj.m = test;
8
9obj.m(); // 1

这个函数中包含多个对象，尽管这个函数是被最外层的对象所调用，this指向的也只是它上一级的对象

复制
1var o = {
2    a:10,
3    b:{
4        fn:function(){
5            console.log(this.a); //undefined
6        }
7    }
8}
9o.b.fn();

上述代码中，this的上一级对象为b，b内部并没有a变量的定义，所以输出undefined

这里再举一种特殊情况

复制
1var o = {
2    a:10,
3    b:{
4        a:12,
5        fn:function(){
6            console.log(this.a); //undefined
7            console.log(this); //window
8        }
9    }
10}
11var j = o.b.fn;
12j();

此时this指向的是window，这里的大家需要记住，this永远指向的是最后调用它的对象，虽然fn是对象b的方法，但是fn赋值给j时候并没有执行，所以最终指向window

new绑定

通过构建函数new关键字生成一个实例对象，此时this指向这个实例对象

复制
1function test() {
2　this.x = 1;
3}
4
5var obj = new test();
6obj.x // 1

上述代码之所以能过输出1，是因为new关键字改变了this的指向

这里再列举一些特殊情况：

new过程遇到return一个对象，此时this指向为返回的对象

复制
1function fn()  
2{  
3    this.user = 'xxx';  
4    return {};  
5}
6var a = new fn();  
7console.log(a.user); //undefined

如果返回一个简单类型的时候，则this指向实例对象

复制
1function fn()  
2{  
3    this.user = 'xxx';  
4    return 1;
5}
6var a = new fn;  
7console.log(a.user); //xxx

注意的是null虽然也是对象，但是此时new仍然指向实例对象

复制
1function fn()  
2{  
3    this.user = 'xxx';  
4    return null;
5}
6var a = new fn;  
7console.log(a.user); //xxx

显示修改

apply()、call()、bind()是函数的一个方法，作用是改变函数的调用对象。它的第一个参数就表示改变后的调用这个函数的对象。因此，这时this指的就是这第一个参数

复制
1var x = 0;
2function test() {
3　console.log(this.x);
4}
5
6var obj = {};
7obj.x = 1;
8obj.m = test;
9obj.m.apply(obj) // 1

关于apply、call、bind三者的区别，我们后面再详细说

三、箭头函数

在 ES6 的语法中还提供了箭头函语法，让我们在代码书写时就能确定 this 的指向（编译时绑定）

举个例子：

复制
1const obj = {
2  sayThis: () => {
3    console.log(this);
4  }
5};
6
7obj.sayThis(); // window 因为 JavaScript 没有块作用域，所以在定义 sayThis 的时候，里面的 this 就绑到 window 上去了
8const globalSay = obj.sayThis;
9globalSay(); // window 浏览器中的 global 对象

虽然箭头函数的this能够在编译的时候就确定了this的指向，但也需要注意一些潜在的坑

下面举个例子：

绑定事件监听

复制
1const button = document.getElementById('mngb');
2button.addEventListener('click', ()=> {
3    console.log(this === window) // true
4    this.innerHTML = 'clicked button'
5})

上述可以看到，我们其实是想要this为点击的button，但此时this指向了window

包括在原型上添加方法时候，此时this指向window

复制
1Cat.prototype.sayName = () => {
2    console.log(this === window) //true
3    return this.name
4}
5const cat = new Cat('mm');
6cat.sayName()

同样的，箭头函数不能作为构建函数

四、优先级

隐式绑定 VS 显式绑定

复制
1function foo() {
2    console.log( this.a );
3}
4
5var obj1 = {
6    a: 2,
7    foo: foo
8};
9
10var obj2 = {
11    a: 3,
12    foo: foo
13};
14
15obj1.foo(); // 2
16obj2.foo(); // 3
17
18obj1.foo.call( obj2 ); // 3
19obj2.foo.call( obj1 ); // 2

显然，显式绑定的优先级更高

new绑定 VS 隐式绑定

复制
1function foo(something) {
2    this.a = something;
3}
4
5var obj1 = {
6    foo: foo
7};
8
9var obj2 = {};
10
11obj1.foo( 2 );
12console.log( obj1.a ); // 2
13
14obj1.foo.call( obj2, 3 );
15console.log( obj2.a ); // 3
16
17var bar = new obj1.foo( 4 );
18console.log( obj1.a ); // 2
19console.log( bar.a ); // 4

可以看到，new绑定的优先级>隐式绑定

new绑定 VS 显式绑定

因为new和apply、call无法一起使用，但硬绑定也是显式绑定的一种，可以替换测试

复制
1function foo(something) {
2    this.a = something;
3}
4
5var obj1 = {};
6
7var bar = foo.bind( obj1 );
8bar( 2 );
9console.log( obj1.a ); // 2
10
11var baz = new bar( 3 );
12console.log( obj1.a ); // 2
13console.log( baz.a ); // 3

bar被绑定到obj1上，但是new bar(3) 并没有像我们预计的那样把obj1.a修改为3。但是，new修改了绑定调用bar()中的this

我们可认为new绑定优先级>显式绑定

综上，new绑定优先级 > 显示绑定优先级 > 隐式绑定优先级 > 默认绑定优先级