this指向的又一点坑

        function person(name){
            // this.name = name
            let obj = {}
            obj.name = name
            obj.getname = ()=>{
                console.log(this);
            }
            // 有return对象的时候就不能算是一个构造函数，虽然后面是new，但是只是执行一遍person函数而已
            // p得到的就是return回去的obj，所以p就是obj
            // 那么p.getname()一执行，就是执行obj.getname()，又因为箭头函数没有自己的this，往外找到person

            // 那么这样把obj赋值给p，通过p调用函数，this指向的韩式该对象，是因为赋值的是对象的地址而已
            // 但是如果像下面那样，把对象下的方法赋值给另一个对象，就会去找谁调用的该方法，
            // 相当于绕开了原本的对象，直接调用这个方法，所以是window
            return obj
        }
        let p = new person('lisi')
        console.log(p);
        p.getname()

        let obj = {
            name:'LISI',
            say(){
                console.log(this);
            }
        }
        obj.say()
        let p2 = obj
        p2.say()
        let fn = obj.say
        fn()

函数里面有return对象的时候就不能算是一个构造函数，虽然后面是new，但是只是执行一遍person函数而已，new了的p得到的就是return回去的obj对象不是一个实例对象，所以p就是obj，

那么p.getname()一执行，就是执行obj.getname()，又因为箭头函数没有自己的this，往外找到person

那么这样把obj赋值给p，通过p调用函数，this指向的还是该对象，是因为赋值的是对象的地址而已

但是如果像下面那样，把对象里的方法赋值给另一个对象，就会去找谁调用的该方法，

相当于绕开了原本的对象，直接调用这个方法，所以是window

        let obj = {
            name: 'LISI',
            say() {
                console.log(this);
            }
        }

        let obj2 = {
            name: 'lisi',
            say: () => {
                console.log(this);
            }
        }
        
        let obj1 = {
            name: 'wangwu'
        }
        obj.say()
        obj.say.call(obj1)
        obj2.say()
        obj2.say.call(obj1)

当箭头函数作为方法的时候，由于箭头函数，没有自身的this，所以顺着外部去找，当调用obj2.say()的时候，外面就是window，当用bind、call等，依旧是改变不了this的，还是window
参考this问题

var obj = {
  i: 10,
  b: () => console.log(this.i, this),
  c: function() {
    console.log( this.i, this)
  }
}
obj.b();  // undefined window{...}
obj.c();  // 10 Object {...}

但是如果箭头函数是对象中的方法内部的，相对于再套了一层，那么调用的时候，this顺着外面找就能找到这个对象，而不再是外面的window，

var adder = {
  base : 1,
    
  add : function(a) {
    var f = v => v + this.base;
    return f(a);
  },
 
  addThruCall: function inFun(a) {
    var f = v => v + this.base;
    var b = {
      base : 2
    };
            
    return f.call(b, a);
  }
};
 
console.log(adder.add(1));         // 输出 2
console.log(adder.addThruCall(1)); // 仍然输出 2（而不是3，其内部的this并没有因为call() 而改变，其this值仍然为函数inFun的this值，指向对象adder

比如：

        var a = 2

        var obj = {
            a: 3,
            fn: function () {
                (() => {
                    console.log(this);
                    console.log(this.a)
                })()
            },
        }

        var obj1 = {
            a: 3,
            fn: () => {
                console.log(this);
                console.log(this.a)
            },
        }
        obj.fn()
        obj1.fn()