原型继承优于经典继承的好处？

Posted 2023-02-22

【中文标题】原型继承优于经典继承的好处？

【英文标题】：Benefits of prototypal inheritance over classical?

【发布时间】：2011-02-17 13:28:44

【问题描述】：

所以这些年来我终于不再拖拖拉拉，决定“正确地”学习 javascript。语言设计中最令人头疼的元素之一是它的继承实现。有 Ruby 方面的经验，我很高兴看到闭包和动态类型；但是对于我来说，我无法弄清楚使用其他实例进行继承的对象实例有什么好处。

【参考方案1】：

我知道这个答案晚了 3 年，但我真的认为当前的答案没有提供关于 how prototypal inheritance is better than classical inheritance 的足够信息。

首先让我们看看 JavaScript 程序员在捍卫原型继承时最常见的论点（我从当前的答案池中获取这些论点）：

很简单。 功能强大。 这会导致代码更小、冗余更少。 它是动态的，因此更适合动态语言。

现在这些论点都是有效的，但没有人费心解释原因。这就像告诉孩子学习数学很重要。当然是，但孩子肯定不在乎；你不能说数学很重要就让孩子喜欢数学。

我认为原型继承的问题在于它是从 JavaScript 的角度来解释的。我喜欢 JavaScript，但 JavaScript 中的原型继承是错误的。与经典继承不同，原型继承有两种模式：

原型继承的原型模式。 原型继承的构造函数模式。

不幸的是，JavaScript 使用原型继承的构造函数模式。这是因为在创建 JavaScript 时，Brendan Eich（JS 的创建者）希望它看起来像 Java（具有经典继承）：

我们把它作为 Java 的小兄弟，就像 Visual Basic 这样的互补语言在当时微软的语言系列中对 C++ 的推动。

这很糟糕，因为当人们在 JavaScript 中使用构造函数时，他们认为构造函数继承自其他构造函数。这是错误的。在原型继承中，对象继承自其他对象。构造函数永远不会出现。这是让大多数人感到困惑的地方。

来自像 Java 这样具有经典继承的语言的人会更加困惑，因为尽管构造函数看起来像类，但它们的行为并不像类。正如Douglas Crockford 所说：

这种间接方式旨在让受过经典培训的程序员更熟悉该语言，但未能做到这一点，正如我们从 Java 程序员对 JavaScript 的极低评价中可以看出的那样。 JavaScript 的构造函数模式并不吸引经典人群。它还掩盖了 JavaScript 真正的原型性质。因此，很少有程序员知道如何有效地使用该语言。

你有它。直接从马的嘴里。

真正的原型继承

原型继承是关于对象的。对象从其他对象继承属性。这里的所有都是它的。使用原型继承创建对象有两种方法：

创建一个全新的对象。 克隆现有对象并扩展它。

注意： JavaScript 提供了两种克隆对象的方法 - delegation 和 concatenation。以后我将使用“克隆”一词专门指代通过委托进行的继承，而“复制”一词专门指代通过串联进行的继承。

说得够多了。让我们看一些例子。假设我有一个半径为5 的圆：

var circle = 
    radius: 5
;

我们可以根据半径计算圆的面积和周长：

circle.area = function () 
    var radius = this.radius;
    return Math.PI * radius * radius;
;

circle.circumference = function () 
    return 2 * Math.PI * this.radius;
;

现在我想创建另一个半径为10 的圆。一种方法是：

var circle2 = 
    radius: 10,
    area: circle.area,
    circumference: circle.circumference
;

但是 JavaScript 提供了更好的方法 - delegation。 Object.create 函数用于执行此操作：

var circle2 = Object.create(circle);
circle2.radius = 10;

就是这样。您刚刚在 JavaScript 中进行了原型继承。那不是很简单吗？你拿一个对象，克隆它，改变你需要的任何东西，嘿，你得到了一个全新的对象。

现在你可能会问，“怎么这么简单？每次我想创建一个新圆时，我都需要克隆 circle 并手动为其分配一个半径”。那么解决方案是使用函数为您完成繁重的工作：

function createCircle(radius) 
    var newCircle = Object.create(circle);
    newCircle.radius = radius;
    return newCircle;


var circle2 = createCircle(10);

事实上，您可以将所有这些组合成一个对象字面量，如下所示：

var circle = 
    radius: 5,
    create: function (radius) 
        var circle = Object.create(this);
        circle.radius = radius;
        return circle;
    ,
    area: function () 
        var radius = this.radius;
        return Math.PI * radius * radius;
    ,
    circumference: function () 
        return 2 * Math.PI * this.radius;
    
;

var circle2 = circle.create(10);

JavaScript 中的原型继承

如果您注意到在上面的程序中create 函数创建了circle 的克隆，分配一个新的radius 给它，然后返回它。这正是构造函数在 JavaScript 中所做的：

function Circle(radius) 
    this.radius = radius;


Circle.prototype.area = function () 
    var radius = this.radius;
    return Math.PI * radius * radius;
;

Circle.prototype.circumference = function ()          
    return 2 * Math.PI * this.radius;
;

var circle = new Circle(5);
var circle2 = new Circle(10);

JavaScript 中的构造函数模式是原型模式的倒置。而不是创建一个对象，而是创建一个构造函数。 new 关键字将构造函数内的this 指针绑定到构造函数的prototype 的克隆。

听起来令人困惑？这是因为 JavaScript 中的构造函数模式不必要地使事情复杂化。这是大多数程序员难以理解的。

他们不考虑从其他对象继承的对象，而是认为构造函数从其他构造函数继承，然后变得完全混乱。

应该避免 JavaScript 中的构造函数模式还有很多其他原因。您可以在我的博客文章中阅读它们：Constructors vs Prototypes

---

那么原型继承相对于经典继承有什么好处呢？让我们再次回顾一下最常见的论点，并解释为什么。

1。原型继承很简单

CMS 在他的回答中说：

在我看来，原型继承的主要好处是它的简单性。

让我们考虑一下我们刚刚做了什么。我们创建了一个对象circle，其半径为5。然后我们克隆它，并给克隆的半径为10。

因此我们只需要两件事来使原型继承工作：

一种创建新对象的方法（例如对象字面量）。 一种扩展现有对象的方法（例如Object.create）。

相比之下，经典继承要复杂得多。在经典继承中，您有：

类。 对象。 接口。 抽象类。 最后的课程。 虚拟基类。 构造函数。 析构函数。

你明白了。关键是原型继承更容易理解、更容易实现、更容易推理。

正如 Steve Yegge 在他的经典博文“Portrait of a N00b”中所说：

元数据是对其他事物的任何类型的描述或模型。代码中的 cmets 只是计算的自然语言描述。使元数据成为元数据的原因在于它不是绝对必要的。如果我的狗有一些谱系文件，但我丢失了文件，我仍然有一只完全有效的狗。

在同样的意义上，类只是元数据。继承并不严格要求类。然而，有些人（通常是 n00bs）觉得上课更舒服。这给了他们一种虚假的安全感。

好吧，我们也知道静态类型只是元数据。它们是一种专门针对两种读者的评论：程序员和编译器。静态类型讲述了一个关于计算的故事，大概是为了帮助两个读者群体理解程序的意图。但是静态类型可以在运行时被丢弃，因为最终它们只是程式化的 cmets。它们就像家谱文件：它可能会让某些缺乏安全感的性格类型的人更喜欢他们的狗，但狗肯定不在乎。

正如我之前所说，课程给人一种虚假的安全感。例如，即使您的代码完全清晰易读，Java 中的NullPointerExceptions 也会太多。我发现经典继承通常会妨碍编程，但也许这只是 Java。 Python 有一个惊人的经典继承系统。

2。原型继承很强大

大多数具有经典背景的程序员认为，经典继承比原型继承更强大，因为它具有：

私有变量。 多重继承。

这种说法是错误的。我们已经知道 JavaScript 支持private variables via closures，但是多重继承呢？ JavaScript 中的对象只有一个原型。

事实上，原型继承支持从多个原型继承。原型继承仅仅意味着一个对象从另一个对象继承。居然有two ways to implement prototypal inheritance：

委托或差异继承 克隆或串联继承

是的，JavaScript 只允许对象委托给另一个对象。但是，它允许您复制任意数量的对象的属性。例如_.extend 就是这样做的。

当然，许多程序员并不认为这是真正的继承，因为instanceof 和isPrototypeOf 另有说法。然而，这可以通过在每个通过连接继承自原型的对象上存储一个原型数组来轻松解决：

function copyOf(object, prototype) 
    var prototypes = object.prototypes;
    var prototypeOf = Object.isPrototypeOf;
    return prototypes.indexOf(prototype) >= 0 ||
        prototypes.some(prototypeOf, prototype);

因此，原型继承与经典继承一样强大。事实上，它比经典继承更强大，因为在原型继承中，您可以从不同的原型中手动选择要复制的属性以及要省略的属性。

在经典继承中，不可能（或至少非常困难）选择要继承的属性。他们使用虚拟基类和接口来解决the diamond problem。

然而，在 JavaScript 中，您很可能从未听说过菱形问题，因为您可以准确控制希望继承哪些属性以及从哪些原型继承。

3。原型继承更少冗余

这点有点难以解释，因为经典继承并不一定会导致更多冗余代码。事实上，继承，无论是经典的还是原型的，都被用来减少代码中的冗余。

一个论点可能是大多数具有经典继承的编程语言都是静态类型的，并且需要用户显式声明类型（与具有隐式静态类型的 Haskell 不同）。因此，这会导致更冗长的代码。

Java 因这种行为而臭名昭著。我清楚地记得Bob Nystrom 在他的博客文章中提到了以下关于Pratt Parsers 的轶事：

您一定会喜欢这里 Java 的“请一式三份签名”的官僚作风。

再说一次，我认为这只是因为 Java 太烂了。

一个有效的论点是并非所有具有经典继承的语言都支持多重继承。再次想到 Java。是的，Java 有接口，但这还不够。有时你真的需要多重继承。

由于原型继承允许多重继承，如果使用原型继承而不是使用具有经典继承但没有多重继承的语言编写需要多重继承的代码，则冗余更少。

4。原型继承是动态的

原型继承最重要的优点之一是您可以在原型创建后向其添加新属性。这允许您向原型添加新方法，这些方法将自动提供给委托给该原型的所有对象。

这在经典继承中是不可能的，因为一旦创建了一个类，就不能在运行时修改它。这可能是原型继承相对于经典继承的最大优势，它应该是最重要的。不过我喜欢把最好的留到最后。

结论

原型继承很重要。教育 JavaScript 程序员为什么要放弃原型继承的构造函数模式转而支持原型继承的原型模式非常重要。

我们需要开始正确地教授 JavaScript，这意味着向新程序员展示如何使用原型模式而不是构造器模式编写代码。

使用原型模式不仅更容易解释原型继承，而且还可以培养出更好的程序员。

如果您喜欢这个答案，那么您还应该阅读我关于“Why Prototypal Inheritance Matters”的博文。相信我，你不会失望的。

【讨论】：

你经常使用clone这个词，这是完全错误的。 Object.create 正在使用指定的原型创建新对象。您选择的词语给人的印象是原型被克隆了。

@AaditMShah 虽然我喜欢你的第四点。考虑维护几千行多个 javascript 文件。我们需要在非常文件中查找变量。变量名中的一个小错误会造成严重破坏。编译器不会指出这个错误。到目前为止，无法使用自动建议或自动更正编写好的 IDE。变量名不能重构。并且 IDE 也不能建议第三方模块的接口。 Javascript 程序员必须查找其他人的代码才有意义。 Java有可以自省的jar文件。静态类型语言具有所有这些优点。

虽然我很欣赏您的回答的严谨和热情，但我认为不一定非要成为 n00b 才能欣赏为静态分析而设计的语言之美。也许解决这个问题的一种方法是将您与狗相关的文书工作（元数据）进行类比。假设文书工作提供了对狗进行的医疗治疗清单。当然，这些信息对于您的狗成为狗来说不是必需的。但它可以让兽医在下次治疗您的狗时有所帮助。

clone 绝对是一个糟糕的词选择。克隆被定义为其他事物的精确副本，而 constructors 或 Object.create 并非如此。没有进行复制。现在回答的措辞方式可能会造成更多混乱。

@Aadit：真的没有必要如此防御。您的回答非常详细，值得投票。我并不是说“链接”应该是“克隆”的替代品，而是它更恰当地描述了对象与其继承的原型之间的联系，无论您是否断言自己对“克隆”一词的定义“ 或不。改不改，完全是你的选择。

【参考方案2】：

请允许我实际回答内联问题。

原型继承具有以下优点：

它更适合动态语言，因为继承与它所处的环境一样动态。（此处对 JavaScript 的适用性应该很明显。）这使您可以像自定义类一样快速地做事而无需大量基础设施代码。 与经典的类/对象二分法方案相比，实现原型对象方案更容易。 它无需像“元类”（我从不喜欢我喜欢的元类......对不起！）或“特征值”等对象模型周围的复杂锐边。

但它有以下缺点：

类型检查原型语言并非不可能，但非常非常困难。大多数原型语言的“类型检查”都是纯运行时“鸭子类型”式检查。这并不适合所有环境。 通过静态（或者，通常甚至是动态！）分析来优化方法分派之类的事情同样困难。它可以（我强调：可以）很容易变得非常低效。 类似地，在原型语言中创建对象可能（而且通常是）比在更传统的类/对象二分法方案中要慢得多。

我想你可以从上面的字里行间找出相应的传统类/对象方案的优缺点。当然，每个区域都有更多内容，所以我将剩下的留给其他人回答。

【讨论】：

嘿看，一个简洁的答案，不***。真希望这是该问题的最佳答案。

我们今天有动态即时编译器，可以在代码运行时编译代码，为每个部分创建不同的代码片段。 JavaScript 实际上比使用经典类的 Ruby 或 Python 更快，因此即使您使用原型也是如此，因为在优化它方面已经做了大量工作。

这肯定是最佳答案。

【参考方案3】：

IMO 原型继承的主要好处是它的简单性。

语言的原型性质可能会使受过经典训练的人感到困惑，但事实证明这是一个真正简单而强大的概念，differential inheritance。

您不需要进行分类，您的代码更小，冗余更少，对象继承自其他更通用的对象。

如果您以原型的方式思考，您很快就会注意到您不需要类...

原型继承在不久的将来会更加流行，ECMAScript 5th Edition 规范引入了Object.create 方法，它允许您以非常简单的方式生成从另一个继承的新对象实例：

var obj = Object.create(baseInstance);

这个新版本的标准正在被所有浏览器供应商实施，我想我们会开始看到更多纯粹的原型继承......

【讨论】：

“你的代码更小，冗余更少……”，为什么？我已经查看了“差异继承”的***链接，没有任何东西支持这些断言。为什么经典继承会导致更大、更冗余的代码？

没错，我同意诺埃尔的观点。原型继承只是完成工作的一种方式，但这并不是正确的方式。对于不同的工作，不同的工具将以不同的方式执行。原型继承有它的位置。这是一个非常强大和简单的概念。话虽如此，缺乏对真正封装和多态性的支持使 JavaScript 处于显着劣势。这些方法的存在时间比 JavaScript 长得多，而且它们的原则是合理的。所以认为原型“更好”完全是错误的心态。

您可以使用基于原型的继承来模拟基于类的继承，反之则不行。这可能是一个很好的论据。此外，我将封装更多地视为一种约定而不是语言功能（通常您可以通过反射打破封装）。关于多态性-您所获得的只是在检查方法参数时不必编写一些简单的“if”条件（如果在编译期间解决了目标方法，则速度会有所提高）。这里没有真正的 JavaScript 缺点。

【参考方案4】：

这两种方法之间确实没有太多选择。要掌握的基本思想是，当 JavaScript 引擎被赋予要读取的对象的属性时，它首先检查实例，如果该属性缺失，它会检查原型链。这是一个显示原型和经典之间区别的示例：

原型

var single =  status: "Single" ,
    princeWilliam = Object.create(single),
    cliffRichard = Object.create(single);

console.log(Object.keys(princeWilliam).length); // 0
console.log(Object.keys(cliffRichard).length); // 0

// Marriage event occurs
princeWilliam.status = "Married";

console.log(Object.keys(princeWilliam).length); // 1 (New instance property)
console.log(Object.keys(cliffRichard).length); // 0 (Still refers to prototype)

带有实例方法的经典（效率低下，因为每个实例都存储自己的属性）

function Single() 
    this.status = "Single";


var princeWilliam = new Single(),
    cliffRichard = new Single();

console.log(Object.keys(princeWilliam).length); // 1
console.log(Object.keys(cliffRichard).length); // 1

高效经典

function Single() 


Single.prototype.status = "Single";

var princeWilliam = new Single(),
    cliffRichard = new Single();

princeWilliam.status = "Married";

console.log(Object.keys(princeWilliam).length); // 1
console.log(Object.keys(cliffRichard).length); // 0
console.log(cliffRichard.status); // "Single"

如您所见，由于可以操作以经典样式声明的“类”的原型，因此使用原型继承确实没有任何好处。它是经典方法的一个子集。

【讨论】：

查看有关此主题的其他答案和资源，您的答案似乎是：“原型继承是添加到 JavaScript 以允许出现经典继承的语法糖的子集”。 OP 似乎在询问 JS 中的原型继承相对于其他语言中的经典继承的好处，而不是比较 JavaScript 中的实例化技术。

【参考方案5】：

Web 开发：原型继承与经典继承

http://chamnapchhorn.blogspot.com/2009/05/prototypal-inheritance-vs-classical.html

经典与原型继承 - 代码日志

Classical Vs prototypal inheritance

【讨论】：

我认为最好总结链接的内容而不是粘贴链接（我自己曾经这样做过），除非它是另一个 SO 链接。这是因为链接/网站出现故障，您会失去对问题的回答，这可能会影响搜索结果。

第一个链接没有回答为什么原型继承的问题？它只是描述它。