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

Question

注意:

正如答案所说,由于问题和我的评论中描述的一些问题,问题中提出的代码并没有真正实现继承(否则它会成为答案而不是问题......).它可以像预期的那样继承假(甚至不是原型).

---

• 摘要

  简而言之,使它类似于我们编写一般的OO语言而不是javascript,但保持继承是正确的.

• 故事

  的Object.create是实现原型继承的好方法,但它是一个有点混乱,以一个类型的大脑和新的球迷.

  我们可以通过各种方式编写javascript代码,就像我们使用伪经典模式编写其他OO语言一样.因为它是伪经典的,我们必须正确处理javascript的底层原型继承.

  我想要找到的是一种可以在类声明上实现伪古典继承的方法.演示代码放在帖子的后面,它按预期工作,但是,有一些烦人的事情:

  1. 我无法摆脱return类声明或继承不起作用.

  2. 除了传入this类声明以使返回的闭包知道是什么,我没办法this.

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

  4. 不继承类的静态(自己的属性).

  解决方案比现有框架更多的是一些语法糖,一个好的模式是适用的.

---

该_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中的类,那么有很多库可以提供给你.例如,使用扩充,您可以重新构建代码,如下所示:

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中的经典继承.如果这解决了你的问题,太好了!如果不是那么继续阅读.

原型类同构

在很多方面,原型与类相似.事实上,原型和类是如此相似,我们可以使用原型来建模类.首先让我们来看看原型继承是如何工作的:

以上图片取自以下答案.我建议你仔细阅读.该图显示了我们:

1. 每个构造函数都有一个名为property的属性prototype,该属性指向构造函数的原型对象.
2. 每个原型都有一个属性constructor,该属性指向原型对象的构造函数.
3. 我们从构造函数创建一个实例.但是实例实际上继承自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 实现继承:

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;
}

这告诉我们,一旦我们有了一个原型对象,我们需要做的就是获取它的构造函数属性并返回它.

增强的前三行用于:

1. 获取基类原型.
2. 使用创建派生类原型Object.create.
3. 使用指定的属性填充派生类原型.

这就是JavaScript中继承的全部内容.如果你想创建自己的经典继承模式,那么你应该考虑相同的思路.

拥抱真正的原型继承

每个值得他们盐的JavaScript程序员都会告诉你原型继承比经典继承更好.然而,来自具有经典继承的语言的新手总是试图在原型继承之上实现经典继承,并且它们通常会失败.

它们失败并不是因为它不可能在原型继承之上实现经典继承,而是因为要在原型继承之上实现经典继承,首先需要了解真正的原型继承是如何工作的.

然而,一旦你理解了真正的原型继承,你就永远不会想要回到古典继承.我也试过来实现对原型继承作为一个新手的顶部经典的继承.既然我理解了真正的原型继承是如何工作的,那么我编写这样的代码:

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.但是,它不返回构造函数,而是返回原型对象.这实际上是一个非常巧妙的技巧,它允许继承静态属性.您可以使用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它不会返回构造函数.它返回原型对象.这意味着您无法使用该new关键字来创建该类的实例.相反,您需要使用new如下方法:

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

这实际上是件好事.该new关键字被视为 有害,我强烈建议您停止使用它.例如它无法使用apply与new关键字.然而,可以使用apply与new如下方法:

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

由于Abc和Xyz不是构造函数,我们不能instanceof用来测试对象是否是Abc或的实例Xyz.然而,这不是问题,因为JavaScript有一个方法isPrototypeOf,用于测试对象是否是另一个对象的原型:

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/

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

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是我们可以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/