JS对象

1、function是Function的实例，var fun = new Function("arg" , "alert('arg');"); Function的最后一个参数是方法体字符串，前几个参数是function的参数。一个function有三部分：函数体，成员，prototype
     function f(){
         var name;
         this.name;
     }
     f.name;
     f.prototype.name;
     f作为构造函数时，this.name会覆盖 f.prototype.name；其他情况下，以上四个name没有任何关系。
2、function作为普通函数，函数体里的this指向调用该函数的对象，直接调用时，this指向window对象（全局）

3、function作为构造函数，其中的this是指向将new出来的对象
      new出来的对象，是在prototype的基础上调用function而来。其中prototype.constructor === function本身，因而new出来的对象的constructor也是这个function。prototype.constructor可以被改变，因此new 出来的对象的constructor不一定是这个function。
      var f = function(){
          this.name = function(){};
      }
      var a = new f();
      var b = new f();
      console.log(a.name === b.name);//此为false
     用this定义的函数成员，跟this定义的普通成员一样也是一个对象一份
4、对原型链的理解：对象添加、修改和删除成员(可发生在构造时和生成后)，只在本对象进行，不影响原型。查询成员时，顺着原型链往上查找。
添加成员：本对象和原型都没有该成员。
修改成员：本对象和原型至少一个有该成员。
删除成员：本对象有，原型有，值变成原型里的值；本对象没有，原型有，删除不成功。
var f = function(){this.name = "aa";}
f.prototype.name = "dd";
var a = new f();
delete a.name;
console.log(a.name);//打印出 “dd”

5、[ ]的constructor是Array, function的constructor是Function,{ }的constructor是Object

6、constructor不是一个对象的独立属性，对象的类型发生变化时，它也跟着变化。也可以单独改变对象的constructor。
7、闭包：在一个函数中定义另一个函数，内部函数使用了外部函数定义的变量。当外部函数被调用并返回，但仍有对内部函数的引用未被销毁（比如将内部函数返回出去并被赋值给了全局变量，或者在执行外部函数时，就把内部函数赋值给了全局变量），此时可能被内部函数使用的外部函数中定义的变量不会被释放，未被释放的外部函数变量和这个内部函数，就构成了一个闭包。
function f(param){
   return {
       fn1:function(){
           param++;
           console.log(param);
        },
       fn2:function(){
           console.log(param);
       }
   }
   
}
var a = f(1);
var b = f(3);
console.log(a.fn1 === b.fn1);//false，每次执行定义函数语句都产生新的函数实例
a.fn1();//2
a.fn2();//2，函数fn1、fn2和变量param组成一个闭包
b.fn1();//4，每次调用f，都产生新的闭包
b.fn2();//4
8、遍历成员：if('bar' in foo) 和 for(i in foo)会查找原型链
foo.hasOwnProperty('bar'); 判断本对象有没有该成员

9、原型与构造器

  function f1(){}
   function f2(){}
   f2.prototype = new f1();
   var a = new f2();
   console.log(a.constructor); //f1
   console.log(a instanceof f2); //true ,instanceof 并非判断a.constructor
   //a.__proto__ 是a的构造器的prototype，a.constructor === a.__proto__.constructor
   //f2 有一个 默认的 prototype，f2.prototype.constructor 默认为 f2
   //当f2.prototype被覆盖时，其constructor也被覆盖,因此a.constructor 不是 a的构造函数f2
   //为了避免对象的constructor不是其构造函数，可以加上 f2.prototype.constructor = f2

10、call 和 apply 的典型用法：让类数组对象使用数组的方法
Array.prototype.pop.call({0: 0,1: 1,length: 3});

11、function f(){
window.a = [];
window.b = [];
window.c = [];
for(var i=0;i<10;i++)
{
//a的元素在同一个闭包
window.a[i] = function(){
console.log(i);
}
//b的元素在不同的闭包
window.b[i] = h(i);
//匿名函数执行一次就产生新的闭包
(function(){
var temp = i;
//c的元素在不同的闭包
window.c[i] = function(){alert(temp);}
})()
}
}
//每调用一次h()产生一个新的闭包
function h(i){
return function(){
console.log(i);
}
}
f();
a[0]();
a[9]();
b[0]();
b[9]();
c[0]();
c[9]();