this 总结

谁最终调用函数，this指向谁！！！

  ① this指向的，永远只可能是对象！
   ② this指向谁，永远不取决于this写在哪！而是取决于函数在哪调用。
   ③ this指向的对象，我们称之为函数的上下文context，也叫函数的调用者。

下面，请看具体情况。

　　① 通过函数名()直接调用：this指向window

function func(){
            console.log(this);
        }
        

        //① 通过函数名()直接调用：this指向window
        func(); // this--->window

② 通过对象.函数名()调用的：this指向这个对象

//② 通过对象.函数名()调用的：this指向这个对象
            // 狭义对象
            var obj = {
                name:"obj",
                func1 :func
            };
            obj.func1(); // this--->obj
            
            // 广义对象
            document.getElementById("div").onclick = function(){
                this.style.backgroundColor = "red";
            }; // this--->div

③ 函数作为数组的一个元素，通过数组下标调用的：this指向这个数组

function func(){
            console.log(this);
        }
        
//③ 函数作为数组的一个元素，通过数组下标调用的：this指向这个数组
        var arr = [func,1,2,3];
        arr[0]();  // this--->arr

④ 函数作为window内置函数的回调函数调用：this指向window（ setInterval setTimeout 等）

function func(){
            console.log(this);
        }
        

//④ 函数作为window内置函数的回调函数调用：this指向window
        setTimeout(func,1000);// this--->window
        //setInterval(func,1000);

⑤ 函数作为构造函数，用new关键字调用时：this指向新new出的对象

function func(){
            console.log(this);
        }

//⑤ 函数作为构造函数，用new关键字调用时：this指向新new出的对象
        var obj = new func(); //this--->new出的新obj

例题：

例1：

function f1(){
var user = '二狗子';
alert(this.user); //undefined
alert(this); //object window
}
f1(); //实际上就是 window.f1();

这里调用方法f1的是window对象，也就是说this指向window对象，所以会出现this.user 为undefined

例2：

var a = {
user: '二狗子',
f1: function () {
alert(this.user);
}
}
a.f1(); //二狗子

这里调用方法f1的是对象a，就是说this指向a对象，所以this.user为a对象里面的“二狗子”

接下来朝深处看看

例3：

var a = {
user: '二狗子',
f1: function () {
alert(this.user);
}
}
window.a.f1(); //二狗子
这段代码跟例2 比就是多了个window.  结果还是一样的，想说明什么问题呢，看下段代码

var a = {
user: '二狗子',
b: {
user: '大傻子',
f1: function () {
alert(this.user);
}
}
}
a.b.f1(); //大傻子

      看见没，结果变成“大傻子”了，对比两段代码再结合最上面说的this指向调用它的对象，

也就表名第一段代码是对象a调用的方法f1,第二段代码是对象b调用的，得出结论：在这种链式情况下，

this指向的是它上一级的对象。可能表达的不太准确，反正就是那个意思。

再把b对象里面的user注释掉看看

var a = {
user: '二狗子',
b: {
//user: '大傻子',
f1: function () {
alert(this.user);
}
}
}
a.b.f1(); //undefined

这里的this应该是指向b对象的，但是b里面没有user啊，肯定就是undefined，

通过this就把指代的对象给定死了，反正this就是指的b，我不管你里面有没有这个user，

没有就返回undefined，我可不会去拿a的user，

千万别与链式作用域搞混了，像下面这样

var user = '大傻子'; 
function f1(){
var user = '二狗子';
alert(user); //二狗子
}
f1();

function f2(){
alert(user); //大傻子
}
f2(); 

睁大眼看清楚了，这里没有this啊，所以执行f1的时候直接就是f1里面的user “二狗子”，执行f2的时候因为f2里面没有user,所以就朝外找，找到了外面的user "大傻子"

不能再多说了，待会该迷糊了。

再加个例子吧

例4：

function f1(){
this.user = "二狗子";
}
var a = new f1();
alert(a.user); //二狗子

其实就是new 关键字可以改变this的指向，通过new关键字，把一个对象实例给了a，同时this的指向也变成了a对象。