javascript - 如何在类声明上实现伪经典继承？

Question

注意:

正如答案所言，由于问题和我的评论中描述的一些问题，问题中提出的代码确实 NOT 真正实现了继承(否则它将成为答案而不是问题 .. )。它按预期工作 是 继承的假冒(甚至不是原型(prototype))。

摘要

简而言之，让它像我们正在编写一种通用的 OO 语言而不是 javascript 一样，但要保持继承是正确的。

故事

Object.create 是实现原型(prototype)继承的好方法，但对于 类型的 大脑和 新 粉丝来说有点困惑。

我们可以通过多种方式编写 javascript 代码，更像是使用伪经典模式编写其他 OO 语言。由于它是 伪 -经典，我们必须正确处理 javascript 的底层原型(prototype)继承。

我想找到一种方法，可以在类声明 上实现伪经典继承 。演示代码放在帖子后面，按预期运行，但是有一些烦人的地方:

我无法摆脱类声明中的 return 或继承不起作用。

除了在类声明中传递 this 以使返回的闭包知道什么是 this 之外，我别无他法。

我也想摆脱 function (instance, _super) { ，但还没有一个好主意。

类的静态(自己的属性)没有被继承。

与现有框架相比，解决方案更多的是一些语法糖，一个好的模式是适用的。
_extends 函数:

function _extends(baseType) {
    return function (definition) {
        var caller=arguments.callee.caller;
        var instance=this;

        if(!(instance instanceof baseType)) {
            (caller.prototype=new baseType()).constructor=caller;
            instance=new caller();
        }

        var _super=function () {
            baseType.apply(instance, arguments);
        };

        definition(instance, _super);
        return instance;
    };
}

Abc 类:

function Abc(key, value) {
    return _extends(Object).call(this, function (instance, _super) {
        instance.What=function () {
            alert('What');
        };

        instance.getValue=function () {
            return 333+Number(value);
        };

        instance.Value=instance.getValue();
        instance.Key=key;
    });
}

Xyz 类:

function Xyz(key, value) {
    return _extends(Abc).call(this, function (instance, _super) {
        _super(key, value);

        instance.That=function () {
            alert('That');
        };
    });
}

示例代码:

var x=new Xyz('x', '123');
alert([x.Key, x.Value].join(': ')+'; isAbc: '+(x instanceof Abc));

var y=new Xyz('y', '456');
alert([y.Key, y.Value].join(': ')+'; isAbc: '+(y instanceof Abc));

var it=new Abc('it', '789');
alert([it.Key, it.Value].join(': ')+'; isAbc: '+(it instanceof Abc));
alert([it.Key, it.Value].join(': ')+'; isXyz: '+(it instanceof Xyz));

x.What();
y.That();

it.What();
it.That(); // will throw; it is not Xyz and does not have That method

Answer 1

不。不。不。这不行。你在 JavaScript 中做继承都是错误的。你的代码让我偏头痛。

在 JavaScript 中创建伪经典继承模式

如果您想要类似于 JavaScript 中的类的东西，那么有很多库可以为您提供。例如，使用 augment 您可以按如下方式重构代码:

var augment = require("augment");

var ABC = augment(Object, function () {
    this.constructor = function (key, value) {
        this.key = key;
        this.value = value;
    };

    this.what = function () {
        alert("what");
    };
});

var XYZ = augment(ABC, function (base) {
    this.constructor = function (key, value) {
        base.constructor.call(this, key, value);
    };

    this.that = function () {
        alert("that");
    };
});

我不了解你，但对我来说这看起来很像 C++ 或 Java 中的经典继承。如果这解决了您的问题，那就太好了!如果不是，则继续阅读。

原型(prototype)类同构

在很多方面，原型(prototype)类似于类。事实上，原型(prototype)和类是如此相似，以至于我们可以使用原型(prototype)来为类建模。首先让我们看看 how prototypal inheritance really works :



上图来自 following answer 。我建议你仔细阅读。该图向我们展示了:

每个构造函数都有一个名为 prototype 的属性，它指向构造函数的原型(prototype)对象。

每个原型(prototype)都有一个名为 constructor 的属性，它指向原型(prototype)对象的构造函数。

我们从构造函数创建一个实例。然而，该实例实际上继承自 prototype ，而不是构造函数。

这是非常有用的信息。传统上，我们总是先创建一个构造函数，然后设置它的 prototype 属性。然而，这些信息告诉我们，我们可以先创建一个原型(prototype)对象，然后在其上定义 constructor 属性。

例如，传统上我们可以这样写:

function ABC(key, value) {
    this.key = key;
    this.value = value;
}

ABC.prototype.what = function() {
    alert("what");
};

然而，使用我们新发现的知识，我们可能会写出同样的东西:

var ABC = CLASS({
    constructor: function (key, value) {
        this.key = key;
        this.value = value;
    },
    what: function () {
        alert("what");
    }
});

function CLASS(prototype) {
    var constructor = prototype.constructor;
    constructor.prototype = prototype;
    return constructor;
}

如您所见，在 JavaScript 中很容易实现封装。您需要做的就是横向思考。然而，继承是一个不同的问题。您需要做更多的工作来实现继承。

继承与超

看看如何 augment achieves inheritance :

function augment(body) {
    var base = typeof this === "function" ? this.prototype : this;
    var prototype = Object.create(base);
    body.apply(prototype, arrayFrom(arguments, 1).concat(base));
    if (!ownPropertyOf(prototype, "constructor")) return prototype;
    var constructor = prototype.constructor;
    constructor.prototype = prototype;
    return constructor;
}

请注意，最后三行与上一节中的 CLASS 相同:

function CLASS(prototype) {
    var constructor = prototype.constructor;
    constructor.prototype = prototype;
    return constructor;
}

这告诉我们，一旦我们有了原型(prototype)对象，我们需要做的就是获取它的构造函数属性并返回它。

增强的前三行用于:

获取基类原型(prototype)。

使用 Object.create 创建派生类原型(prototype)。

使用指定的属性填充派生类原型(prototype)。

这就是 JavaScript 中继承的全部内容。如果您想创建自己的经典继承模式，那么您应该按照相同的思路思考。

拥抱真正的原型(prototype)继承

每个称职的 JavaScript 程序员都会告诉你 prototypal inheritance is better than classical inheritance 。尽管如此，来自具有经典继承的语言的新手总是试图在原型(prototype)继承之上实现经典继承，但他们通常会失败。

它们失败并不是因为不可能在原型(prototype)继承之上实现经典继承，而是因为要在原型(prototype)继承之上实现经典继承，您首先需要了解 true prototypal inheritance works 是如何实现的。

然而，一旦你理解了真正的原型(prototype)继承，你就再也不想回到经典继承了。作为新手，我也喜欢 tried 到 implement 在原型(prototype)继承之上的经典继承。现在我了解了真正的原型(prototype)继承是如何工作的，但是我编写了这样的代码:

function extend(self, body) {
    var base = typeof self === "function" ? self.prototype : self;
    var prototype = Object.create(base, {new: {value: create}});
    return body.call(prototype, base), prototype;

    function create() {
        var self = Object.create(prototype);
        return prototype.hasOwnProperty("constructor") &&
            prototype.constructor.apply(self, arguments), self;
    }
}

上面的 extend 函数与 augment 非常相似。然而，它没有返回构造函数，而是返回原型(prototype)对象。这实际上是一个非常巧妙的技巧，它允许继承静态属性。您可以使用 extend 创建一个类，如下所示:

var Abc = extend(Object, function () {
    this.constructor = function (key, value) {
        this.value = 333 + Number(value);
        this.key = key;
    };

    this.what = function () {
        alert("what");
    };
});

继承同样简单:

var Xyz = extend(Abc, function (base) {
    this.constructor = function (key, value) {
        base.constructor.call(this, key, value);
    };

    this.that = function () {
        alert("that");
    };
});

但是请记住 extend 不返回构造函数。它返回原型(prototype)对象。这意味着您不能使用 new 关键字来创建类的实例。相反，您需要使用 new 作为方法，如下所示:

var x = Xyz.new("x", "123");
var y = Xyz.new("y", "456");
var it = Abc.new("it", "789");

这其实是一件好事。 new 关键字是 considered harmful ，我强烈建议您使用 stop using it 。例如它是 not possible to use apply with the new keyword 。但是，可以将 apply 与 new 方法一起使用，如下所示:

var it = Abc.new.apply(null, ["it", "789"]);

由于 Abc 和 Xyz 不是构造函数，我们不能使用 instanceof 来测试对象是 Abc 还是 Xyz 的实例。然而这不是问题，因为 JavaScript 有一个名为 isPrototypeOf 的方法，它测试一个对象是否是另一个对象的原型(prototype):

alert(x.key + ": " + x.value + "; isAbc: " + Abc.isPrototypeOf(x));
alert(y.key + ": " + y.value + "; isAbc: " + Abc.isPrototypeOf(y));

alert(it.key + ": " + it.value + "; isAbc: " + Abc.isPrototypeOf(it));
alert(it.key + ": " + it.value + "; isXyz: " + Xyz.isPrototypeOf(it));

事实上 isPrototypeOf 比 instanceof 更强大，因为它允许我们测试一个类是否扩展了另一个类:

alert(Abc.isPrototypeOf(Xyz)); // true

除了这个小改动之外，其他一切都像以前一样:

x.what();
y.that();

it.what();
it.that(); // will throw; it is not Xyz and does not have that method

亲自查看演示:http://jsfiddle.net/Jee96/

真正的原型(prototype)继承还能提供什么？真正原型(prototype)继承的最大优点之一是普通属性和静态属性之间没有区别，允许您编写如下代码:

var Xyz = extend(Abc, function (base) {
    this.empty = this.new();

    this.constructor = function (key, value) {
        base.constructor.call(this, key, value);
    };

    this.that = function () {
        alert("that");
    };
});

请注意，我们可以通过调用 this.new 从类本身创建类的实例。如果 this.constructor 尚未定义，则它返回一个新的未初始化实例。否则它返回一个新的初始化实例。

另外因为 Xyz 是原型(prototype)对象，我们可以直接访问 Xyz.empty (即 empty 是 Xyz 的静态属性)。这也意味着静态属性是自动继承的，与普通属性没有区别。

最后，因为类可以从类定义中作为 this 访问，所以您可以创建嵌套类，这些类继承自嵌套类，使用 extend 如下:

var ClassA = extend(Object, function () {
    var ClassB = extend(this, function () {
        // class definition
    });

    // rest of the class definition

    alert(this.isPrototypeOf(ClassB)); // true
});

亲自查看演示:http://jsfiddle.net/Jee96/1/