JavaScript 中对象的prototype 属性，可以返回对象类型原型的引用。这是一个相当
拗口的解释，要理解它，先要正确理解对象类型(Type)以及原型(prototype)的概念。
1、什么是prototype
JavaScript 中对象的prototype 属性，可以返回对象类型原型的引用。这是一个相当
拗口的解释，要理解它，先要正确理解对象类型（Type）以及原型（prototype）的概念。
前面我们说，对象的类（Class）和对象实例（Instance）之间是一种“创建”关系，
因此我们把“类”看作是对象特征的模型化，而对象看作是类特征的具体化，或者说，类
（Class）是对象的一个类型(Type)。例如，在前面的例子中，p1 和p2 的类型都是Point，
在JavaScript 中，通过instanceof 运算符可以验证这一点：
p1 instanceof Point
p2 instanceof Point
但是，Point 不是p1 和p2 的唯一类型，因为p1 和p2 都是对象，所以Obejct 也是它
们的类型，因为Object 是比Point 更加泛化的类，所以我们说，Obejct 和Point 之间有一
种衍生关系，在后面我们会知道，这种关系被叫做“继承”，它也是对象之间泛化关系的一
个特例，是面向对象中不可缺少的一种基本关系。
在面向对象领域里，实例与类型不是唯一的一对可描述的抽象关系，在JavaScript 中，
另外一种重要的抽象关系是类型（Type)与原型(prototype)。这种关系是一种更高层次的抽
象关系，它恰好和类型与实例的抽象关系构成了一个三层的链。
在现实生活中，我们常常说，某个东西是以另一个东西为原型创作的。这两个东西可以
是同一个类型，也可以是不同类型。习语“依葫芦画瓢”，这里的葫芦就是原型，而瓢就是
类型， 用JavaScript 的prototype 来表示就是“ 瓢.prototype = 某个葫芦” 或者
“瓢.prototype= new 葫芦()”。
要深入理解原型，可以研究关于它的一种设计模式——prototype pattern，这种模式
的核心是用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
JavaScript 的prototype 就类似于这种方式。
关于prototype pattern 的详细内容可以参考《设计模式》（《Design Patterns》）它不
是本文讨论的范围。
注意，同类型与实例的关系不同的是，原型与类型的关系要求一个类型在一个时刻只能
有一个原型（而一个实例在一个时刻显然可以有多个类型）。对于JavaScript 来说，这个限制有两层含义，第一是每个具体的JavaScript 类型有且仅有一个原型（prototype），在默认的情况下，这个原型是一个Object 对象（注意不是Object 类型！）。第二是，这个对象所属的类型，必须是满足原型关系的类型链。例如p1 所属的类型是Point 和Object，而一个Object 对象是Point 的原型。假如有一个对象，它所属的类型分别为ClassA、ClassB、ClassC和Object，那么必须满足这四个类构成某种完整的原型链。
有意思的是，JavaScript 并没有规定一个类型的原型的类型（这又是一段非常拗口的
话），因此它可以是任何类型，通常是某种对象，这样，对象-类型-原形（对象）就可能构
成一个环状结构，或者其它有意思的拓扑结构，这些结构为JavaScript 带来了五花八门的
用法，其中的一些用法不但巧妙而且充满美感。下面的一节主要介绍prototype 的用法。
2、prototype 使用技巧
在了解prototype 的使用技巧之前，首要先弄明白prototype 的特性。首先，JavaScript
为每一个类型(Type)都提供了一个prototype 属性，将这个属性指向一个对象，这个对象就
成为了这个类型的“原型”，这意味着由这个类型所创建的所有对象都具有这个原型的特性。
另外，JavaScript 的对象是动态的，原型也不例外，给prototype 增加或者减少属性，将
改变这个类型的原型，这种改变将直接作用到由这个原型创建的所有对象上，例如：
<script>
function Point(x,y) {
this.x = x;
this.y = y;
}
var p1 = new Point(1,2);
var p2 = new Point(3,4);
Point.prototype.z = 0; //动态为Point 的原型添加了属性
alert(p1.z);
alert(p2.z); //同时作用于Point 类型创建的所有对象
</script>
结果：第一次：0 第二次：0
如果给某个对象的类型的原型添加了某个名为a 的属性，而这个对象本身又有一个名为
a 的同名属性，则在访问这个对象的属性a 时，对象本身的属性“覆盖”了原型属性，但是
原型属性并没有消失，当你用delete 运算符将对象本身的属性a 删除时，对象的原型属性
就恢复了可见性。利用这个特性，可以为对象的属性设定默认值，例如：
<script>
function Point(x, y) {
if(x) this.x = x;
if(y) this.y = y;
}
Point.prototype.x = 0;
Point.prototype.y = 0;
var p1 = new Point;
var p2 = new Point(1,2);
alert(p1.x+" "+p1.y);
alert(p1.x+" "+p1.y);
</script>
结果：第一次：0 0 第二次：0 0
上面的例子通过prototype 为Point 对象设定了默认值(0,0)，因此p1 的值为(0,0)，p2
的值为(1,2)，通过delete p2.x, delete p2.y; 可以将p2 的值恢复为(0,0)。下面是一个
更有意思的例子：
<script>
function classA() {
this.a = 100;
this.b = 200;
this.c = 300;
this.reset = function() {
for(var each in this){
delete this[each];
}
}
}
classA.prototype = new classA();
var a = new classA();
alert(a.a);
a.a *= 2;
a.b *= 2;
a.c *= 2;
alert(a.a);
alert(a.b);
alert(a.c);
a.reset(); //调用reset 方法将a 的值恢复为默认值
alert(a.a);
alert(a.b);
alert(a.c);
</script>
利用prototype 还可以为对象的属性设置一个只读的getter，从而避免它被改写。下
面是一个例子：
<script>
function Point(x, y) {
if(x) this.x = x;
if(y) this.y = y;
}
Point.prototype.x = 0;
Point.prototype.y = 0;
function LineSegment(p1, p2) {
//私有成员
var m_firstPoint = p1;
var m_lastPoint = p2;
var m_width = {
valueOf : function(){return Math.abs(p1.x - p2.x)},
toString : function(){return Math.abs(p1.x - p2.x)}
}
var m_height = {
valueOf : function(){return Math.abs(p1.y - p2.y)},
toString : function(){return Math.abs(p1.y - p2.y)}
}
//getter
this.getFirstPoint = function() {
return m_firstPoint;
}
this.getLastPoint = function() {
return m_lastPoint;
}
this.length = {
valueOf : function(){
return Math.sqrt(m_width*m_width+m_height*m_height)
},
toString : function(){
return Math.sqrt(m_width*m_width + m_height*m_height)
}
}
}
var p1 = new Point;
var p2 = new Point(2,3);
var line1 = new LineSegment(p1, p2);
var lp = line1.getFirstPoint();
lp.x = 100; //不小心改写了lp 的值，破坏了lp 的原始值而且不可恢复
alert(line1.getFirstPoint().x);
alert(line1.length); //就连line1.lenght 都发生了改变
</script>
将this.getFirstPoint()改写为下面这个样子：
this.getFirstPoint = function() {
function GETTER(){};
GETTER.prototype = m_firstPoint;
return new GETTER();
}
则可以避免这个问题，保证了m_firstPoint 属性的只读性。
<script>
function Point(x, y) {
if(x) this.x = x;
if(y) this.y = y;
}
Point.prototype.x = 0;
Point.prototype.y = 0;
function LineSegment(p1, p2) {
//私有成员
var m_firstPoint = p1;
var m_lastPoint = p2;
var m_width = {
valueOf : function(){
return Math.abs(p1.x - p2.x)
},
toString : function(){
return Math.abs(p1.x - p2.x)
}
}
var m_height = {
valueOf : function(){
return Math.abs(p1.y - p2.y)
},
toString : function(){
return Math.abs(p1.y - p2.y)
}
}
//getter
this.getFirstPoint = function() {
function GETTER(){};
GETTER.prototype = m_firstPoint;
return new GETTER();
}
this.getLastPoint = function() {
function GETTER(){};
GETTER.prototype = m_lastPoint;
return new GETTER();
}
this.length = {
valueOf : function(){
return Math.sqrt(m_width*m_width + m_height*m_height)
},
toString : function(){
return Math.sqrt(m_width*m_width + m_height*m_height)
}
}
}
var p1 = new Point;
var p2 = new Point(2,3);
var line1 = new LineSegment(p1, p2);
var lp = line1.getFirstPoint();
lp.x = 100; //不小心改写了lp 的值，但是没有破坏原始的值
alert(line1.getFirstPoint().x);
alert(line1.length); //line1.lenght 不发生改变
</script>
实际上，将一个对象设置为一个类型的原型，相当于通过实例化这个类型，为对象建立
只读副本，在任何时候对副本进行改变，都不会影响到原始对象，而对原始对象进行改变，
则会影响到副本，除非被改变的属性已经被副本自己的同名属性覆盖。用delete 操作将对
象自己的同名属性删除，则可以恢复原型属性的可见性。下面再举一个例子：
<script>
function Polygon() {
var m_points = [];
m_points = Array.apply(m_points, arguments);
function GETTER(){};
GETTER.prototype = m_points[0];
this.firstPoint = new GETTER();
this.length = {
valueOf : function(){
return m_points.length
},
toString : function(){
return m_points.length
}
}
this.add = function() {
m_points.push.apply(m_points, arguments);
}
this.getPoint = function(idx) {
return m_points[idx];
}
this.setPoint = function(idx, point) {
if (m_points[idx] == null) {
m_points[idx] = point;
} else {
m_points[idx].x = point.x;
m_points[idx].y = point.y;
}
}
}
var p = new Polygon({x:1, y:2},{x:2, y:4},{x:2, y:6});
alert(p.length);
alert(p.firstPoint.x);
alert(p.firstPoint.y);
p.firstPoint.x = 100; //不小心写了它的值
alert(p.getPoint(0).x); //不会影响到实际的私有成员
delete p.firstPoint.x; //恢复
alert(p.firstPoint.x);
p.setPoint(0, {x:3,y:4}); //通过setter 改写了实际的私有成员
alert(p.firstPoint.x); //getter 的值发生了改变
alert(p.getPoint(0).x);
</script>
注意，以上的例子说明了用prototype 可以快速创建对象的多个副本，一般情况下，利
用prototype 来大量的创建复杂对象，要比用其他任何方法来copy 对象快得多。注意到，
用一个对象为原型，来创建大量的新对象，这正是prototype pattern 的本质。
下面是一个例子：
<script>
var p1 = new Point(1,2);
var points = [];
var PointPrototype = function(){};
PointPrototype.prototype = p1;
for(var i = 0; i < 10000; i++) {
points[i] = new PointPrototype();
//由于PointPrototype 的构造函数是空函数，因此它的构造要比直接构造//p1 副
本快得多。
}
</script>
除了上面所说的这些使用技巧之外，prototype 因为它独特的特性，还有其它一些用途，
被用作最广泛和最广为人知的可能是用它来模拟继承，关于这一点，留待下一节中去讨论。
3、prototype 的实质
上面已经说了prototype 的作用，现在我们来透过规律揭示prototype 的实质。
我们说，prototype 的行为类似于C++中的静态域，将一个属性添加为prototype 的属性，
这个属性将被该类型创建的所有实例所共享，但是这种共享是只读的。在任何一个实例中只
能够用自己的同名属性覆盖这个属性，而不能够改变它。换句话说，对象在读取某个属性时，
总是先检查自身域的属性表，如果有这个属性，则会返回这个属性，否则就去读取prototype
域，返回protoype 域上的属性。另外，JavaScript 允许protoype 域引用任何类型的对象，
因此，如果对protoype 域的读取依然没有找到这个属性，则JavaScript 将递归地查找
prototype 域所指向对象的prototype 域，直到这个对象的prototype 域为它本身或者出现
循环为止，我们可以用下面的图来描述prototype 与对象实例之间的关系：
//TODO:
4、prototype 的价值与局限性
从上面的分析我们理解了prototype，通过它能够以一个对象为原型，安全地创建大量
的实例，这就是prototype 的真正含义，也是它的价值所在。后面我们会看到，利用prototype
的这个特性，可以用来模拟对象的继承，但是要知道，prototype 用来模拟继承尽管也是它
的一个重要价值，但是绝对不是它的核心，换句话说，JavaScript 之所以支持prototype，
绝对不是仅仅用来实现它的对象继承，即使没有了prototype 继承，JavaScript的prototype
机制依然是非常有用的。
由于prototype 仅仅是以对象为原型给类型构建副本，因此它也具有很大的局限性。首先，
它在类型的prototype 域上并不是表现为一种值拷贝，而是一种引用拷贝，这带来了“副作
用”。改变某个原型上引用类型的属性的属性值（又是一个相当拗口的解释:P），将会彻底影
响到这个类型创建的每一个实例。有的时候这正是我们需要的（比如某一类所有对象的改变
默认值），但有的时候这也是我们所不希望的（比如在类继承的时候），下面给出了一个例子：
<script>
function ClassA() {
this.a=[];
}
function ClassB() {
this.b=function(){};
}
ClassB.prototype=new ClassA();
var objB1=new ClassB();
var objB2=new ClassB();
objB1.a.push(1,2,3);
alert(objB2.a);
//所有b 的实例中的a 成员全都变了！！这并不是这个例子所希望看到的。
</script>
分享到：
相关推荐
JavaScriptprototype的深度探索不是原型继承那么简单.pdf
理解prototype属性首先需要从对象、类型和原型的关系开始探索。 在JavaScript中，对象和类（类型）的关系可以被描述为“创建”关系，其中类是对象特征的模型化，对象则是类特征的具体实例。例如，当我们创建一个...
`prototype` 的深度探索 #### 1. 什么是 `prototype` 在 JavaScript 中，`prototype` 属性是一个非常核心的概念，它主要用于实现对象之间的继承。简单来说，`prototype` 是对象类型原型的一个引用。为了更好地...
jQuery以其易用性和广泛的社区支持占据了主导地位，而Prototype则以其深度的DOM操作和面向对象的设计思想吸引了一部分开发者。学习这两个框架可以帮助您更好地理解和掌握JavaScript编程，提升Web开发效率。通过提供...
《JavaScript权威指南》是一本备受推崇的编程教材，专注于JavaScript语言的深度解析。这本书由David Flanagan撰写，为读者提供了全面而深入的JavaScript知识。Epub格式的电子书便于在各种设备上阅读，而源码文件则...
JavaScript，作为一种广泛应用于Web开发的脚本语言，其深度理解和高效使用是每个前端开发者必备的技能。本资源集合主要关注JavaScript中的三个核心概念：闭包、原型（Prototype）以及JavaScript的深入机制。以下是对...
但这仅仅是开始，JavaScript的深度和广度远不止于此，随着经验的积累，你将更深入地探索这个语言的魅力，包括前端框架（如React、Vue、Angular）、Node.js后端开发、Web组件化、TypeScript等更多高级主题。
### 探索JavaScript的原型链：原型继承的奥秘 #### 一、JavaScript与原型继承的基础 JavaScript（简称JS）是一种广泛使用的高级编程语言，在Web开发中占据着核心地位。它的特性之一是基于原型的继承机制，这与其他...
### JavaScript的秘密花园：深入探索JS的核心概念 #### 引言 `JavaScript_Garden_CN`，中文译为“JavaScript的秘密花园”，是一份详尽且不断更新的文档，专注于揭示JavaScript中的那些微妙而奇特的用法。这份文档...
### 精通JavaScript：深度探索与实践 在IT领域，尤其是前端开发中，JavaScript（简称JS）无疑占据着核心地位。《精通JavaScript》作为一本今年刚出版的专业书籍，为开发者提供了一条深入理解并掌握这门语言的路径。...
以上只是JavaScript学习和实践过程中的一部分知识点，实际开发中，JavaScript的应用深度和广度远不止于此。持续积累和实践，不断探索新的技术和最佳实践，是成为一名优秀的JavaScript开发者的关键。
JavaScript，作为Web开发的核心语言，一直在不断发展和更新。在进阶阶段，JavaScript的知识点变得更为深入和广泛。本文将重点探讨“js进阶...不断探索和理解JavaScript的深度，将有助于你在Web开发领域取得更大的成就。
功能性JavaScript工作坊旨在深入探索JavaScript的函数式编程概念，这对于提升你的编程技能和理解现代JavaScript应用的构建方式至关重要。在JavaScript的世界中，函数式编程是一种强大的编程范式，它强调程序的数据流...
总结，OPJS是一个深度挖掘JavaScript特性和实践的个人项目，涵盖了从基础到高级的广泛内容，对于任何希望提升JavaScript技能的开发者来说，都是一份宝贵的资源。通过深入学习和实践，可以更好地驾驭这门强大的语言，...
**JavaScript 深度探索与高级特性** JavaScript，作为互联网上最广泛使用的编程语言之一，其高级特性对于提升代码质量、性能优化以及实现复杂功能至关重要。在这个“Advanced-[removed]高级 JavaScript 课程”中，...
在JavaScript中，可以使用`Array.prototype.shift()`和`Array.prototype.push()`方法实现队列操作。以下是一个简单的BFS实现： ```javascript function bfs(root) { const queue = [root]; while (queue.length...
在JavaScript的世界里，探索其深度和广度是无尽的。作为一门广泛应用于Web开发的脚本语言，JavaScript不仅在客户端有着强大的表现力，还在服务器端（Node.js）占据一席之地。这篇博客将带你深入理解JavaScript的核心...
JavaScript中的函数式编程是软件开发领域的一个重要概念...《Functional JavaScript》是一本非常有价值的资源，它能引导你探索这一编程范式的深度和广度。通过实践和理解书中的内容，你将在JavaScript开发中受益匪浅。