js中的this指向问题（小计）

this的指向在函数定义的时候是确定不了的，只有函数执行的时候才能确定，this最终指向调用它的对象。

1.函数调用模式

当一个函数并非一个对象的属性时，那么它就是被当做函数来调用的。在此种模式下，this被绑定为全局对象，在浏览器环境下就是window对象；

function fn(){
                var a = "hello";
                console.log(this.a); //undefined
                console.log(this);    //window
                        
            }
            fn();

2.方法调用模式

当函数被保存为一个对象的属性时，它就可称为这个对象的方法。当一个方法被调用时，this被绑定到这个对象上。如果调用表达式包含一个提取属性的动作（. 或 []），那么它被称为方法调用

var obj = {
                name : "hello",
                sayName : function(){
                    console.log(this.name); //hello
                }                        
            }
            obj.sayName();

这里的this指向的对象是obj，因为调用这个sayName()函数是通过obj.sayName()执行的。

var obj = {
                name : "hello",
                obj2 : {
                    name : "world",
                    sayName : function(){
                        console.log(this.name); //world
                        console.log(this);  //obj2
                    }
                }
            }
            obj.obj2.sayName();

因为是obj.obj2调用的这个函数，所以指向obj2这个对象。

var obj = {
                name : "hello",
                obj2 : {
                    //name : "world",
                    sayName : function(){
                        console.log(this.name); //undefined
                        console.log(this);  //obj2
                    }
                }
            }
            obj.obj2.sayName();

同理，因为是obj.obj2调用的这个函数，所以指向obj2这个对象。

var name = "我是最外面的name";
            var obj = {
                name : "hello",
                obj2 : {
                    name : "world",
                    sayName : function(){
                        console.log(this.name); //"我是最外面的name"
                        console.log(this);  //window
                    }
                }
            }
            var q = obj.obj2.sayName;
            q();

q是全局变量，在全局环境下执行，this指向window;

 

3.构造函数调用模式

如果在一个函数前面加上new关键字来调用，那么就会创建一个连接到该函数的prototype成员的新对象，同时，this会被绑定到这个新对象上。这种情况下，这个函数就可以成为此对象的构造函数。

function fn(){
                console.log(this);//fn
            }
            var a = new fn();

在构造函数，new出一个对象时，this指向这个构造函数，new关键字会改变this的指向；

function fn(){
                this.name = "hello";
            }
            var a = new fn();
            console.log(a.name); //hello

当用new关键字，返回的是一个对象，this指向的就是那个返回的对象；

如果返回的不是对象，this还是指向函数的实例，虽然null属于对象，但是返回null依然指向函数实例；

function fn(){
                this.name = "hello";
                return {};
            }
            var a = new fn();
            console.log(a.name); //undefined

function fn(){
                this.name = "hello";
                return function(){
                    
                };
            }
            var a = new fn;
            console.log(a.name); //undefined

function fn(){
                this.name = "hello";
                return function(){
                    
                };
            }
            var a = new fn;
            console.log(a.name); //undefined

function fn(){
                this.name = "hello";
                return [];
            }
            var a = new fn;
            console.log(a.name); //undefined

function fn(){
                this.name = "hello";
                return 1;
            }
            var a = new fn;
            console.log(a.name); //hello

function fn(){
                this.name = "hello";
                return 1;
            }
            var a = new fn;
            console.log(a.name); //hello

function fn(){
                this.name = "hello";
                return null;
            }
            var a = new fn;
            console.log(a.name); //hello

function fn(){
                this.name = "hello";
                return undefined;
            }
            var a = new fn;
            console.log(a.name); //hello

4.apply和call调用模式

JS中，函数也是对象，所有函数对象都有两个方法：apply和call，这两个方法可以让我们构建一个参数数组传递给调用函数，也允许我们改变this的值

var name = "window";
            var obj = {
                name : 'obj'
            }
            function sayName(){
                console.log(this.name);
            }
            sayName();//window
            sayName.apply(obj);//obj
            sayName.call(obj);//obj
            sayName.apply();//window
            sayName.call();    //window

在全局范围内，this指向全局对象（浏览器下指window对象）

对象函数调用时，this指向当前对象

全局函数调用时，应该是指向调用全局函数的对象。

使用new关键字实例化对象时，this指向新创建的对象

当用apply和call上下文调用的时候指向传入的第一个参数；