我不太喜欢动态编程语言，但我已经编写了相当多的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
这些幻灯片也帮了大忙。
我总是喜欢用类比来理解这类事情在我看来，原型继承与类低音继承相比非常令人困惑，尽管原型是更简单的范例。事实上，对于原型来说，确实没有继承，因此名称本身就具有误导性，更像是一种“委托”。
想象一下。。。。
你在上高中，你在课堂上，有一个今天到期的测验，但你没有笔来填写你的答案。多！
你坐在你的朋友芬尼乌斯旁边，他可能有一支笔。你问，他环顾了一下他的桌子，但没有成功，但他不是说“我没有笔”，而是一个很好的朋友，他会和他的另一个朋友Derp检查是否有笔。德普确实有一支备用笔，并将其交给芬尼乌斯，后者将其交由你完成测验。德普已将笔交给芬尼乌斯，后者已将笔委托给你使用。
这里重要的是，德普不会把笔交给你，因为你和他没有直接关系。
这是原型如何工作的一个简化示例，其中搜索数据树以查找您要查找的对象。
在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);
每个对象都有一个内部属性[[Prototype]]，将其链接到另一个对象：
object [[Prototype]] → anotherObject
在传统javascript中，链接对象是函数的原型属性：
object [[Prototype]] → aFunction.prototype
某些环境将[[Prototype]]公开为__proto__：
anObject.__proto__ === anotherObject
创建对象时创建[[Prototype]]链接。
// (1) Object.create:
var object = Object.create(anotherObject)
// object.__proto__ = anotherObject
// (2) ES6 object initializer:
var object = { __proto__: anotherObject };
// object.__proto__ = anotherObject
// (3) Traditional JavaScript:
var object = new aFunction;
// object.__proto__ = aFunction.prototype
因此，这些陈述是等价的：
var object = Object.create(Object.prototype);
var object = { __proto__: Object.prototype }; // ES6 only
var object = new Object;
您实际上无法在新语句中看到链接目标（Object.prototype）；相反，目标由构造函数（Object）暗示。
记得：
每个对象都有一个链接[[Prototype]]，有时公开为__proto__。每个函数都有一个原型属性，最初持有一个空对象。使用new创建的对象链接到其构造函数的原型属性。如果函数从未用作构造函数，则其原型属性将不被使用。如果不需要构造函数，请使用Object.create而不是new。
让我告诉你我对原型的理解。我不会将这里的继承与其他语言进行比较。我希望人们不要再比较语言了，而只把语言理解为语言本身。理解原型和原型继承非常简单，我将在下面向您展示。
原型就像一个模型，你可以根据它来创建产品。要理解的关键点是，当您使用另一个对象作为原型创建一个对象时，原型和产品之间的联系是持久的。例如：
var model = {x:2};
var product = Object.create(model);
model.y = 5;
product.y
=>5
每个对象都包含一个名为[[prototype]]的内部属性，可以通过object.getPrototypeOf（）函数访问该属性。create（model）创建一个新对象，并将其[[prototype]]属性设置为对象模型。因此，当您执行Object.getPrototypeOf（产品）时，您将获得对象模型。
产品中的财产按以下方式处理：
当访问属性以读取其值时，将在范围链中查找该属性。变量的搜索从产品开始，一直到其原型。如果在搜索中找到了这样的变量，搜索将立即停止，并返回值。如果在作用域链中找不到这样的变量，则返回undefined。当写入（更改）属性时，该属性将始终写入产品对象。如果产品还没有这样的属性，则会隐式创建和编写它。
使用原型属性的对象链接称为原型继承。这很简单，同意吗？
