this总结

this总结，mark一下：

Object中的this：

Object方法中的this，指向的就是该对象，即谁调用this就指向谁，与C#等服务器语言的思想比较一致。

let
    demo = {
        name: "dqhan",
        action: function () {
            console.log(this); //{name: "dqhan", action: ƒ}
            (function () {
                console.log(this);//Window {postMessage: ƒ, blur: ƒ, focus: ƒ, close: ƒ, frames: Window, …}
                // "use strict";
                // console.log(this);//undefined
            })();
        }
    };
demo.action();

demo对象调用action，action中的this指向的就是demo，action内部的自执行函数this则指向的是window，严格模式下为undefined。可以写个深层次的demo来看下会不会影响this的指向

let
    demo = {
        name: "dqhan",
        action: function () {
            console.log(this) //{name: "dqhan", action: ƒ, innerDemo: {…}}
        },
        innerDemo: {
            name: 'innerDqhan',
            action: function () {
                console.log(this)//{name: "innerDqhan", action: ƒ}
            }
        }
    };
demo.action();
demo.innerDemo.action();

事实证明不会影响this的指向，这种方式的定义以及调用不参与原型链，不涉及this指向改变的问题。

函数中的this：

匿名函数中，函数体内的this指向为window，严格模式下为undefined。

function demo(){
    console.log(this);//Window {postMessage: ƒ, blur: ƒ, focus: ƒ, close: ƒ, frames: Window, …}
    // "use strict"
    // console.log(this);//undefined
}
demo();

foo = 'outer'
function demo() {
    this.foo = 'inner';
    // "use strict";
    // this.foo = 'inner';//error
}
console.log(foo);//outer
demo();
console.log(foo);//inner

foo在不加var，let(ES6)下自动挂载window下，调用demo后在函数内部将foo重新赋值。严格开发下this为undefined报错。

构造函数中的this：

提到this常常想到的是构造函数，写个简单的demo如下

function Demo() {
    this.name = "dqhan";
    this.action = function () {
        console.log(this)//Demo {name: "dqhan", action: ƒ}
    };
};

let
    demo = new Demo();
demo.action();
console.log(demo.name);//dqhan

调用demo内的action，action中的this指向构造函数的实例化对象，原因是什么呢？这里需要了解一下let demo = new demo();到底发生了什么。

//action1
let
    demo = new Demo();
//action2
let
    demo = {};
demo.__proto__ = Demo.prototype;
Demo.call(demo);

js中new一个实例化对象的过程等价于action2的代码，最后一步通过call方法（apply，bind）将demo对象中的this传递到了Demo构造函数中，从而将构造函数中没有定义在原型中的属性与方法都定义到了demo 对象中，这就是为什么构造函数中的this会是实例化对象的原因。另外我们可以将属性或者方法都定义在原型中

function Demo() {
    this.name = "dqhan";
};
Demo.prototype.action = function () {
    console.log(this)//Demo {name: "dqhan", action: ƒ}
};

let
    demo = new Demo();
console.log(demo.name);//dqhan

我们都清楚，构造函数类似于一个简单工厂模式，我们可以通过一个构造函数生成很多其他对象，我们将属性或者方法定义在原型中，这样可以达到原型共享的目的。

function Demo() {
    this.name = "dqhan";
};
Demo.prototype.action = function () {
    console.log(this)//Demo {name: "dqhan", action: ƒ}
};
let
    demo = new Demo(),
    demo1 = new Demo(),
    demo2 = new Demo();
demo.__proto__ === demo1.__proto__;//true
demo1.__proto__ === demo2.__proto__;//true

当对象非常多的是时候，可以节约内存。

当函数内嵌套匿名函数

function Demo() {
    this.name = "dqhan";
};
Demo.prototype.action = function () {
    console.log(this);//Demo {name: "dqhan", action: ƒ}
    (function () {
        console.log(this);//Window {postMessage: ƒ, blur: ƒ, focus: ƒ, close: ƒ, frames: Window, …}
        // "use strict";
        // console.log(this)//undefined
    })();
};
let
    demo = new Demo();
demo.action();

 定义在构造函数内的方法在传递的时候，实例化对象不会跟着一起传过去

function Demo() {
    this.name = "dqhan";
};
Demo.prototype.action = function () {
    console.log(this);
    
};
function foo(method){
    method();
};
let
    demo = new Demo();
foo(demo.action);//Window {postMessage: ƒ, blur: ƒ, focus: ƒ, close: ƒ, frames: Window, …}

function Demo() {
    this.name = "dqhan";
};
Demo.prototype.action = function (method) {
    console.log(this);
    method();
};
Demo.prototype.actionCallBack = function () {
    console.log(this);
}
let
    demo = new Demo();
demo.action(demo.actionCallBack);
//Demo {name: "dqhan"}
//Window {postMessage: ƒ, blur: ƒ, focus: ƒ, close: ƒ, frames: Window, …}

这两种情况都是将实例化对象中的方法当成参数进行传递。但是在执行函数中，this的上下文已经发生改变。解决方式可以通过bind，apply，call等改变上下文的方式。

function Demo() {
    this.name = "dqhan";
};
Demo.prototype.action = function (method) {
    console.log(this);
    method()
};
Demo.prototype.actionCallBack = function () {
    console.log(this);
}
let
    demo = new Demo();
demo.action(demo.actionCallBack.bind(demo));
// Demo {name: "dqhan"}
// Demo {name: "dqhan"}

function Demo() {
    this.name = "dqhan";
};
Demo.prototype.action = function () {
    console.log(this);
    (function () {
        console.log(this);
    }).apply(this);
};
let
    demo = new Demo();
demo.action();
// Demo {name: "dqhan"}
// Demo {name: "dqhan"}

setTimeout中的延迟函数中this

let
    obj = {
        timerAction: function () {
            console.log(this);
        }
    };
function foo(method) {
    method();
};
obj.timerAction();
foo(obj.timerAction);
setTimeout(obj.timerAction, 0);
// {timerAction: ƒ}
// Window {postMessage: ƒ, blur: ƒ, focus: ƒ, close: ƒ, frames: Window, …}
// Window {postMessage: ƒ, blur: ƒ, focus: ƒ, close: ƒ, frames: Window, …}

之前看过一篇关于setTimeout使用时延迟函数自动挂载window上。今天总结了一下，发现这种方式个人觉得可以理解成，以函数当做参数进行传递this都是传递不过去的。如果简单的写一个函数，那么问题就更不存在了，匿名函数本身就是挂载window下，没有争议了。