javascript 中的对象函数闭包
Javascript对象的创建
1.
var a=new Object();
a.x=1;a.y=2;
2.
var b={x:1,b,2}
3.
function Point (x,y){this.x=x;this.y=y}
var point=new Point(1,2); javascript 中任何合法的函数都可以作为对象的构造函数。一旦函数作为构造函数执行，它内部的this属性将引用对象本身。
构造函数通常没有返回值，它们只是初始化this传进来的对象（例如一个函数作为构造函数后，它内部的this属性引用了那个对象，如果对象有x,y等属性就可以通过this.x this.y来初始化它）。
构造函数有返回值的情况：
function test(){
this.name='test';
return 1;
}
function test1(){
this.name='test1';
return new String("test1");
}
var a=new test();
alert(a.name);//test
alert(a);//object
var b=new test1();//
alert(b.name);//undefined
alert(b);//test1 如果一个函数的返回类型为引用类型（数组，对象或函数）的数据时当这个函数作为构造函数用new运算符执行构造时，构造函数体内的this值丢失，取而代之的是被返回的对象。
如果函数的返回值是一个值类型，那么这个函数作为构造函数用new运算执行构造时，它的返回值将被舍弃。new表达式的结果仍然为this所引用的对象。
new foo()的执行过程可以简单的理解为：
1. 创建一个新的对象实例，并继承foo.prototype
2. 将this绑定到这个新创建的对象上，new foo 跟new foo()是等价的在没有参数时
3. 这个构造函数返回的对象成了这个new表达式的结果。如果构造函数内没有返回对象，那么第一步中创建的对象将作为返回结果。more>>
对象的属性，方法：
对象的属性方法有四种类型
1. 私有类型 外界不可直接访问
2. 动态公有类型：外界可以访问，每个实例有一个副本，互相之间不影响。
3. 静态公有类型（原型类型）：所有实例共象的一个副本
4. 类属性：类型而非对象的属性，没有构造函数时也可以直接访问
如下“
function Test(){
var x=0;// 私有属性
this.y=1;// 动态公有类型
}
var a=new Test();
Test.z=3; // 类属性
Test.prototype.w=20; // 静态公有类型
alert(a.z);//undefined
alert(Test.z);
alert(a.w);//20
a.w=40;
alert(a.w);//40 动态公有属性代替了原型类型
delete(a.w);
alert(a.w);//20 prototype:
javascript中每个类型只有一个原型，默认情况下是一个Object对象，但每一个实例可有多个类型，如：
function A(){}
A.prototype=new Object()// 可省略
A.prototype.w=10;
function B(){}
B.prototype=new A();//new A() 的过程：生成对象，将 new Object(),w 这些属性赋给这个对象，
//B 的 prototype 指向的对象中有了 new Object 和 w 这些属性 ……
function C(){}
C.prototype=new B();
var c=new C();
alert(typeof(c));//object
alert(c instanceof B);//true
alert(c instanceof A)//true
alert(c.w); 将一个属性添加为prototype的属性后这个属性为该类型的所有的对象所共享，而且这种共享是只读的，任何一个实例中只能通过同名的属性来覆盖它，但不能改变它。一个对象在查找某个属性时，先查找自身域的属性表，如果有则返回，如果没有，查找其prototype域，如果还没有则递归的查找ptototype所指对象的prototype域。
根据new funciton的执行过程和prototype的用法可以方便的创建大量副本
var p1=new Point(1,2);
var points=[];
var pointPrototype=function(){}
pointPrototype.prototype=p1;
for(var i=0;i<1000;i++){
points[i]=new pointPrototype();
}
对象的继承：
模拟：
1. 构造继承
function BaseObject(name){
this.getName=function(){return name}
}
function ChildObject(name){
BaseObject.call(this,name);// 这里的 this 指的是 ChildObject 的对象（设为 o ），因此调用 call 后， //BaseObjict 原来构造函数中的 this 就成了 o ，然后 o 就有了 getName 属性。
// 所以这里相当有了 this.getName=function(){return name} 这行代码
}
var c=new ChildObject('chen');
alert(c.getName()); 但是这样不能继承父类型中的静态属性。
2. 原型继承法
function MyDate(){}
MyDate.prototype=new Date();
var date=new MyDate();这样并不能调用Date的toString方法。也就是说核心对象不能被继承。
由于类的原型(prototype)实际上是一个Object的实例，它不能再次被实例化(它的初始化在脚本装载时已经执行完毕)。这么意思呢？我们知道在新建对象实例时，我们使用语句 new MyDate()，这时我们可以看做JavaScript脚本引擎把prototype的一个浅拷贝作为this返回给类的实例(这里其实没有发生拷贝，只是利用浅拷贝这个概念来帮助理解)，如果类没有附加任何原型属性和原型方法，那么就等于返回了一个new Object()实例，如果prototype的原型属性类里有对象型的属性，那么就会造成共享对象实例的问题(类似于在传统OOP的类定义中使用了static修饰符来修饰了属性)如下面的实例。结果中array中的数组都打印的是1,2,3,4而count是不同的。这是因为数组是引用类型的而整数是值类型的。
<script>
function Collect(){
this.arr=[];
this.count=0;
}
function ArrayList(){
}
ArrayList.prototype=new Collect();
ArrayList.prototype.constructor=ArrayList;
// 为什么上面要把 ArrayList 赋值给新 prototype 的 constructor 呢？如果不做这个赋值， // 当我们从 ArrayList 的实例中， 通过 XXX.prototype.constructor 去取其构造函数，将会 // 获得 Collection 。这不是我们的本意，而且这是使用 instanceof 关键之比较对象实例和 // 对象也会出错。
var array=new ArrayList();
array.arr.push(1);
array.arr.push(2);
array.count=1;
var array2=new ArrayList();
array2.arr.push(3);
array2.arr.push(4);
array2.count=2
for(var i=0;i<array.arr.length;i++){
alert(array.arr[i]);
}
for(var i=0;i<array2.arr.length;i++){
alert(array2.arr[i]);
}
alert(array.count);
alert(array2.count);
</script> 3. 实例继承
functionMyDate(){ var instance =new Date(); instance.someFunction=..; return instance;}
用闭包保证this不被修改：
function MyClass(){
var $this=this;
var foo=function(){
return $this.foo.apply($this,arguments);
}
} 利用闭包构造私有域
var a=0;var b=1;
(function(){
showAB=function(){
alert(a+" "+b);
}
var a=1;
var b=2;
alert(a);alert(b);
showAB();
})()
a=2;
b=5;
showAB();// 输出仍为 1,2