this指向的问题（一）

1.默认绑定规则

this === window  //true指向同一个引用（对象）

2.函数的独立调用

函数中的this也是指向window
function test(){
    this === window  //true
}
window.test(); / test();

3.隐式绑定规则:谁调用就指向谁

每一个函数的【执行的时候】才都会有一个this指向，指向可能相同（地址可能相同），但是这是两个对象上的this

在创建上下文的时候，this指向的环境对象已经确定好了，有可能全局，有可能有对象，执行时会根据调用者来选择this的执行

var a = 0;
var obj = {
    a:2,
    foo:function(){
    1.只有当foo函数执行，这里才会有自身的this
        console.log(this)//obj调用 指向obj
   
   2.    
        function test(){
            console.log(this)
        }
        test();//当函数独立调用，默认就是window
   
   3.     
        函数立即执行，一定是window调用
        (function(){
            console.log(this)
        })();
        
    }
}
obj.foo();

4.闭包(是一个现象)

当函数执行的时候，导致函数被定义，并抛出；

var a = 0;
var obj = {
    a:2,
    foo:function(){
    闭包里的this都是window，独立调用都是window
        function test(){
            console.log(this);
        }
        独立调用
        return test
      //当函数执行的时候，导致函数被定义，并抛出；
      函数作为返回值返回的函数就是闭包
      函数里嵌套函数，并返回函数
    }
}
obj.foo();

var a = 0;
function foo(){
    console.log(this) //window
}

var obj = {
    a:2,
    foo:foo
}

obj.foo() //obj

var bar = obj.foo;  //这里没有执行函数，就没有this
bar(); //这里执行了 window 这个是独立调用

5.函数的参数赋值

var a = 0;
function foo(){
    console.log(this) //window
}

function bar(fn){
1.
    当我执行bar(obj.foo)，实际上在bar函数中创建了this
    //console.log(this)

2.    
    fn(); //foo作为参数开始执行，独立调用window
    
    非要让fn指向obj，使用call
    fn.call(obj);this指向强行指向obj

    父函数bar有能力决定 子函数 的this指向：call、apply、bind
}

var obj = {
    a:2,
    foo:foo
}
//预编译的过程中，实参被赋值为形参（浅拷贝）
bar(obj.foo) //window

提供的api的this指向

指向window

new 绑定

function Person(){
    var this = [];
    this.a = 1;
    return this;
}
实际上return this就是实例化后的对象
var person = new Person