最后更新：1997年12月18日
翻译日期：2008年11月11日
文章翻译：chenzhe
翻译注解：object hierarchy[b]译为[b]对象层次;constructor译为构造器;constructor function和constructor method译为构造函数;此外，本文中所有涉及__proto__属性的代码适用于FireFox和Chrome，不适用于IE，其它浏览器未测试。
以类为基础的面向对象语言，比如Java和C++，都是建立在两种不同的实体之上：类与实例。一个类定义了某个物体集合的所有属性，而这些属性能够描述这个物体集合的特性（可以想想Java里的方法和域，或者是C++中的成员，把它们当作属性）。类是抽象的事物，而不是它所描述的物体集合中的某一特定的成员。举个例子，Employee（雇员）类可以代表所有的雇员。然而一个实例（instance）则是一个类的实例化（instantiation）；也就是说，类的一个成员。还是举例来说明，Victoria就可以是Employee类的的一个实例，代表雇员中的一个特定个体。一个实例和它的父类有完全相同的属性（不多，也不少）。
以原型为基础的语言，比如说JavaSctipt，并没有这个区别（类和实例的区别）。它只有对象。以原型为基础的语言中有原型对象（prototypical object）这样一个概念，它被当作模板来使用，一个新对象将会从这个模板中获得初始的属性。任何物体都可以随时给自己设置特性，可能是当您创建它的时候，甚至也可以是在运行时。此外，任何对象都可以被关联为另一个对象的原型，以允许第二个对象分享的第一个对象的属性。
在以类为基础的语言中，你需要在一个单独的类定义（class definition）中定义类。在这一定义中，您可以指定特殊的方法，即所谓的构造器（constructors），构造器用来创建该类的实例。构造器可以给实例的属性设置初始值，并在合适的时候执行其他的流程。你可以使用new操作符来配合构造器创建类的实例。
JavaScript也遵从相似的模式，但是并没有将构造器区别出来的类定义。相反，你要定义一个构造器函数（constructor function）来创建有若干初始属性和属性值的对象。任何JavaScript函数都可以被用来当作构造器。你可以使用new操作符和构造函数来创建一个新对象。
在以类为基础的语言中，你通过类的定义来实现类的层次。在类定义中，你可以指定新的类是某个已存在类的子类（subclass）。子类继承超类（superclass）的所有属性，而且还可以额外添加新的属性，或是修改继承的属性。比如说，我们假设Employee类只包含 nameanddept属性（姓名和部门），Manager（经理）是Employee类的子类，它添加了reports（报告）属性。在这种情况下，一个Manager类的实例会有所有的三个属性：name,dept, 和reports。
JavaScript允许你将原型对象与任何构造器函数相关联，以此实现继承机制。所以，你完全可以创建和上面一模一样的Employee- Manager实例，但是要使用稍有不同的词汇。首先你要定义Employee构造函数，指定name和dept属性。然后，你定义Manager构造函数，设置reports属性。最后，你把Employee对象设置为Manager构造函数的prototype。之后，当你创建一个新的Manager 的时候，它会从Employee对象继承name和dept属性。
在以类为基础的语言中，在典型情况下，你在编译时创建class，之后你就可以在运行时或者是编译时将class实例化。你不能在定义class之后改变对象属性的个数或者是种类。然而，在JavaScript中，你可以在运行时向任何对象添加或者删除属性。如果你给一个对象添加属性，而这个对象又是某些对象的prototype，那些以它为prototype的对象也将获得新的属性。
表1是对这些区别的摘要。这篇文章的剩下的部分会描述使用JavaScript构造器和prototype来创建对象层次的细节，并且对比在Java中完成相同工作的方法。
表 1基于类（Java）与基于原型（JavaScript）的对象系统的对比
==================================================================================================
基于类（Java） 基于原型（JavaScript）
==================================================================================================
类和实例是不同的实体。 所有的对象都是实例。
使用类定义来定义类；使用构造函数来将类实例化。 使用构造函数定义，并且创建一些列对象。
使用new操作符来创建一个新的对象。 一样。
使用类定义来定义已存在类的子类，以此来创建对象层次。 通过将一个对象设置为关联到某个构造函数的原型，从而创建对象层次。
通过类链（class chain）继承属性。 通过原型链继承属性。
类定义设置类的所有实例的所有属性。 构造函数或者是原型指定了一系列原始（initial）属性。
不能再运行时动态添加新的属性。 可以动态地向个别对象或者一个对象集合添加或删除属性。
Employee雇员实例
本文剩下部分的工作就是实现图1中简单的employee雇员层次。
一个简单的对象层次
图 1
* Employee有name属性（默认值为空字符串）和dept属性（默认值"general"）。
* Manager以Employee为基础。它添加了一个reports属性（默认值是空的数组，我们意在让其成为一个值为Employee对象的数组）。
* WorkerBee同样以Employee为基础。它添加了projects属性（默认值是空的数组，我们意在让其成为一个值为字符串的数组）
* SalesPerson以WorkerBee为基础。它添加了quota（配额）属性（默认值100）。它还将dept属性的值覆盖为"sales"，表明所有的销售人员都在同一个部门。
* Engineer以WorkerBee为基础。它添加了machine（机器）属性（默认值为空字符串）。它同样将dept属性的值覆盖为" engineering "。
创建层次
要定义合适的构造函数以实现Employee层次，你有多种方式可以使用。如何选择在很大程度上取决于你想要在你的应用（application）中能够做些什么事情。我们稍后再来讨论这个问题。
就现在而言，我们使用非常简单的（相对来讲也是灵活的）定义，这仅仅是为了看看继承是如何工作的。在这些定义中，你不能在新创建一个对象的时候设置任何属性值。新创建的对象仅仅是取得默认值，你可以稍后再修改这些属性。图2展示了这种简单定义的层次。
在实际的应用中，你可能定义允许你在创建对象的同时指定属性值的构造函数。我们会在后面的"更加灵活的构造函数"部分介绍实现方法。现在，这些简单的定义可以让我们观察到继承是如何发生的。
以上定义看起来的样子What the definitions look like
图 2
如下，Java和JavaScript简单的Employee定义非常相似。唯一的不同就是在Java中，你需要指定属性的类型，而在JavaScript中不需要，而且你需要给Java类定义一个明确的（explicit，显式）的构造函数。
程序代码javascript的方法
function Employee () {
this.name = "";
this.dept = "general";
}
程序代码java的方法
public class Employee {
public String name;
public String dept;
public Employee () {
this.name = "";
this.dept = "general";
}
}
Manager 与 WorkerBee 的定义显示了，在构建继承链条中更高层对象的方式中的不同。在JavaScript中，你将一个原型实例设置为构造函数的prototype属性。你可以在定义了构造器之后的任何时间来完成这项工作。在Java中，你在类定义中指定超类（superclass）。你不能在类定义之外改变超类。
程序代码javascript的方法
function Manager () {
this.reports = [];
}
Manager.prototype = new Employee;function WorkerBee () {
this.projects = [];
}
WorkerBee.prototype = new Employee;
程序代码java的方法
public class Manager extends Employee {
public Employee[] reports;
public Manager () {
this.reports = new Employee[0];
}
}
public class WorkerBee extends Employee {
public String[] projects;
public WorkerBee () {
this.projects = new String[0];
}
}
Engineer和SalesPerson的定义从WorkerBee继承下来的对象，自然也是从Employee继承而来。这些类型的对象拥有所有在链条上游对象（objects above it in the chain）的属性
程序代码javascript的方法
function SalesPerson () {
this.dept = "sales";
this.quota = 100;
}
SalesPerson.prototype = new WorkerBee;
function Engineer () {
this.dept = "engineering";
this.machine = "";
}
Engineer.prototype = new WorkerBee;
程序代码java的方法
public class SalesPerson extends WorkerBee {
public double quota;
public SalesPerson () {
this.dept = "sales";
this.quota = 100.0;
}
}
public class Engineer extends WorkerBee {
public String machine;
public Engineer () {
this.dept = "engineering";
this.machine = "";
}
}
使用这些定义，你可以创建这些对象的实例，而这些实例会获得属性的默认值。图3展示了使用以上JavaScript定义新对象和这些新对象的属性值。
注意：正如之前描述的，实例（instance）这个词汇在基于类的语言中有特殊的技术含义。在这些语言中，一个实例是一个类的个体成员，是从根本上不同于类的。在JavaScript中，“实例”并没有这个技术含义，因为JavaScript没有类和实例的区别。以后再谈论JavaScript的时候，“实例”可以被用来非正式地指代用某个特定构造函数创建的一个对象。所以，在这个例子中，你可以非正式地说jane是Engineer类的一个实例。相似的，尽管父亲（parent）、儿子（child）、祖先（ancestor）、后代（descendant）这些词汇在JavaScript中同样没有正式的意义，我们仍然可以非正式地使用他们来指代原型链中位置或高或低的对象。
使用简单的定义创建对象
图3
对象的属性
本部分讨论在原型链中，对象是如何从其他对象中继承属性，以及当你在运行时添加一个属性的时候会发生什么事情。
继承属性
假设你像图3中一样定义了一个WorkerBee的mark 对象，语句如下：
程序代码mark = new WorkerBee;
当JavaScript看到new操作符，它就创建一个新的通用对象，并且将这个新对象作为this的this关键字的值传递给WorkerBee构造函数。构造函数显式地设置projects属性的值。并且它会将WorkerBee.prototype的值设置为内部的 __proto__属性的值。（那个属性在两侧分别由两个下划线。）当这些属性被设置完之后，JavaScript将新对象返回，而赋值语句就会将 mark变量设置为那个对象。
这个过程并没有显式地给mark对象从原型链中继承的属性赋值（局部变量）。当你请求一个属性值的时候，JavaScript首先检查这个值在对象中是否存在。如果存在，就返回那个值。如果值在本地不存在， JavaScript会检查原型链（使用 __proto__）。如果在原型链里的某个对象有该属性的值，就返回那个值。如果没有找到这个属性，JavaScript会说对象没有这个属性。由此来说，mark对象有如下几个属性和值：
程序代码mark.name = "";
mark.dept = "general";
mark.projects = [];
mark对象从mark.__proto__中的原型对象中继承了name和dept属性的值。它的projects属性被 WorkerBee构造器赋予了本地的值。简单地说，这给了你在JavaScript中对属性和属性值的继承。这个过程的一些细节将会在"又见属性继承" 部分讨论。
因为这些构造器不让你给特定的实例指定值，这些信息都是通用的。属性值都是默认值，由所有的WorkerBee新建对象所分享。你当然可以改变任何属性的值。所以，你可以像下面这样给mark一些指定的信息：
程序代码mark.name = "Doe, Mark";
mark.dept = "admin";
mark.projects = ["navigator"];
添加属性
在JavaScript中，你可以在运行时给任何对象添加属性。并不限于使用构造器提供的属性。要给单独的对象添加特定的属性，你只需要简单地给对象赋值就可以了，像这样：
程序代码mark.bonus = 3000;
现在，mark对象就有一个额外的属性了，任何其他的WorkerBee都没有这个属性。
如果你给一个对象添加了新的属性，而它又被一个构造器作为原型，你就为所有从该原型继承属性的对象添加了那个属性。举例来说，你可以给所有的雇员（employees）添加一个specialty属性，就使用下面的语句：
程序代码Employee.prototype.specialty = "none";
一旦JavaScript执行到这条语句，mark对象也会拥有这个specialty属性，且属性值为“none”。图4展示了向 Employee的原型添加这个属性，并且在Engineer原型中覆盖它。
添加属性
图 4
更灵活的构造器
至今为止，我们使用的构造函数都不允许你在创建实例的时候指定属性值。就像在Java中一样，你可以给构造器提供参数来初始化实例的属性值。图5展示了实现的方法。
在构造器内设置属性，take 1
图 5
下面是Java和JavaScript 对这些对象的定义。
程序代码JavaScript 的方法
function Employee (name, dept) {
this.name = name || "";
this.dept = dept || "general";
}
function WorkerBee (projs) {
this.projects = projs || [];
}
WorkerBee.prototype = new Employee;
function WorkerBee (projs) {
this.projects = projs || [];
}
WorkerBee.prototype = new Employee;
function Engineer (mach) {
this.dept = "engineering";
this.machine = mach || "";
}
Engineer.prototype = new WorkerBee;
程序代码Java 的方法
public class Employee {
public String name;
public String dept;
public Employee () {
this("", "general");
}
public Employee (name) {
this(name, "general");
}
public Employee (name, dept) {
this.name = name;
this.dept = dept;
}
}
public class WorkerBee extends Employee {
public String[] projects;
public WorkerBee () {
this(new String[0]);
}
public WorkerBee (String[] projs) {
this.projects = projs;
}
}
public class Engineer extends WorkerBee {
public String machine;
public WorkerBee () {
this.dept = "engineering";
this.machine = "";
}
public WorkerBee (mach) {
this.dept = "engineering";
this.machine = mach;
}
}
这些JavaScript定义使用一种特殊的风格(idiom)来设置默认值。
程序代码this.name = name || "";
JavaScript的逻辑或操作符(||)先计算第一个参数的值。如果该参数转换为true，操作符就将它返回。否则，或操作符返回第二个参数。因此，这行代码尝试着看看name是否有满意的值。如果有，将this.name的值设置为这个值。否则，它将this.name的值设置为空字符换。本篇文章都会使用这种简洁的风格；然而，第一次看到可能会有一些令人迷惑。
有了这些定义，当你创建任何对象的实例时，你都可以给本地定义的属性设定值了。就像在图5中展示的，你可以使用这个语句来创建一个新的Engineer：
程序代码jane = new Engineer("belau");
现在Jane的属性如下:
程序代码jane.name == "";
jane.dept == "general";
jane.projects == [];
jane.machine == "belau"
需要注意的是，使用这个定义，你不能给name等继承的属性指定初始值。如果你想要在JavaScript中给继承的属性设定初始值，你需要再给构造函数多添加一些代码。
到目前为止，构造函数已经创建了一个通用的对象，然后再给新对象指定本地的属性和值。你可以给构造器添加更多的属性，只要调用原型链中更高位置上的构造函数就可以做到这点。图 6展示了这些新的定义。
在构造器内指定属性，take 2
[align=center]图 6[/b]
让我们详细地看看这些定义。下面就是Engineer类的构造器的新定义。
程序代码function Engineer (name, projs, mach) {
this.base = WorkerBee;
this.base(name, "engineering", projs);
this.projects = mach || "";
}
假设我们像下面这样创建Engineer对象：
程序代码jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
JavaScript会执行如下步骤：
1.首先，new操作符创建一个通用的的对象，然后设置它的__proto__属性为Engineer.prototype。
2.new操作符将新的对象传递给Engineer构造器，作为this关键字的值。
3.然后，构造器为对象创建一个叫做base的新属性，并且将base属性的值设置为WorkerBee的构造器。这使得WorkerBee构造器成为了Engineer对象的一个方法。
注意：base属性的名字并没有什么特别的。你可以使用任何的合法属性名；起名为base仅仅是为了直观一些。
4.下一步，构造器调用base方法，并将传递给构造器的参数中的两个("Doe, Jane"和["navigator", "javascript"])以及字符串“engineering”再传递给base。在构造器内显式地使用“engineering”表明所有的 Engineer对象对于继承的dept属性都拥有相同的值，而且这个值会覆盖从Employee继承的值。
5.因为base是Engineer的方法，在对base的调用中，JavaScript将this关键字绑定到第一步创建的对象上。这样， WorkerBee函数依次将"Doe, Jane"and["navigator", "javascript"]参数传递给Employee构造函数。当Employee构造函数返回的时候，WorkerBee函数使用剩余的参数来设置 projects属性。
6.当从base方法返回的时候，Engineer构造器初始化对象的machine属性为“belau”。
7.当从构造器返回的时候，JavaScript将新对象赋值给jane变量。
你可能认为，已将在Engineer构造器的内部调用WorkerBee的构造器了，你就完成了对Engineer对象继承关系的设置。但是事实却不是这样。调用WorkerBee的构造器确保了Engineer对象开始的时候就具有了所有构造函数中指定的属性。然而，如果你之后又向Employee或者 WorkerBee的原型添加属性，那些属性将不会被Engineer对象所继承。举例来说，假设你写了如下的语句：
程序代码function Engineer (name, projs, mach) {
this.base = WorkerBee;
this.base(name, "engineering", projs);
this.projects = mach || "";
}
jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
Employee.prototype.specialty = "none";
jane对象并不会继承specialty属性。你仍然需要显示地设置原型来确保动态的继承。假设你写了如下语句：
程序代码function Engineer (name, projs, mach) {
this.base = WorkerBee;
this.base(name, "engineering", projs);
this.projects = mach || "";
}
Engineer.prototype = new WorkerBee;
jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
Employee.prototype.specialty = "none";
现在jane对象的specialty属性是"none"。
又见属性继承
上一部分描述了在JavaScript中，构造器和原型是如何提供层次和继承的。就像在所有的语言中一样，在之前的讨论中有一些细微之处还没有能够充分地暴露（not necessarily apparent）。而这一部分就来讨论这些细微之处中的几个。
本地值和继承的值
我们再来概括地看看属性的继承。正如在之前讨论的，当你访问一个对象的属性，JavaScript进行如下几步：
* 查看是否存在本地值。如果存在，返回那个值。
* 如果不存在本地值，检查原型链（使用__proto__属性）。
* 如果在原型链中的某一个对象有该属性值，则返回那个值。
* 如果没有找到这个属性，说明这个对象没有这个属性值。
这一些列简单步骤的结果取决与你是如何在原型链上（along the way）定义对象的。在我们原来的例子中，我们有如下定义：
程序代码function Employee () {
this.name = "";
this.dept = "general";
}
function WorkerBee () {
this.projects = [];
}
WorkerBee.prototype = new Employee;
根据如上定义，假设你创建一个WorkerBee的实例amy，语句如下：
程序代码amy = new WorkerBee;
amy对象有一个本地的属性，projects。name和dept属性的值并不是amy本地的，是从amy对象的__proto__属性取得的。所以，amy拥有如下属性：
程序代码amy.name == "";
amy.dept = "general";
amy.projects == [];
现在假设你改变了关联到Employee的原型的name属性的值：
程序代码Employee.prototype.name = "Unknown"
第一眼看来，你可能认为新的属性值会传递（propagate）到所有Employee的实例。然而，它却没有。
当你创建任何的Employee 对象的时候，那个实例就会为name属性取得一个本地的值（空字符串）。这意味着当你设置WorkerBee的原型为一个新建的Employee对象的时候，WorkerBee.prototype的name属性有一个本地的值。所以，当JavaScript查找amy对象（WorkerBee的一个实例）的name属性的时候，JavaScript在 WorkerBee.prototype中找到了name属性的值。所以它不会进一步顺着原型链访问Employee.prototype。
如果你想要在运行时改变改变对象的属性，并且让这个属性的新值被所有的该对象后代所继承，你就不能在对象的构造函数中定义这个属性。相反，你要将它添加在于构造函数向关联的原型上。例如，假设你将上面的代码修改如下：
程序代码function Employee () {
this.dept = "general";
}
Employee.prototype.name = "";
function WorkerBee () {
this.projects = [];
}
WorkerBee.prototype = new Employee;
amy = new WorkerBee;
Employee.prototype.name = "Unknown";
在这种情况下，amy对象的name属性就变成了"Unknown"。
就像这些例子展示的，如果你想要让对象的属性有默认值，而且又希望可以在运行时改变这个默认值，你就应该在构造器的原型中设置这个属性，而不是在构造函数中。
确定实例关系
你可能想要知道某个对象的原型链中究竟有些什么对象，所以你可以分辨出这个对象从哪些对象继承属性。在基于类的语言中，你可能拥有一个instanceof操作符来完成这项工作。JavaScript可没有提供instanceof，但是你可以自己写一个这样的函数。
正如在"属性的继承"中所讨论的，当你使用new操作符和构造函数创建新对象的时候，JavaScript将新对象的__proto__属性设置为构造函数的prototype属性的值。你可以使用这一点来测试原型链。
举个例子，假设你使用了我们上面使用的定义，原型都被合适地设置好了。像下面这样创建一个__proto__对象：
程序代码chris = new Engineer("Pigman, Chris", ["jsd"], "fiji");
就这个对象而言，下面的语句都是成立（true）的。
程序代码chris.__proto__ == Engineer.prototype;
chris.__proto__.__proto__ == WorkerBee.prototype;
chris.__proto__.__proto__.__proto__ == Employee.prototype;
chris.__proto__.__proto__.__proto__.__proto__ == Object.prototype;
chris.__proto__.__proto__.__proto__.__proto__.__proto__ == null;
根据这一点，你可以像下面这样写一个instanceOf函数：
程序代码function instanceOf(object, constructor) {
while (object != null) {
if (object == constructor.prototype) return true;
object = object.__proto__;
}
return false;
}
有以上定义，下面的表达式都成立(true)：
程序代码instanceOf (chris, Engineer)
instanceOf (chris, WorkerBee)
instanceOf (chris, Employee)
instanceOf (chris, Object)
但是下面的表达式不成立：
程序代码instanceOf (chris, SalesPerson)
构造器中的全局信息
当你创建构造器的时候，如果你要在构造器中设置全局信息就需要小心了。举个例子，假设你想要给每个新的employee都自动设置一个独一无二的ID。你可能会这么定义Employee：
程序代码var idCounter = 1;
function Employee (name, dept) {
this.name = name || "";
this.dept = dept || "general";
this.id = idCounter++;
}
使用这个定义，当你创建一个新的Employee的时候，构造器会设置序列中的下一个ID并且将全局的IE计数器加一。所以，如果你的后续语句是：
程序代码victoria = new Employee("Pigbert, Victoria", "pubs")
harry = new Employee("Tschopik, Harry", "sales")
victoria.id是1 并且harry.id是 2。第一眼看起来一切正常。然而，idCounter在每次Employee对象被创建的时候都会加一，而不管你是处于什么目的。如果你像我们之前那样创建整个Employee层次，每当我们设置一次原型的时候Employee构造器都会被调用一次。也就是说，假设你有如下代码：
程序代码var idCounter = 1;
function Employee (name, dept) {
this.name = name || "";
this.dept = dept || "general";
this.id = idCounter++;
}
function Manager (name, dept, reports) {...}
Manager.prototype = new Employee;
function WorkerBee (name, dept, projs) {...}
WorkerBee.prototype = new Employee;
function Engineer (name, projs, mach) {...}
Engineer.prototype = new WorkerBee;
function SalesPerson (name, projs, quota) {...}
SalesPerson.prototype = new WorkerBee;
mac = new Engineer("Wood, Mac");
进一步假设我们省略的定义中设置了base属性，并且调用了处于原型链上游的构造器。在这里例子中，到mac对象被创建的时候，mac.id 是 5。
根据应用的不同，计数器被额外多加这么几次不一定有没有影响。如果你关心计数器的精确值，一个可能的解决方案需要使用下面这个替代的构造器：
程序代码function Employee (name, dept) {
this.name = name || "";
this.dept = dept || "general";
if (name) this.id = idCounter++;
}
当你Employee的实例是为了作为原型的时候，你不会向构造器提供参数。使用这个构造器定义，当你不提供参数的时候，构造器不会设置id值，也不会更新计数器的值。自然而然，想要让一个Employee取得id，你必须给employee指定一个姓名。在我们的例子中，mac.id将会是1。
没有多继承（Multiple Inheritance）
一些面向对象语言允许多继承。也就是，一个对象可以从不相关的多个父对象中继承属性和值。JavaScript并不支持多继承。
正如我们已经说的，属性值的继承发生在运行时，是通过JavaScript在对象的原型链中搜索一个属性值（实现的）。因为一个对象只有一个关联的原型，JavaScript不能动态地从多个原型链中继承属性。
在JavaScript中，你可以在一个构造函数中调用多个构造函数。这可以制造一种多继承的假象。举例来说，考虑如下的语句：
程序代码function Hobbyist (hobby) {
this.hobby = hobby || "scuba";
}
function Engineer (name, projs, mach, hobby) {
this.base1 = WorkerBee;
this.base1(name, "engineering", projs);
this.base2 = Hobbyist;
this.base2(hobby);
this.projects = mach || "";
}
Engineer.prototype = new WorkerBee;
dennis = new Engineer("Doe, Dennis", ["collabra"], "hugo")
进一步假设WorkerBee的定义和我们之前看到的一样。在这种情况下，dennis对象有如下的属性：
程序代码dennis.name == "Doe, Dennis"
dennis.dept == "engineering"
dennis.projects == ["collabra"]
dennis.machine == "hugo"
dennis.hobby == "scuba"
所以dennis确实从Hobbyist构造器中取得了hobby属性。然而，假设你之后又向Hobbyist构造器的原型中添加了属性：
程序代码Hobbyist.prototype.equipment = ["mask", "fins", "regulator", "bcd"]
dennis对象并不会继承这个新的属性。]]>
引用内容