• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

var ajax = new Ajax.PeriodicalUpdater(
    'divid ',//存放欲加载js的页面元素ID
    'test.js',//请求的URL
    {
        method: 'post ',//HTTP请求的方式为POST
        evalScripts:true,//是否执行请求页面中的脚本
        frequency:1,//更新的频率
        decay:2//衰减系数
      }
);

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

和开发过程相对应，测试主要按照时间顺序经历单元测试、集成测试、系统测试、验收测试四个阶段。

单元测试：

是针对软件设计的最小单位——程序模块进行正确性检验的测试工作，由开发人员进行，其目的在于发现每个程序模块内部可能存在的缺陷，实际程序员编码过程

中已经进行了。单元测试基本不需要编写测试用例，开发人员自己调试通过、符合设计要求就可以了。

集成测试：

集成测试是将模块按照设计要求组装起来进行测试，主要目标是发现与接口有关的问题，由于在产品提交到测试部门前，产品开发小组都要进行联合调试，所以大部分企业是由开发人员来完成集成测试的，但也可以到了测试部门后再次进行集成测试。主要测试模块之间数据传输是否正确、模块集成后的功能是否实现、模块接口功能与设计需求是否一致。集成测试紧接在单元测试之后，当单元测试通过后，便可开始配置集成测试环境。集成测试是最关键的一步，如果问题较多就把产品送到测试部，会造成反复测试，从而浪费人力、物力资源，延误了工期。

系统测试：

系统测试是在集成测试通过后进行，目的是充分运行系统，验证各子系统是否都能正常工作并完成设计的要求。主要由测试部门进行，是测试部门最大最重要的一个测试，对产品的质量有重大的影响。系统测试的主要内容有：功能测试、健壮性测试、性能－效率测试、安全性测试、压力测试、可靠性测试、安装/反安装测试等。这个测试需要编写大量的测试用例，投入大量的资源来完成。主要由黑盒测试工程师在整个系统集成完毕后进行测试。前期测试系统的功能是否满足要求，后期测试系统运行的性能是否满足要求，以及系统在不同的软硬件环境中的兼容性等。系统测试主要依据《系统需求规格说明书》文档。

功能测试

可细分为：逻辑功能测试、界面测试、易用性测试、安装测试、兼容性测试等。

性能测试

是软件按测试的高端领域，主要包括时间性能和空间性能两种。

时间性能：主要指软件的一个具体事物的响应时间。对于一个电子商务的网站来说，一个普遍接受的响应时间标准为2/5/10。

空间性能：主要指软件运行所消耗的系统资源。软件性能测试分为一般性能测试、稳定性能测试、负载测试和压力测试。

一般性能测试：

让被测系统在正常的软硬件环境下运行，不向其施加任何压力的性能测试。比如，测试163邮箱的登陆模块，只让一fe用户多次登陆，记录服务器端系统资源的消耗情况（CPU、内存），并记录单个用户的平均登陆时间。

稳定性测试：

连续运行被测系统，检查系统运行时的稳定程度。

负载测试：

让被测系统在其能忍受的压力测试的极限范围内连续运行，来测试系统的稳定性。负载测试需要给被测系统施加其刚好能承受的压力。用系统能承受的压力值进行多次重复登陆，直到系统出现故障为止。

压力测试：

持续不断地给被测系统增加压力，直到系统被压垮为止，用来测试系统所能承受的最大压力。假设一个人很轻松就能背1袋米，背两袋米很吃力，最多就能背3袋米，一般性测试——我就让他背1袋米；稳定性测试——我让他背1袋米，但让他去操场上跑圈，看多久累倒；负载测试——我让他背2袋米去操场上跑圈，看多久累倒；压力测试——我让他背2袋米、3袋米、4袋米……发现他最多背3袋米。

验收测试：

根据需求阶段的《需求规格说明书》为验收标准，测试时要求模拟实际运行环境。对于实际项目可以和客户共同进行，对于产品实际就是最后一次的系统测试。测试内容为对功能模块的全面测试, 尤其要进行文档测试。功能测试：功能测试主要针对产品需求说明书的测试，主要是验证功能是否符合需求，包括原定功能的检验、是否有冗余功能、功能。这类测试应由测试员做，这并不意味着程序员在发布前不必检查他们的代码能否工作(自然他能用于测试的各个阶段)。 健壮性测试（容错能力/恢复能力测试）：侧重于程序容错能力的测试。本测试在单元测试阶段和系统测试阶段都要进行。如数据边界测试、非法数据测试、异常中断测试等等，主要是验证程序对各种异常情况是否进行正确处理。为了执行方便，建议健壮性的大部分测试用例尽量编写在功能测试用例中。

接口测试：

程序员对各个模块进行系统联调的测试，包含程序内接口和程序外接口测试。这个测试，在单元测试阶段进行了一部分工作，而大部分都是在集成测试阶段完成的。由开发人员进行。

强度测试：

强度测试检查程序对异常情况的抵抗能力。强度测试总是迫使系统在异常的资源配置下运行。例如，①当中断的正常频率为每秒一至两个时，运行每秒产生十个中断的测试用例；②定量地增长数据输入率，检查输入子功能的反映能力；③运行需要最大存储空间（或其他资源）的测试用例；④运行可能导致虚存操作系统崩溃或磁盘数据剧烈抖动的测试用例，等等。

压力测试：

对系统不断施加压力的测试，是通过确定一个系统的瓶颈或者不能接收的性能点，来获得系统能提供的最大服务级别的测试。例如测试一个 Web 站点在大量的负荷下，何时系统的响应会退化或失败。

性能测试：

在交替进行负荷和强迫测试时常用的术语。性能测试关注的是系统的整体。它和通常所说的强度、压力/负载测试测试有密切关系。所以压力和强度测试应该于性能测试一同进行。举例说明：针对一个网站进行测试，模拟10到50个用户就是在进行常规性能测试，用户增加到1000乃至上万就变成了压力/负载测试。如果同时对系统进行大量的数据查询操作，就包含了强度测试。压力测试注重的是外界不断施压，强度测试注重的是极限或者异常情况下系统的测试。

用户界面测试：

对系统的界面进行测试，测试用户界面是否友好、是否方便易用、设计是否合理、位置是否正确等一系列界面问题

安全测试

主要是测试系统在没有授权的内部或者外部用户对系统进行攻击或者恶意破坏时如何进行处理，是否仍能保证数据的安全。测试人员可以学习一些黑客技术，来对系统进行攻击。

可靠性测试：

这里是比较狭义的可靠性测试，它主要是对系统能否稳定运行进行一个统计，在实际工作中如果没有条件可以不必特意去做。重点做好与之紧密相关的功能测试、健壮性测试就可以了。

安装/反安装测试：

安装测试主要检验软件是否可以正确安装，安装文件的各项设置是否有效，安装后能否影响原系统；反安装是逆过程，测试是否删除干净，是否给影响原系统等。

文档测试

主要测试开发过程中针对用户的文档，以需求、用户手册、安装手册等为主，检验文档是否和实际应用存在差别。文档测试不需要编写测试用例。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

JavaScript 是一种非常灵活的面向对象程序设计语言，它与传统的强类型的面向对象程序设计语言（如 C++，Java，C# 等）有很大不同，所以要实现如 C++、java、C# 当中的一些特性就需要换一种思考方式来解决。今天主要讨论如何在 JavaScript 脚本中实现数据的封装（encapsulation）。

数据封装说的简单点就是把不希望调用者看见的内容隐藏起来。它是面向对象程序设计的三要素之首，其它两个是继承和多态，关于它们的内容在后面再讨论。

关于数据封装的实现，在 C++、Java、C# 等语言中是通过 public、private、static 等关键字实现的。在 JavaScript 则采用了另外一种截然不同的形式。在讨论如何具体实现某种方式的数据封装前，我们先说几个简单的，大家所熟知却又容易忽略的 JavaScript 的概念。

1 几个基本概念

1.1 变量定义

在 JavaScript 语言中，是通过 var 关键字来定义变量的。

但是如果我们直接给一个没有使用 var 定义的变量赋值，那么这个变量就会成为全局变量。

一般情况下，我们应该避免使用没有用 var 定义的变量，主要原因是它会影响程序的执行效率，因为存取全局变量速度比局部变量要慢得多。

但是这种用法可以保证我们的变量一定是全局变量。

另外，为了保证速度，我们在使用全局变量时，可以通过 var 定义一个局部变量，然后将全局变量赋予之，由此可以得到一个全局变量的局部引用。

1.2 变量类型

没有定义的变量，类型为 undefined。

变量的值可以是函数。

函数在 JavaScript 中可以充当类的角色。

1.3 变量作用域

变量作用域是指变量生存周期的有效范围。

单纯用 { } 创建的块不能创建作用域。

with 将它包含的对象作用域添加到当前作用域链中，但 with 不创建新的作用域。with 块结束后，会将对象作用域从当前作用域链中删除。

try-catch 中，catch 的错误对象只在 catch 块中有效，但 catch 块中定义的变量属于当前作用域。

其它如 if、for、for-in、while、do-while、switch 等控制语句创建的块不能创建作用域。

用 function 创建的函数，会创建一个新的作用域添加到当前作用域中。

2 封装

下面我们就来讨论具体的封装。首先说一下大家最熟悉的几种封装：私有实例成员、公有实例成员和公有静态成员。最后会讨论一下大家所不熟悉的私有静态成员和静态类的封装办法。因为下面要讨论的是面向对象编程，所有当函数作为类来定义和使用时，我们暂且将其成为类。

2.1 私有实例成员

私有实例成员在 JavaScript 中实际上可以用函数内的局部变量来实现，它相当于类的私有实例成员。例如：

这里 m_first 和 m_second 是 class1 的两个私有实例字段，method1 和 method2 是两个私有实例方法。他们只能在该类的对象内部被使用，在对象外无法使用。

这里大家会发现创建私有方法有两种方式，一种是直接在类中定义方法，另一种是先定义一个局部变量（私有实例字段），然后定义一个匿名方法赋值给它。

直接在类中定义方法，则该方法的作用域就是这个类，因此这个方法在此类外不能够被访问，而它又可以存取类中所有的私有实例字段，这就保证了这是个私有实例方法。

第二种创建私有实例方法的方式跟第一种方式的效果是一样的，但是第二种方式更灵活一些。

你应该还会注意到，class1 中把构造器代码用 { } 括起来了，这样做虽然没有必要，但是代码看上去更加清晰。

关于这段构造器代码，还有两点需要说明的地方：

1、构造器代码必须放在整个类定义的最后，这样做是为了保证在它当中被调用的方法都已经被定义了。因为 JavaScript 是解释型语言，所以，它会按照从上到下的顺序执行，因此，如果构造器代码放在其它方法定义的前面，则执行到调用语句时找不到要调用的方法，就会出错。

2、我们已经知道 { } 创建的块不会改变作用域，因此如果在这样的构造器代码中创建局部变量，实际上是在整个类中创建私有实例成员，所以，如果需要用到局部变量，应当定义一个私有实例方法，例如可以命名为 constructor()，在 constructor() 这个私有实例方法中定义局部变量和原来 { } 构造器中要执行的代码，然后在类的最后直接调用它就可以了。所以更好的写法是这样的：

最后，你可能还会发现 class1 的定义我们没有用 var，这样做我们就可以保证它是个全局的类了。

2.2 公有实例成员

公有实例成员可以通过两种方式来创建，我们先来看下面这个例子：

我们发现这个例子是在 class1 的例子上做了一些补充。给它添加了公有实例字段和公有实例方法，我们把它们通称为公有实例成员。

我们应该已经发现，创建公有实例成员其实很简单，一种方式是通过在类中给 this.memberName 来赋值，如果值是函数之外的类型，那就是个公有实例字段，如果值是函数类型，那就是公有实例方法。另外一种方式则是通过给 className.prototype.memberName 赋值，可赋值的类型跟 this.memberName 是相同的。

到底是通过 this 方式定义好呢，还是通过 prototype 方式定义好呢？

其实它们各有各的用途，它们之间不是谁比谁更好的关系。在某些情况下，我们只能用其中特定的一种方式来定义公有实例成员，而不能够使用另一种方式。原因在于它们实际上是有区别的：

1、prototype 方式只应该在类外定义。this 方式只能在类中定义。

2、prototype 方式如果在类中定义时，则存取私有实例成员时，总是存取最后一个对象实例中的私有实例成员。

3、prototype 方式定义的公有实例成员是创建在类的原型之上的成员。this 方式定义的公有实例成员，是直接创建在类的实例对象上的成员。

基于前两点区别，我们可以得到这样的结论：如果要在公有实例方法中存取私有实例成员，那么必须用 this 方式定义。

关于第三点区别，我们后面在讨论继承时再对它进行更深入的剖析。这里只要知道有这个区别就可以了。

我们还会发现，公有实例成员和私有实例成员名字是可以相同的，这样不会有冲突吗？

当然不会。原因在于它们的存取方式不同，公有实例成员在类中存取时，必须要用 this. 前缀来引用。而私有实例成员在类中存取时，不使用也不能够使用 this. 前缀来存取。而在类外存取时，只有公有成员是可以通过类的实例对象存取的，私有成员无法存取。

2.3 公有静态成员

公有静态成员的定义很简单，例如：

这个例子的 class3 跟 class1 很像。不同的是 class3 的外面，我们又给 class3 定义了一个静态字段和静态方法。

定义的方式就是给 className.memberName 直接赋值。

这里定义的静态字段和静态方法都是可以被直接通过类名引用来存取的，而不需要创建对象。因此它们是公有静态成员。

不过有点要记住，一定不要将公有静态成员定义在它所在的类的内部，否则你会得到非你所期望的结果。我们可以看下面这个例子：

这个例子中，我们期望 s_second 能够扮演一个私有静态成员的角色，但是输出结果却不是我们所期望的。我们会发现 s_second 实际上是 class4 的一个私有实例成员，而不是私有静态成员。而 class4 的 method1 和 method2 所存取的私有成员总是类的最后一个实例对象中的这个私有实例成员。

问题出在哪儿呢？

问题出在每次通过 new class4() 创建一个对象实例时，class4 中的所有语句都会重新执行，因此，s_second 被重置，并成为新对象中的一个私有实例成员。而 class4.method1 和 class4.method2 也被重新定义了，而这个定义也将它们的变量作用域切换到了最后一个对象上来。这与把通过 prototype 方式创建的公有实例方法定义在类的内部而产生的错误是一样的。

所以，一定不要将公有静态成员定义在它所在的类的内部！也不要把通过 prototype 方式创建的公有实例方法定义在类的内部！

那如何定义一个私有静态成员呢？

2.4 私有静态成员

前面在基本概念里我们已经清楚了，只有用 function 创建函数，才能创建一个新的作用域，而要创建私有成员（不论是静态成员，还是实例成员），都需要通过创建新的作用域才能够起到数据隐藏的目的。下面所采用的方法就是基于这一点来实现的。

实现私有静态成员是通过创建一个匿名函数函数来创建一个新的作用域来实现的。

通常我们使用匿名函数时都是将它赋值给一个变量，然后通过这个变量引用该匿名函数。这种情况下，该匿名函数可以被反复调用或者作为类去创建对象。而这里，我们创建的匿名函数不赋值给任何变量，在它创建后立即执行，或者立即实例化为一个对象，并且该对象也不赋值给任何变量，这种情况下，该函数本身或者它实例化后的对象都不能够被再次存取，因此它唯一的作用就是创建了一个新的作用域，并隔离了它内部的所有局部变量和函数。因此，这些局部变量和函数就成了我们所需要的私有静态成员。而这个立即执行的匿名函数或者立即实例化的匿名函数我们称它为静态封装环境。

下面我们先来看通过直接调用匿名函数方式来创建带有私有静态成员的类的例子：

这个例子中，通过

来创建了一个静态封装环境，实际的类是在这个环境中定义的，并且在最后通过 return 语句将最后的类返回给我们的全局变量 class5，然后我们就可以通过 class5 来引用这个带有静态私有成员的类了。

为了区分私有静态成员和私有实例成员，我们在私有静态成员前面用了 s_ 前缀，在私有实例成员前面加了 m_ 前缀，这样避免了重名，因此在对象中总是可以存取私有静态成员的。

但是这种命名方式不是必须的，只是推荐的，私有静态成员可以跟私有实例成员同名，在重名的情况下，在类构造器和在类中定义的实例方法中存取的都是私有实例成员，在静态方法（不论是公有静态方法还是私有静态方法）中存取的都是私有静态成员。

在类外并且在静态封装环境中通过 prototype 方式定义的公有实例方法存取的是私有静态成员。

在静态封装环境外定义的公有静态方法和通过 prototype 方式定义的公有实例方法无法直接存取私有静态成员。

另外一种方式通过直接实例化匿名函数方式来创建带有私有静态成员的类的例子跟上面的例子很相似：

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

alert(a);
alert(b);
alert(c);
var a = "a";
function a() {}
function b() {}
var b = "b";
var c = "c";
var c = function() {}
alert(a);
alert(b);
alert(c);

var x = "I'm a global variable!";
function method() {
    alert(x);
    alert(this.x);
}
function class1() {
    // private field
    var x = "I'm a private variable!";
    // private method
    function method1() {
        alert(x);
        alert(this.x);
    }
    var method2 = method;
    // public field
    this.x = "I'm a object variable!";
    // public method
    this.method1 = function() {
        alert(x);
        alert(this.x);
    }
    this.method2 = method;
    // constructor
    {
        this.method1();     // I'm a private variable!
                            // I'm a object variable!
        this.method2();     // I'm a global variable!
                            // I'm a object variable!
        method1();          // I'm a private variable!
                            // I'm a global variable!
        method2();          // I'm a global variable!
                            // I'm a global variable!
        method1.call(this); // I'm a private variable!
                            // I'm a object variable!
        method2.call(this); // I'm a global variable!
                            // I'm a object variable!
    }
}
 
var o = new class1();
method();       // I'm a global variable!
                // I'm a global variable!
o.method1();    // I'm a private variable!
                // I'm a object variable!
o.method2();    // I'm a global variable!
                // I'm a object variable!

function parentClass() {
    // private field
    var x = "I'm a parentClass field!";
    // private method
    function method1() {
        alert(x);
        alert("I'm a parentClass method!");
    }
    // public field
    this.x = "I'm a parentClass object field!";
    // public method
    this.method1 = function() {
        alert(x);
        alert(this.x);
        method1();
    }
}
parentClass.prototype.method = function () {
    alert("I'm a parentClass prototype method!");
}
parentClass.staticMethod = function () {
    alert("I'm a parentClass static method!");
}
 
function subClass() {
    // private field
    var x = "I'm a subClass field!";
    // private method
    function method2() {
        alert(x);
        alert("I'm a subClass method!");
    }
    // public field
    this.x = "I'm a subClass object field!";
    // public method
    this.method2 = function() {
        alert(x);
        alert(this.x);
        method2();
    }
    this.method3 = function() {
        method1();
    }
}
 
// inherit
subClass.prototype = new parentClass();
subClass.prototype.constructor = subClass;
 
// test
var o = new subClass();
 
alert(o instanceof parentClass);    // true
alert(o instanceof subClass);       // true
 
alert(o.constructor);  // function subClass() {...}
 
o.method1();    // I'm a parentClass field!
                // I'm a subClass object field!
                // I'm a parentClass field!
                // I'm a parentClass method!
o.method2();    // I'm a subClass field!
                // I'm a subClass object field!
                // I'm a subClass field!
                // I'm a subClass method!
o.method();     // I'm a parentClass prototype method!
 
o.method3();               // Error!!!
subClass.staticMethod();   // Error!!!

function parentClass() {
    // private field
    var x = "I'm a parentClass field!";
    // private method
    function method1() {
        alert(x);
        alert("I'm a parentClass method!");
    }
    // public field
    this.x = "I'm a parentClass object field!";
    // public method
    this.method1 = function() {
        alert(x);
        alert(this.x);
        method1();
    }
}
parentClass.prototype.method = function () {
    alert("I'm a parentClass prototype method!");
}
 
parentClass.staticMethod = function () {
    alert("I'm a parentClass stati