Uwaga:

Jak mówią odpowiedzi, kod zaproponowany w pytaniu takNIE naprawdę osiągnąć dziedziczenie (inaczej staje się odpowiedzią, a nie pytaniem ..) ze względu na pewne problemy opisane w pytaniu iw moich komentarzach. Działa zgodnie z oczekiwaniamipodróbka dziedziczenie (a nawet prototyp).

streszczenie

W skrócie, uczyń to tak podobnym, jak piszemy ogólny język OO, a nie javascript, ale zachowaj poprawność dziedziczenia.

Historia

Object.create to dobry sposób na osiągnięcie prototypowego dziedziczenia, ale jest to trochę mylące dla awpisane mózg iNowy Fani.

Istnieje wiele sposobów, dzięki którym możemy napisać kod javascript bardziej, jak piszemy inne języki OO ze wzorem pseudoklasycznym. Jak to jestrzekomy-klasyczny, musimy poprawnie zająć się prototypowym dziedziczeniem javascript.

Chcę znaleźć podejście, dzięki któremu można osiągnąć pseudoklasyczne dziedzictwoprawo na deklaracji klasy. Kod demonstracyjny jest umieszczony z tyłu posta, działa zgodnie z oczekiwaniami, jednak są pewne irytujące rzeczy:

Nie mogę się pozbyćreturn w deklaracji klasy lub dziedziczenie nie będzie działać.

Nie mam innego wyjścia, jak tylko przejśćthis w deklaracji klasy, aby powracające zamknięcie wiedziało cothis.

Chcę też się pozbyćfunction (instance, _super) {, ale jeszcze nie mam dobrego pomysłu.

Thestatyczny(Własne właściwości) klasy nie są dziedziczone.

Rozwiązaniem byłoby więcej cukru syntaktycznego niż istniejące ramy, dobry wzór ma zastosowanie.

The_extends funkcjonować:

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

TheAbc klasa:

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

TheXyz klasa:

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

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

Przykładowy kod:

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