JS中this指向问题（一看就会）

this 的值取决于它出现的上下文：函数、类或全局。

全局上下文

非严格模式下，当this出现在全局作用域中，它永远指向全局对象（在浏览器中通常是window）。

// 在网页浏览器中，window 对象也是全局对象：
console.log(this === window); // true

this.a = "test";
console.log(window.a); // "test"
console.log(a); // "test"

function fun1(){
	console.log(this);
}
fun1();//输出 Window

const fun2 = function(){  
    console.log(this);  
}   
fun2();//输出 Window

全局函数（严格模式）

严格模式下，当this出现在全局函数中，this为undefined。

function strictFun1() {  
    'use strict';  
    console.log(this); 
}  
strictFun1();// 输出 undefined  

函数作为对象方法调用

当函数作为对象的方法被调用时，this指向调用该方法的对象，原型链上的方法根对象方法一样，this指向调用该方法的对象。

const obj1 = {
   name:"obj1",
    fun3() {
        console.log(this);
    },
};
const obj2 = {
    name: "obj2",
    __proto__: obj1,

};
obj1.fun3();// 输出 { name: 'obj1', fun3(){} }
obj2.fun3();// 输出 { name: 'obj2' }

构造函数

当一个函数被用作构造函数（使用 new 关键字）时，无论构造函数是在哪个对象上被访问的，其 this 都会被绑定到正在构造的新对象上，也就是构造函数实例化的对象。除非使用call()，apply()等手动重定义 this指向。

	var name = 'window'

    function Person (name) {
        this.name = name;
        this.show1 = function () {
            console.log(this.name)
        }
        this.show2 = function () {
            return function () {
            console.log(this.name)
            }
        }
    }
    
    var personA = new Person('personA')//构造函数中的this指向personA
    var personB = new Person('personB')//构造函数中的this指向personB

    personA.show1()//输出 personA
    personA.show1.call(personB)//输出 personB

    personA.show2()()//输出 window
    //因为 personA.show2()()=function (){ console.log(this.name)}，是一个全局函数
    personA.show2().call(personB)//输出 personB
    //设置全局函数的this为personB
    personA.show2.call(personB)()//输出 window
    //设置外层函数的this为personB，但实际执行的return返回的函数，返回的函数是一个全局函数

箭头函数

箭头函数它们不绑定自己的this值，而是捕获其所在上下文的this值。 这意味着箭头函数内部的 this 会指向最近一层非箭头函数作用域的 this，而不是箭头函数自身的 this。箭头函数的this指向在定义时就已经确定，并且不会被函数调用方式改变，也不会被上下文环境影响。无论你怎么尝试通过 .call(), .apply(), 或 .bind() 来改变箭头函数中的 this，它都会忽略这些尝试，并继续使用它创建时所在上下文的 this 值。

下面是一个简单的例子，展示了这一点：

对象中

在对象字面量中定义箭头函数时，箭头函数会捕获其所在上下文的this值。

var name = 'window'

var person1 = {
  name: 'person1',
  show1: () => console.log(this.name),//this 指向全局
  show2: function () {//this指向对象person1
    return () => console.log(this.name)//捕获到所在上下文的 this，上下文的 this指向对象person1
  }
}
var person2 = { name: 'person2' }

person1.show1()//输出 window
person1.show1.call(person2)//输出 window
//show1 是箭头函数，this 的值不会改变，使用call方法来无法改变，它仍然引用全局对象。
person1.show2()()//输出 person1
//返回的箭头函数捕获到所在上下文的 this，上下文的 this指向对象person1
person1.show2().call(person2)//输出 person1
//最后返回的是箭头函数，this 的值不会改变，但是捕获到所在上下文的 this，上下文的 this指向对象person1
person1.show2.call(person2)()//输出 person2
//call方法先改变了箭头函数上下文的this指向，此时上下文的this指向person2，然后执行返回的箭头函数
获到所在上下文的 this

构造函数中

如果在构造函数的内部定义了一个箭头函数，那么这个箭头函数内部的 this 并不会指向构造函数的实例，而是会捕获其外部作用域（通常是构造函数本身或全局作用域）中的 this 值。这是因为箭头函数没有自己的 this 上下文，它会继承外层函数（或全局作用域）的 this 值。

var name = 'window'

function Person (name) {
  this.name = name;
  this.show1 = () => console.log(this.name)
  this.show2 = function () {
    return () => console.log(this.name)
  }
}

var personA = new Person('personA')
var personB = new Person('personB')

personA.show1()//personA
//箭头函数没有被外层函数包裹，捕获的外部作用域是构造函数本身
personA.show1.call(personB)//personA
//箭头函数没有被外层函数包裹，捕获的外部作用域是构造函数本身，使用call改变箭头函数中的this上下文是无效的

personA.show2()()//personA
//最后执行的是返回的箭头函数，箭头函数被外层函数包裹，继承外层函数的this值personA。
personA.show2().call(personB)//personA
//最后执行的是返回的箭头函数，箭头函数被外层函数包裹，继承外层函数的this值personA，使用call改变箭头函数中的this上下文是无效的
personA.show2.call(personB)()//personB
//personA.show2.call(personB)将外层函数的this值修改为personB，最后执行的是返回的箭头函数，箭头函数被外层函数包裹，继承外层函数的this值，也就是personB。