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