<script type="text/javascript">
//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 o ={};
p.call(o);//相当于o.p(),调用函数看成是类的构造器执行了，那么此时o就是函数这类的实例化对象，就有了这个类的属性了，this就指向o,
console.log(o.name); // 111


  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(){//返回函数,可以不写形参，
          //o.name = arguments[0];
        //o.age = arguments[1];
          f.apply(o,arguments);//o调用f，类的构造器执行，那么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>