//this:this可以写在js全剧环境中（全局环境中this是window对象），this可以写在函数中，可以写在对象中，

function f(){

     this.name = "asdfas";

}

var o ={

    name :"cj",

     print:function(){

        console.log(this.name);

    }

};

o.print();//cj

var f = o.print();//java的内存分析模型来分析js内存模型。函数也有地址，f就指向print指向的函数对象，

f();//undefined,

/*this是运行时决定不是代码写的时候决定，this写在函数中，哪个对象调用函数， ，this就指向那个对象，  f() === window.f(),所以未定义。

*/

var ele = document.getElementById("id");

ele.addEventListener("click",function(){

    console.log(this);//this永远指向dom元素，就是引发事件的对象，

})

//call,apply都是函数对象有的，动态改变函数调用的对象

function log(a){

    console.log(this[a]);

}

log("name");  //this是window对象，global

log.call(o,"name");//cj，相当于o.log("name"),不让window调用log函数让o来调用log函数，call方法第一个参数是要调用这个函数的对象，第二个是参数。

function log(a,b){

     console.log(this[a]);//通过中括号访问函数对象的成员属性，

     console.log(this[b]);

}

log("name","");

log.apply(o,"name","age");

log.apply(o,["name","age"]); //apply接受参数是数组，call是一个一个传递

log.call(this,)  == this.log()

function p(){

    this.name = "111";//函数的this是调用这个函数的对象

}
var d = p();//单纯函数执行不会返回对象，除非函数里面返回了函数就是返回子类对象，
console.log(d.name);//name未定义

var o ={};

p.call(o);//相当于o.p(),  this就指向o,然后增加一个属性name

console.log(o.name); //

  function Person(name,age){

      this.name =  name;

      this.age = age;

  }

  var p1  = new Person   ("cj",22);//new出来的，当然p1就是这个函数类的实例化对象

  console.log(p1 instanceof Person); //true

  //自定义new

  function New(f){ //f 是个函数。f 构造器函数

      var o = {"__proto__":f.prototype}; //o.__proto__ 指向函数f的prototype

      return function(){//返回函数,可以不写形参，按照java父类子类思维，每次return的函数地址是不一样的，就像return多个子类对象，

          //o.name = arguments[0];

          //o.age = arguments[1];

          f.apply(o,arguments);//o调用f，f函数里面的this就是o了，o就有了f函数的成员属性和值

          return o;//函数执行时返回o对象

      }

  }

  var p2 = New(Person)("xx",33);//New(Person)返回函数，("xx",33)函数执行返回o

  console.log(p2.name);//xx

  console.log(p2 instanceof Person);//true

</script>

  // java的面向对象思维来分析js函数闭包而已，函数成员属性的作用范围也用java父子类思维来分析

  //函数的嵌套，产生的闭包的作用范围，类似于父类子类对象堆的作用域范围。return函数出去，每次return都是一个新的函数地址（产生新的闭包）

  function New(f){ //类1

      var o = {"__proto__":f.prototype};  //对象2，对象的组合

      return function(){ //类3

          f.apply(o,arguments);

        return o;//函数执行时返回o对象

      }

  }

  var temp = New(Person); //window.New(Person),函数1执行,return function()返回函数3地址就是对象3

  var p2 = temp("11",11);  //window.temp("11",11),函数3执行， ,返回对象2，

  var p3 = temp("22",22);// 函数3执行，返回对象2， p2,p3是同一个对象o

  console.log(p2.name);  //

  console.log(p3.name);  //

  function New(f){//对象1

      return function(){//对象3

          var o = {"__proto__":f.prototype};//对象2，对象的组合

          f.apply(o,arguments);

        return o;

      }

  }

  var temp = New(Person);//返回对象3

  var p2 = temp("11",11); //函数3执行，返回对象2，这个对象

  var p3 = temp("22",22);

  console.log(p2.name);  //

  console.log(p3.name);  //