http://blog.csdn.net/lenel/archive/2007/10/10/1818018.aspx 比较好的试题
http://topic.csdn.net/u/20070103/12/e957caa0-6b08-4ca7-9206-bf2bbcc4ef58.html 关于某人的提问
http://www.cnblogs.com/thinhunan/archive/2006/04/01/DeveloperNotesForPrototype.html  prototype.js　1.4版开发者手册

A、 通过 直接引用和函数调用

function Child(name,age,sex)

{

this.name = name;

this.age = age;

  this.sex = sex;

  this.toString = function()

  {

window.alert(this.name+"/"+this.age+"/"+this.sex);

}

}

function Guy(name,age,sex)

{

this.Super = Child;

this.Super(name,age,sex);

}

var __child = new Guy("me","10","M");

 __child.toString();

解释：

继承的过程先是将Child的对象原型赋给 Guy 下的 Super 方法, 然后在执行完 Child 的构造函数后, Child的属性就被自动地加到了 Guy 的属性列表中.这主要是由于在 Guy 中通过 this 来调用的 Super(也就是 Child) 构造函数造成的, 通过此种方式调用 Child 构造函数时, JavaScript 解释器会把 Child 中的 this 与 Guy 中的 this 理解成位于同一个作用域下的 this 关键字, 所以就产生了继承的效果。当然我们也可以用InheritsForm，base等关键字来描述继承父类。

另外, 需要说明的是, 对于任何一个实例化的对象, 你任意地为它添加属性或方法, 如下所示:

  var newGuy = new Gue();
  newGuy.addprop = "added property to instance object";

很明显, 通过此种方式添加的属性和方法只对当前实例化对象有效, 不会影响所有的同类型对象实例. 无疑, 它是你创造的一个独一无二的对象实例.

B、 通过prototype 关键字

function Guy(name,age,sex)

{

  this.name = name;

  this.age = age;

  this.sex = sex;

}

Guy.prototype = new Child();

var guy = new Guy(“me”,”10”,”M”);

guy.toString();

如果我们要覆盖父类也就是Child的tostring()方法，可以这样定义:

Guy.prototype.toString = function()

{

  window.alert(“…….”);

}

这里说明下:

先定义一个类的prototype 为另外一个类，也就是定义该类为某个类的子类。

再通过Class.prototype.functionName = function(Args)来实现方法覆盖。

整个Guy的代码如下:
function Guy(name,age,sex)

{

  this.name = name;

  this.age = age;

  this.sex = sex;

}

Guy.prototype = new Child();

Guy.prototype.toString = function()

{

  window.alert(“…….”);

}

var guy = new Guy(“me”,”10”,”M”);

guy.toString();

C、 但是javascript 中好象不支持多深度的继承。也就是说无法实现AàBàC当中的A向上调用C的方法。

2、  关于prototype 的几点理解

A.         

var AjaxPro.IFrameXmlHttp.TestClass = new Function();

AjaxPro.IFrameXmlHttp.TestClass.prototype.abort = function()

{

window.alert("this is AjaxPro.IFrameXmlHttp ");

}

AjaxPro.IFrameXmlHttp.TestClass.prototype = {

stopMe: function(){

      window.alert("Oh,don't stop me");

  },

  reset: function(){

    window.alert(“Oh,is reseting now,please waite”);

}

 };

var Test = new AjaxPro.IFrameXmlHttp.TestClass();

Test.abort();

Test.stopMe();

在两者同时出现的时候，请将外部定义的prototype 函数放在内部定义的prototype = {}的后面，否则后者会覆盖前者。

B.        如果定义了B.prototype = new A() //new A; ，那么当调用B.prototype.function = function() 时，就可以覆盖A中的方法或是新定义属于B的方法。这个过程就象是如下:

prototype = new A() 语句时，就把A 给了B.prototype 属性了。再使用B.prototype.function  = function(){} 时，就类似的 A.function = function(){}，因为前面我们已经将B.prototype = new A()了。

C.        通过 this关键字定义的属性和方法是同对象本身处于同一个地址空间内的; 而通过 prototype 定义的属性和方法, 是通过所谓的 "原型链" 进行管理的, 其下的的属性和方法不位于同一个地址空间之间, 当其调用这种属性或方法时, 必须通过 "链表" 才能索引到其下的某个属性或方法. 也就说, 调用以原型方式定义的属性和方法会有一个类似于链表的 "回溯" 操作.

D.       构造过程中，原型对象是一次性生成的；新对象只持有这个原型实例的引用 (并用“写复制”的机制来存取其属性)，而并不再调用原型的构造器。

E.        最好的理解就是，prototype 表示 附加给我的东西，我便和你所有属性和方法的指针指向一致。在我申明和你相同的属性时，实际上是覆盖了你对应的属性。

例如:

Function A()

{

        This.name  = “is A”;

}

Function B()

{

        This.name = “is B”;

}

//A对象实例赋植给prototype，无形之中创建了个指针链。

B.prototype = new A();

//由于 _bb和new A()拥有同名name ，所以编译器会认为同一要素，因此就覆盖A中的name.

Var _bb = new B();

3、  Prototype.js 中对AddNameSpace 理解

最初代码如下：

if(!window.addNamespace) {

    window.addNamespace = function(ns) {

        var nsParts = ns.split(".");

        var root = window;

        for(var i=0; i<nsParts.length; i++) {

            if(typeof root[nsParts[i]] == "undefined")

                root[nsParts[i]] = {};

            root = root[nsParts[i]];

        }

    }

}

其中root[nsParts[i]] = {};

可以改为如下两种中的任何一种

A、   root[nsParts[i]] = new Object();

B、   root[nsParts[i]] = new Function();

由于Function 继承自Object，所以两个都可以。

// by 3zfp.zeng 2006.03.18

另外一种方法为:

if(!window.addNamespace) {

    window.addNamespace = function(ns) {

        var nsParts = ns.split(".");

        var root = "window";

        for(var i=0; i<nsParts.length; i++) {

            root = root+"."+nsParts[i];

            if( eval(" typeof "+ root+"=='undefined'") == true)

                eval(root+"= new Function()");

        }

    }

}

4、  prototype.js 中对Class 类的理解

源代码如下:

var Class = {

    create: function() {

        return function() {

            if(typeof this.initialize == "function")

                this.initialize.apply(this, arguments);

        }

    }

}

可以改为：

var Class = function() //function Class()

{

        this.create =  function() {

       return function()

{

           if(typeof this.initialize == "function")

              this.initialize.apply(this, arguments);

       }

    }

}

进一步的改为（在只是声明不带参数的函数/对象是使用）:

var Class = function()

{

        this.create =  function()

{

           return new Function();

        }

}

5、  apply 方法             通过该方法可以实现函数 重载 功能。

应用某一对象的一个方法，用另一个对象替换当前对象。

apply([thisObj[,argArray]])

参数

thisObj

可选项。将被用作当前对象的对象。

argArray

可选项。将被传递给该函数的参数数组。

说明

如果 argArray 不是一个有效的数组或者不是 arguments 对象，那么将导致一个 TypeError。

如果没有提供 argArray 和 thisObj 任何一个参数，那么 Global 对象将被用作 thisObj， 并且无法被传递任何参数。

    例子:

    Point2D.prototype.distance = function()  

{

       if (arguments[0] instanceof Point2D)

       {

           return this._point_distance.apply(this, arguments);

           含义为:

由_point_distance 函数替换distance函数，并将arguments

           等参数信息复制过去。

       }

       else if (arguments[0] instanceof Vector2D)

       {

           return this._vector_distance.apply(this, arguments);

       }

       else

       {

           throw new Error("Argument Error!");

        }

    }

6、  函数内部直接套function和通过this来指代funcion之间的区别

var Kinds = function()

{

  function DownA()            //内部私有函数，不能被外部调用。

  {

      alert("is me DownA");

  }

  function DownB()                //内部私有函数，不能被外部调用。

  {

      DownA();

  }

  this.DownC = function()     //该 this 指示 Kinds

  {

      this.DownCC = function()    //该 this 指示 Downc

      {

         new Kinds().DownD();

         DownB();

      }

      Alert(“is me DownC”);

  }

  this.DownD = function()     //该 this 指示 Kinds

  {

      alert("is me DownD");

  }

}

var t = new Kinds();

var d = new t.DownC();

d.DownCC();

PrintOuts:

is me DownC

is me DownD

is me DownA

DownB,DownA 等函数只能是通过内部调用来实现。这样就保证了其方法的内部private性。而通过使用 this.FunctionName = function() 来定义的则可以使用”.”隔号来实现。 其实这个和类 / 类型作用域 类似.

7、  prototype.js 中 extend 含义：让所有的对象都继承自object对象且复制给Object 并返回。

8、  AjaxPro 解析过程：

A、 定义可以被生成客户端对象的type,也就是将在客户端生成类似如下代码的代码段：

AjaxPro.Utility.RegisterTypeForAjax(typeof(Examples.Classes.Demo))；

该代码会在客户端生成如下js 块

<script type="text/javascript" src="/AJAXDemo/ajaxpro/AJAXDemo.Examples.Classes.Demo,AJAXDemo.ashx"></script>

B、 而我们恰巧在web.config 文件中定义了 对于ajaxpro/*.ashx 的请求都由AjaxPro.AjaxHandlerFactory, AjaxPro 来处理。这样的话 就可以对与.ashx文件可以response.write 出一段js 代码了。该代码如下:

addNamespace("AJAXDemo.Examples.Classes");

AJAXDemo.Examples.Classes.Demo_class = Class.create();

AJAXDemo.Examples.Classes.Demo_class.prototype = (

new AjaxPro.Request()).extend(

{

    GetMyClass: function(callback) {

        return this.invoke("GetMyClass", {}, callback);

    },

    GetMyInheritedClass: function(callback) {

        return this.invoke("GetMyInheritedClass", {}, callback);

    },

    PutMyClass: function(c, callback) {

        return this.invoke("PutMyClass", {"c":c}, callback);

    },

    GetPerson: function(callback) {

        return this.invoke("GetPerson", {}, callback);

    },

    initialize: function() {

        this.url = "/AJAXDemo/ajaxpro/AJAXDemo.Examples.Classes.Demo,AJAXDemo.ashx";

    }

}

)

AJAXDemo.Examples.Classes.Demo =

new AJAXDemo.Examples.Classes.Demo_class();

每当我们说到js的继承时，在您的脑袋的第一反应就是prototype原型机制来实现。但是您是否使用过其他的方法来实现继承呢，或者您是否了解其他实现方式及各种不同的继承实现机制的优缺点呢？

好了，下面我们就来看看几种比较常见的继承实现吧。

1、 prototype方式

 1var BaseClass =function()
 2
 3{
 4
 5    this.name = "3zfp";
 6
 7    this.age = 100;
 8
 9    this.ToString = function(){
10
11        return this.name+" " +this.age;
12
13    }
14
15}
16
17var Derived = function()
18
19{ 
20
21    this.address = "ShenZhen";
22
23}
24
25Derived.prototype = new BaseClass();
26
27var instance = new Derived();
28
29instance.ToString();
30

这种方式最为简单，只需要让一个类的prototype为被继承的一个实例就ok，然后直接使用BaseClass的方法。

       prototype属性是啥意思呢？prototype即为原型，每一个对象(由function 定义出来)都有一个默认的原型属性，该属性是个对象类型。并且该默认属性用来实现链的向上攀查。意思就是说，如果某个对象的属性不存在，那个将通过prototype属性对应的对象的来查找该对象的属性。如果prototype查找不到呢？ js会自动地找prototype的prototype属性对应的对象来查找，这样就通过prototype一直往上索引攀查，直到查找到了该属性或者prototype最后为空("undefined");

       例如：上例中的instance.ToString()方法。js会先在instance实例中查找是否有ToString()方法，因为没有，所以查找Derived.prototype属性，而prototype 为 NewClass的一个实例，该实例有ToString()方法，于是调用成功；同样给instance 的 name 属性赋值时也是查找prototype来实现的。

       注意，每一个对象得prototype都默认对应一个object对象，但是该对象不等于Object；如何验证呢？看如下代码：

1       var foo = function(){};
2
3       var result = (foo.prototype==Object);

这段代码的result 所得值为 false;

以下几个需要注意：

 1    typeof(Object.prototype) == "object";
 2
 3 
 4
 5       typeof(Object.prototype.prototype) == "undefined";
 6
 7 
 8
 9       var obj = new Object();
10
11       typeof(obj.prototype) == "undefined";
12
13       
14
15       var obj = {};
16
17       typeof(obj.prototype) == "undefined";
18
19 
20
21

2、apply方式

 1var BaseClass =function()
 2
 3{
 4
 5    this.name = "3zfp";
 6
 7    this.age = 100;
 8
 9    this.ToString = function(){
10
11        return this.name+" " +this.age;
12
13    }
14
15}
16
17var Derived = function()
18
19{ 
20
21       BaseClass.apply(this,new Array());
22
23    this.address = "ShenZhen";
24
25}
26
27var instance = new Derived();
28
29instance.ToString();
30
31 
32

在这种方式下，我们最需要理解的就是apply函数的作用。

该方法普遍的解释为用A方法去替换B方法。第一个参数为B方法的对象本身，第二个参数为一个数组，该数组内的值集合为需要传递给A方法对应的参数列表，如果参数为空，即没有参数传递，则通过 new Array() 来传递，null无效。

一般的方式为：

 第一：将BaseClass以apply传递的Array数组作为初始化参数进行实例化。

第二：将新生成的实例对象的所有属性（name，age，ToString方法）复制到 instance实例对象。这样就实现了继承。

 1var foo = function()
 2
 3{
 4
 5       this.fooA = function(){
 6
 7              this.fooB.apply(this,new Array("sorry"));
 8
 9       }
10
11       this.fooB =function(str)
12
13       {
14
15              alert(str);
16
17       }
18
19}
20
21new foo().fooA();
22

 3、call+prototype 方式

 1var BaseClass =function(name,age)
 2
 3{
 4
 5    this.name = name;
 6
 7    this.age = age;
 8
 9    this.ToString = function(){
10
11        return this.name+" " +this.age;
12
13    }
14
15}
16
17var Derived = function()
18
19{ 
20
21       BaseClass.call(this,"3zfp",100);
22
23    this.address = "ShenZhen";
24
25}
26
27Derived.prototype = new BaseClass();
28
29var instance = new Derived();
30
31instance.ToString();
32
33

       其实，call函数和apply方式有很类似的作用，都是用A方法去替换B方法，但是参数传递不一样，call方法的第一个参数为B方法的对象本身，和面的参数列不用Array对象包装，直接依次传递就可以。

      为什么作用类似，call方式的实现机制却要多一条 Derived.prototype = new BaseClass(); 语句呢？那是因为call方法只实现了方法的替换而没有作对象属性的复制操作。

call方法实际上是做了如下几个操作：

例：

 1var foo = function()
 2
 3{
 4
 5       this.fooA = function(){
 6
 7              this.fooB.call(this,"sorry");
 8
 9       }
10
11       this.fooB =function(str)
12
13       {
14
15              alert(str);
16
17       }
18
19}
20
21new foo().fooA();
22
23

则 this.fooB.call(this,"sorry")执行了如下几个操作：

1this.temp = this.fooB;
2
3this.temp("sorry");
4
5delete (this.temp);
6

其实，google Map API 的继承就是使用这种方式。大家可以下载的参考参考(maps.google.com)。

4、prototype.js中的实现方式

 1Object.extend = function(destination, source) {
 2
 3 for (property in source) {
 4
 5    destination[property] = source[property];
 6
 7 }
 8
 9       return destination;
10
11}
12
13var BaseClass =function(name,age){
14
15       this.name = name;
16
17       this.age = age;
18
19       this.ToString = function(){
20
21              return this.name+" " +this.age;
22
23       }
24
25}
26
27var Derived =function()
28
29{     
30
31       BaseClass.call(this,"foo",100);
32
33       this.address = "singapore";
34
35       this.ToString = function(){
36
37              var string = Derived.prototype.ToString.call(this);
38
39              return string +" "+ this.address;
40
41       }
42
43}
44
45Object.extend(Derived.prototype,new BaseClass());
46
47var instance = new Derived();
48
49document.write(instance.ToString());

该方式，实际上是显式的利用了apply的原理来实现继承。先 var temp = new BaseClass()，再将 temp 的属性遍历复制到Derived.prototype中。for (property in source) 表示遍历某个对象的所有属性。但是私有属性无法遍历。例:

 1var foo = function()
 2
 3{
 4
 5       var innerString = "";
 6
 7       this.name = "3zfp";
 8
 9       this.age = 100;
10
11       function innerToString()
12
13       {
14
15              return innerString;
16
17       }
18
19}
20
21var f =new foo();
22
23var eles = "";
24
25for (property in f)
26
27{
28
29       eles+=" "+property;
30
31}
32
33document.write(eles); 
34
35

输出为 "name age"而没有"innerString" 和 "innerToString()";具体原理，以后有机会可以解释（包括私有变量，私有函数，私有函数的变量可访问性等等）。上面总结了种种继承方式的实现。但是每种方法都有其优缺点。

第一种方式，如何实现如下需求，需要显示 "3zfp__100";

 1var BaseClass =function(name,age)
 2
 3{
 4
 5    this.name = name;
 6
 7    this.age = age;
 8
 9    this.ToString = function(){
10
11        return this.name+" " +this.age;
12
13    }
14
15}
16
17var Derived = function(name,age)
18
19{ 
20
21    this.address = "ShenZhen";
22
23}
24
25Derived.prototype = new BaseClass();
26
27var instance = new Derived("3zfp",100);
28
29document.write(instance.ToString());
30
31

我们通过运行可以发现，实际上输出的是 "undefined__undefined"。也就是说name和age没有被赋值。

oh,my god!天无绝人之路。第二和第三种方法可以实现，具体如下：

 1var BaseClass =function(name,age)
 2
 3{
 4
 5    this.name = name;
 6
 7    this.age = age;
 8
 9    this.ToString = function(){
10
11        return this.name+" " +this.age;
12
13    }
14
15}
16
17var Derived = function(name,age)
18
19{ 
20
21       BaseClass.apply(this,new Array(name,age));
22
23    this.address = "ShenZhen";
24
25}
26
27var instance = new Derived("3zfp",100);
28
29document.write(instance.ToString());
30
31______________________________________________
32
33---------------------------------------------------------------------
34
35var BaseClass =function(name,age)
36
37{
38
39    this.name = name;
40
41    this.age = age;
42
43    this.ToString = function(){
44
45        return this.name+" " +this.age;
46
47    }
48
49}
50
51var Derived = function(name,age)
52
53{ 
54
55       BaseClass.call(this,name,age);
56
57    this.address = "ShenZhen";
58
59}
60
61Derived.prototype = new BaseClass();
62
63var instance = new Derived("3zfp",100);
64
65 
66
67document.write(instance.ToString());
68
69 
70

       但是用apply方法也还是有缺点的，为什么？在js中，我们有个非常重要的运算符就是"instanceof"，该运算符用来比较某个对向是否为某种类型。对于继承，我们除了是属于 Derived类型，也应该是BaseClass类型，但是。apply方式返回值为false((instance instanceof BaseClass) == false).由于prototype.js使用了类似apply的方式，所以也会出现这个问题。

       啊，终极方法就是 call+prototype方式了，还是google牛X。您可以试一下是否正确((instance instanceof BaseClass) == true)。

 最后，就是多重继承了，由于js中prototype只能对应一个对象，因此无法实现真正意义上的多重继承。有一个js库模拟了多重继承，但是该库也额外重写了 instanceOf 方法，用 _instanceOf和_subclassOf 函数来模拟判断。该库的名字叫modello.js，感兴趣的可以搜索下载。

以上为本人的一些个人见解，希望对您有帮助。

 1function Student(name,age,from)
 2{
 3 this.name = name;
 4 this.age = age;
 5 this.from = from;
 6 this.ToString = function()
 7 {
 8  return "my information is name: "+this.name+",age : "+this.age+", from :" +this.from;
 9 }
10}

   Student类有三个变量，分别为name（名字）,age（年龄）,from（籍贯），这三个变量构成了描述一个对象的信息。当然，这里还有一个方法用来返回Student的信息。
   但是，我们是不是定义了一个变量，它就能一直存在着，并且还有可能在任何地方都能被访问和使用直到其被销毁？仔细想想，上面的需求是比较过分的，因为某些变量在某个功能实现后就不再利用了，但如果这个变量还存在的话，就占用了系统资源了，俗语曰：“站着茅坑不拉#$%”。
   于是我们对变量的及时和按需求地销毁有一个探讨的话题了。
   好，切入正题吧，就本人所接触过的来讲，js中支持如下几种类型的变量，分别为:局部变量、类变量、私有变量、实例变量、静态变量和全局变量。接下来我们就一一探讨研究下。

局部变量：

局部变量一般指在{}范围内有效变量，也就是语句块内有效的变量，如：

 1function foo(flag)
 2{
 3 var sum = 0;
 4 if(flag == true)
 5 {
 6  var index;
 7  for(index=0;index<10;index++)
 8  {
 9   sum +=index;
10  }
11 }
12 document.write("index is :"+index+"<br>");
13 return sum;
14}
15//document.write("sum is :" +sum+"<br>");
16document.write("result is :"+foo(true)+"<br>");

   该代码执行后输出的结果为：“index is :undefined” 和 “result is :0”，我们可以看到希望输出的index变量的值为undefined，也就是未定义。因此我们可以发现，index变量在if语句块结束后即被销毁了。那么“sum”变量呢？这个变量在foo()函数段执行完毕后被销毁了，如果您去掉我注释的那条语句，再执行，您将会发现系统将报错。值得注意的是，如果我把上面的foo()函数改成如下:

 1function foo(flag)
 2{
 3 var sum = 0;
 4 for(var index=0;index<10;index++)
 5 {
 6  sum +=index;
 7 }
 8 document.write("index is :"+index+"<br>");
 9 return sum;
10}

   您将可以看见可以输出index值("index is :10")，这个是js和其他语言的不同地方，因为index是在for循环的{}外面定义的，因此其作用范围在foo()函数使用完毕后才销毁。

  类变量：
   类变量，实际上就是类的一个属性或字段或一个方法，该变量在该类的一个实例对象被销毁后自动销毁，比如我们开始时举的Student类。这个我们不多讨论，大家可以自己试一下。

私有变量：
   私有变量，值得是某个类自己内部是用的一个属性，外部无法调用，其定义是用 var 来声明的。注意如果不用var 来声明，该变量将是全局变量（我们下面将会讨论），如：

 1function Student(name,age,from)
 2{
 3
 4 this.name = FormatIt(name);
 5 this.age = age;
 6 this.from = from;
 7 var origName = name;
 8 var FormatIt = function(name)
 9 {
10  return name.substr(0,5);
11 }
12 this.ToString = function()
13 {
14  return "my information is name: "+origName+",age : "+this.age+", from :" +this.from;
15 }
16}
17
18

   这里，我们分别定义了一个origName和FormatIt()两个私有变量（按面向对象的解释，应该用类的属性来称呼）。
   我们把这种情况下的方法也成为变量，因为该情况下的变量是个function类型的变量，而function也属于Object类的继承类。在这种情形下，如果我们定义了 var zfp = new Student("3zfp",100,"ShenZhen")。但无法通过zfp.origName和zfp.FormatIt()方式来访问这两个变量的。

注意以下几点：

1、私有变量是不能用this来指示的。
2、私有方法类型的变量的调用必须是在该方法声明后。如我们将Student类改造如下：

 1function Student(name,age,from)
 2{
 3 var origName = name;
 4 this.name = FormatName(name);
 5 this.age = age;
 6 this.from = from;
 7 var FormatName = function(name)
 8 {
 9  return name+".china";
10 }
11 this.ToString = function()
12 {
13  return "my information is name: "+origName+",age : "+this.age+", from :" +this.from;
14 }
15}
16var zfp = new Student("3zfp",100,"ShenZhen");

代码执行后，将会报"找不到对象"的错误.意思是FormatName()未定义。

3、私有方法无法访问this指示的变量（公开变量），如下：

 1
 2function Student(basicinfo)
 3{
 4 this.basicInfo = basicinfo;
 5
 6 var FormatInfo = function()
 7 {
 8  this.basicInfo.name = this.basicInfo.name+".china";
 9 }
10 FormatInfo();
11
12}
13function BasicInfo(name,age,from)
14{
15 this.name = name;
16 this.age = age;
17 this.from = from;
18}
19var zfp = new Student(new BasicInfo("3zfp",100,"ShenZhen"));
20
21

执行代码后，系统将会提示 “this.basicInfo为空或不是对象”的错误。
基本结论是，私有方法只能访问私有属性，私有属性在声明并赋值后可以在类的任何地方访问，

实例变量：
实例变量即某个实例对象所拥有的变量。如：

 1
 2function BasicInfo(name,age,from)
 3{
 4 this.name = name;
 5 this.age = age;
 6 this.from = from;
 7}
 8var basicA = new BasicInfo("3zfp",100,"ShenZhen");
 9basicA.generalInfo = "is 3zfp owned object";
10document.write("basicA's generalInfo is : "+ basicA.generalInfo+"<br>");
11var basicB = new BasicInfo("zfp",100,"ShenZhen");
12document.write("basicB's generalInfo is : "+ basicB.generalInfo+"<br>");
13执行该代码后，我们将可以看到如下结果：
14basicA's generalInfo is : is 3zfp owned object
15basicB's generalInfo is : undefined
16

静态变量：

静态变量即为某个类所拥有的属性，通过 类名+"."+静态变量名 的方式访问该属性。如下可以做清晰的解释：

 1function BasicInfo(name,age,from)
 2{
 3 this.name = name;
 4 this.age = age;
 5 this.from = from;
 6}
 7BasicInfo.generalInfo = "is 3zfp owned object";
 8var basic = new BasicInfo("zfp",100,"ShenZhen");
 9document.write(basic.generalInfo+"<br>");
10document.write(BasicInfo.generalInfo+"<br>")；
11BasicInfo.generalInfo = "info is changed";
12document.write(BasicInfo.generalInfo+"<br>")；

执行以上代码，将会得到如下结果：
undefined
is 3zfp owned object
info is changed

注意以下几点：
1、以 类名+"."+静态变量名 的方式来声明一个静态变量
2、静态变量并不属于类的某个实例对象所独有的属性,为对象的共享.
3、能以实例对象名+"."+静态变量名来访问。

全局变量：
全局变量即整个系统运行期间有效访问控制的变量，通常是在一个js代码开头定义，如：

1
2var copyright = "3zfp owned";
3var foo =function()
4{
5 window.alert(copyright);
6}

注意以下几点：

1、如果一个变量不用var 来声明，则其被视为全局变量。如：

1var copyright = "3zfp owned";
2var foo =function(fooInfo)
3{
4 _foo = fooInfo;
5 document.write(copyright+"<br>");
6}
7new foo("foo test");
8document.write(_foo+"<br>");

执行代码，将得到如下结果：
3zfp owned
foo test
但是，这个又有一个注意的地方，function是编译期对象，也就是说_foo这个全局变量要在foo对象被实例化后才能被初始化，也就是说如果将
new foo();
document.write(_foo+"<br>");
对调成
document.write(_foo+"<br>");
new foo();
系统将提示 "_foo 未定义"。
2、如果定义了一个和全局变量同名的局部变量属性，如下：

 1
 2
 3var copyright = "3zfp owned";
 4var foo =function(fooInfo)
 5{
 6 var copyright = fooInfo; //同名变量
 7 this.showInfo = function()
 8 {
 9  document.write(copyright+"<br>");
10 }
11}
12new foo("foo test").showInfo();
13document.write(copyright+"<br>");

执行代码，将得到如下结果：
foo test
3zfp owned
原因是由于function 是在编译期间完成变量的定义，也就是foo内部的copyright的定义是在编译期间完成的，其作用域只在foo对象内有效，而与外部定义的全局变量copyright无关。