我不太喜欢动态编程语言，但我已经编写了相当多的JavaScript代码。我从未真正了解过这种基于原型的编程，有人知道它是如何工作的吗？
var obj = new Object();
obj.prototype.test = function() { alert('Hello?'); };
var obj2 = new obj();
obj2.test();
我记得前一段时间我和人们进行了很多讨论（我不太确定我在做什么），但据我所知，没有什么课的概念。它只是一个对象，这些对象的实例是原始对象的克隆，对吗？
但JavaScript中这个“.prototype”属性的确切用途是什么？它与实例化对象有什么关系？
更新：正确方式
var obj = new Object(); // not a functional object
obj.prototype.test = function() { alert('Hello?'); }; // this is wrong!
function MyObject() {} // a first class functional object
MyObject.prototype.test = function() { alert('OK'); } // OK
这些幻灯片也帮了大忙。
原型允许您创建类。如果不使用原型，那么它将成为静态的。
这里有一个简短的例子。
var obj = new Object();
obj.test = function() { alert('Hello?'); };
在上面的例子中，您有静态函数调用测试。该函数只能由obj.test访问，您可以将obj想象为一个类。
其中如下代码所示
function obj()
{
}
obj.prototype.test = function() { alert('Hello?'); };
var obj2 = new obj();
obj2.test();
obj已成为一个现在可以实例化的类。可以存在多个obj实例，它们都具有测试功能。
以上是我的理解。我正在把它做成一个社区维基，所以如果我错了，人们可以纠正我。
我总是喜欢用类比来理解这类事情在我看来，原型继承与类低音继承相比非常令人困惑，尽管原型是更简单的范例。事实上，对于原型来说，确实没有继承，因此名称本身就具有误导性，更像是一种“委托”。
想象一下。。。。
你在上高中，你在课堂上，有一个今天到期的测验，但你没有笔来填写你的答案。多！
你坐在你的朋友芬尼乌斯旁边，他可能有一支笔。你问，他环顾了一下他的桌子，但没有成功，但他不是说“我没有笔”，而是一个很好的朋友，他会和他的另一个朋友Derp检查是否有笔。德普确实有一支备用笔，并将其交给芬尼乌斯，后者将其交由你完成测验。德普已将笔交给芬尼乌斯，后者已将笔委托给你使用。
这里重要的是，德普不会把笔交给你，因为你和他没有直接关系。
这是原型如何工作的一个简化示例，其中搜索数据树以查找您要查找的对象。
考虑以下keyValueStore对象：
var keyValueStore = (function() {
var count = 0;
var kvs = function() {
count++;
this.data = {};
this.get = function(key) { return this.data[key]; };
this.set = function(key, value) { this.data[key] = value; };
this.delete = function(key) { delete this.data[key]; };
this.getLength = function() {
var l = 0;
for (p in this.data) l++;
return l;
}
};
return { // Singleton public properties
'create' : function() { return new kvs(); },
'count' : function() { return count; }
};
})();
我可以通过执行以下操作创建此对象的新实例：
kvs = keyValueStore.create();
此对象的每个实例都将具有以下公共财产：
数据收到设置删去获取长度
现在，假设我们创建了这个keyValueStore对象的100个实例。尽管get、set、delete、getLength将对这100个实例中的每一个执行完全相同的操作，但每个实例都有自己的函数副本。
现在，想象一下，如果您只有一个get、set、delete和getLength副本，并且每个实例都引用相同的函数。这将更好地提高性能，并且需要更少的内存。
原型就是这样产生的。原型是财产的“蓝图”，它是继承而不是被实例复制的。因此，这意味着对于一个对象的所有实例，它只在内存中存在一次，并且由所有这些实例共享。
现在，再次考虑keyValueStore对象。我可以这样重写：
var keyValueStore = (function() {
var count = 0;
var kvs = function() {
count++;
this.data = {};
};
kvs.prototype = {
'get' : function(key) { return this.data[key]; },
'set' : function(key, value) { this.data[key] = value; },
'delete' : function(key) { delete this.data[key]; },
'getLength' : function() {
var l = 0;
for (p in this.data) l++;
return l;
}
};
return {
'create' : function() { return new kvs(); },
'count' : function() { return count; }
};
})();
这与keyValueStore对象的上一版本完全相同，只是它的所有方法现在都放在一个原型中。这意味着，所有100个实例现在都共享这四个方法，而不是每个实例都有自己的副本。
在Java、C#或C++等实现经典继承的语言中，首先要创建一个类——一个对象的蓝图——然后可以从该类创建新对象，或者可以扩展该类，定义一个新类来扩充原始类。
在JavaScript中，您首先创建一个对象（没有类的概念），然后您可以扩充自己的对象或从中创建新对象。这并不难，但对于习惯了传统方式的人来说，有点陌生，很难消化。
例子：
//在JavaScript中定义一个函数对象以容纳人员var Person=函数（名称）{this.name=名称；};//向已定义的对象动态添加一个新的getterPerson.prototype.getName=函数（）{返回this.name；};//创建Person类型的新对象var john=新人（“john”）；//试试吸气剂警报（john.getName（））；//如果现在我修改人，John也会得到更新Person.prototype.sayMyName=函数（）{alert（'你好，我的名字是'+this.getName（））；};//对john调用新方法john.sayMyName（）；
到目前为止，我一直在扩展基本对象，现在我创建了另一个对象，然后从Person继承。
//Create a new object of type Customer by defining its constructor. It's not
//related to Person for now.
var Customer = function(name) {
this.name = name;
};
//Now I link the objects and to do so, we link the prototype of Customer to
//a new instance of Person. The prototype is the base that will be used to
//construct all new instances and also, will modify dynamically all already
//constructed objects because in JavaScript objects retain a pointer to the
//prototype
Customer.prototype = new Person();
//Now I can call the methods of Person on the Customer, let's try, first
//I need to create a Customer.
var myCustomer = new Customer('Dream Inc.');
myCustomer.sayMyName();
//If I add new methods to Person, they will be added to Customer, but if I
//add new methods to Customer they won't be added to Person. Example:
Customer.prototype.setAmountDue = function(amountDue) {
this.amountDue = amountDue;
};
Customer.prototype.getAmountDue = function() {
return this.amountDue;
};
//Let's try:
myCustomer.setAmountDue(2000);
alert(myCustomer.getAmountDue());
var Person=函数（名称）{this.name=名称；};Person.prototype.getName=函数（）{返回this.name；};var john=新人（“john”）；警报（john.getName（））；Person.prototype.sayMyName=函数（）{alert（'你好，我的名字是'+this.getName（））；};john.sayMyName（）；var客户=函数（名称）{this.name=名称；};Customer.prototype=新角色（）；var myCustomer=新客户（“梦想股份有限公司”）；myCustomer.sayMyName（）；Customer.prototype.setAmountDue=函数（amountDue）{this.amountDue=amountDue；};Customer.prototype.getAmountDue=函数（）{return this.amountDue；};myCustomer.setAmountDue（2000）；警报（myCustomer.getAmountDue（））；
虽然如上所述，我不能调用setAmountDue（），但对Person调用getAmountDu（）。
//The following statement generates an error.
john.setAmountDue(1000);
