Javascript 与原型结构相比，经典结构有什么好处？

我最近才开始编程，而且完全自学，不幸的是，我没有详细的计算机科学课程的好处。最近我读了很多关于JavaScript的书，我试图从类中找到JavaScript原型的好处。问题似乎是从中间哪一个更好开始的，我想看看它经典的一面

当我查看原型示例时：

var inst_a = {
  "X": 123,
  "Y": 321,
  add: function () {
    return this.X+this.Y;
  }
};
document.write(inst_a.add());

function Comment(user,text){
  this.user = user;
  this.text = text;
  this.toString = function(){
    return '<span class="comment">'+this.text+' - <a class="user">'+this.user+'</a></span>';
  };
};


var comments = someFunctionThatReturnsALotOfCommentObjects();
for(c=0;c<comments.length;c++)
  document.getElementById('comments_container').innerHTML += comments[c].toString();

然后是古典版本

function A(x,y){
  this.X = x;
  this.Y = y;
  this.add = function(){
    return this.X+this.Y;
  };
};
var inst_a = new A(123,321);
document.write(inst_a.add());

---

我开始考虑这一点，因为我正在看新的ecmascript第5版，很多人似乎对他们没有添加类系统感到愤怒。

使用第二种方法，您可以创建

a

的实例，允许您一次创建多个。例如：

var inst_one = new A(123,321);
var inst_two = new A(456,654);

// some meaningful code here...
document.write(inst_one.add());


// some more meaningful code here...
document.write(inst_two.add());

您提供的示例并不重要，因此让我们来制作一个更直观的示例：

var inst_a = {
  "X": 123,
  "Y": 321,
  add: function () {
    return this.X+this.Y;
  }
};
document.write(inst_a.add());

function Comment(user,text){
  this.user = user;
  this.text = text;
  this.toString = function(){
    return '<span class="comment">'+this.text+' - <a class="user">'+this.user+'</a></span>';
  };
};


var comments = someFunctionThatReturnsALotOfCommentObjects();
for(c=0;c<comments.length;c++)
  document.getElementById('comments_container').innerHTML += comments[c].toString();

函数注释（用户、文本）{
this.user=用户；
this.text=文本；
this.toString=函数（）{
返回'+this.text+'-概念，如果您没有正式的编程课程，这可能是您不熟悉它的原因。
当您通过
新建
创建对象时，它将使用其原型链查找实例中未找到的属性

因此，例如，您可以只向
A.prototype
添加一次
add
方法，而不是每次创建
A
的新实例时重新定义同一函数的新副本

function A(x,y){
  this.X = x;
  this.Y = y;

};
//define add once, instead of every time we create a new 'A'
A.prototype.add = function(){
    return this.X+this.Y;
  };

经典版本允许您声明作用域为“内部”的私有变量这个对象，虽然原型版本没有。
 
公平的JavaScript确实有类。嗯，也许有些人会争辩说，但是我认为这只是毛发的语义分裂。如果一个类被用作创建对象的蓝图，而不是JavaScript函数可以以这种能力服务。e、 唯一形式：
class someObj
{
    private int x;
    public int returnX()
    {
        return x;
    }
}
someObj temp = new someObj();

-

在引擎盖下，它们是不同的，但是你可以使用任何一种形式来达到相同的目的

原型继承在继承方面确实不同。在原型继承中，当你创建一个新对象时，你实际上是在复制原型对象的一个实例，然后向其添加新的字段或成员。另一方面，经典继承不是处理实例，而是处理一个“蓝图”。例如，在JavaScript中，你会说：

temp.prototype = new someOtherObj(); //Creating a new instance to serve as the prototype.

用古典语言，你可以说：

class someObj : someOtherObj //Copying the "blue print" over.

这意味着数据将在prototype语言中的派生对象之间共享。我曾经编写过一个函数，并让另一个函数通过JavaScript中的原型从中派生。这个基本对象持有对DOM对象的引用，当我在一个子对象中更改它时，它将更改该子对象的所有实例.这是因为，同样，在原型语言中，您是从实例派生的，而不是“蓝图”.
如果不使用psuedoClassic样式，继承实际上是不可能的。看看Douglas Crockford对此有什么看法。即使要使用纯原型对象结构，也必须为继承创建构造函数（Crockford会这样做，然后将其抽象到
create
方法后面，然后调用它纯原型）
问得好；我问了一个类似的问题：我会通读一遍。我在搜索中没有找到它。谢谢！你也可以用inst_a的原型制作另一个inst_*并更新X和Y或添加更多属性。我个人会实现一个Object.clone，负责复制。@Rixius哦，是的。我可以花一整天的时间来创建关于OOP如何有用的示例：-d感谢更好的示例。不是真的。您可以在原型版本中创建闭包。+1用于继承——非常好的一点，也是我最喜欢的OOP部分之一。