Typoskript Mehrfachvererbung

Ich bin Notwendigkeit von Mehrfachvererbung in Typoskript.
Logisch ist es nicht ratsam, eine Menge von Funktionen zur Hierarchie.
Ich habe eine base-Klasse und die Anzahl der Hierarchie-Zweige.
Aber ich brauche irgendwie zu verwenden, Mischungen, einige der Haupt-Logik in separate Klassen, cuz es ist nicht in jeder Filiale.

UPDATE von exmple-code:

function Mixin = function(mixins:any[]){ //mixin decorator
    return function(target){
        mixins.forEach((mixin) => {
            add every function from mixing to target prototype, 
            if functions with same name does not exists there,
            so we are able to do calls to as example different render() functions   

            Will show it in OpenableItem        
        });
    }
}

function element = function(){
    return function(target){
        target.prototype.element = function(){
            return this.$el;
        }
    }
}
--------------------------------------------------------------------------------------
@element //every item will have this function as Root as Openable
class BaseItem{
    y() => number; //we need to get y position of every item
}
OpenableMixin{
    render() => render arrow only
    open(){} => change arrow position and cause menu to fire change event
    close(){} => change arrow position and cause menu to fire change event
}
class ItemsMixin extends OpenableMixing{//for now if item have childs it must be openable, 
                    //but Responsive has only tasks and must be openable too
    addItem(item: BaseItem) //need to add generics
    removeItem(item: BaseItem)  
}
--------------------------------------------------------------------------------------
@Mixin([ItemsMixin, ActivitiesMixin]) //it can have items and activities
class OpenableItem extends BaseItem implement ItemsMixin, ActivitiesMixin { //as in typescript docs
    render(){
        //call rendering from BaseItem class
        super.render();
        //call rendering from OpenableMixing
        OpenableMixin.prototype.render.call(this);
        //do some separate rendering for OpenableItem only
        this.$el.append('line');
    }   
}

@Mixin([ItemsMixin]) //it can have items
class RootItem extends BaseItem implement ItemsMixin{ //and subitems functionality is only for Root class
    subitems: Array<BaseItem> //need to add generics to be able to put here different item types
}
--------------------------------------------------------------------------------------
@element
class Menu{
    items: Array<Item>
}

@element
class Timeline{
    menu: Menu
    listAllelement() => {
        console.log(this.element());
        console.log(this.menu.element());
        this.menu.items.forEach((item) => {
            console.log(item.element());
            if(item.hasChilds()){  //really it must be (item instanceof RootItem || item instanceof OpenableItem)
                item.items.forEach((subitem) => { //really we need some recursion here
                    console.log(subitem.element());
                })
            }
        })
    }
}

In der Realität ist es selten die situation, wenn Sie brauchen, um zu implementieren, mehrfache Vererbung, und es ist sehr selten, wenn Sie haben können, wie ein Problem in javascript. Aber jedes Element können verschiedene Funktionen je nach Bedarf.

Nur vorstellen, dass es verschiedene Elemente die Anzahl von Mixins in Verbindung. Ist es klug, um alles in base ? Und was ist Ihre Herangehensweise an dieses Problem ?

Imo sollte man verwenden für DI..
Obwohl die Idee der Mehrfachvererbung oft abgewiesen in OOP, es ist nicht wirklich eine Verletzung von Prinzip, es ist nur so, dass es nicht trivial zu implementieren ist und dass wir lernen, dass es einfach eine blöde Idee sowieso. In der Realität, alle Elemente, die kategorisiert werden können in vielen verschiedenen unabhängigen Abstraktionen, und ich denke, es wäre nett zu haben, eine erstklassige Unterstützung für diese Art der strukturellen Organisation in einer Sprache.
Sorry, ich bin nicht sicher, wie DI helfen kann, in einer solchen situation, aber code-Beispiel wird aktualisiert.
Ich hatte die situation, wenn mehrfache Vererbung war, eine gute Lösung für kleine python-Skript. Und ich war nicht der Verwendung in javascript vor. Aber in meinem Fall habe ich viele verschiedene Kinder, die müssen separate Funktionalität nicht nur beim Rendern, aber in subscribtions zu event-Strahler und eine Menge anderer Dinge. Ich war auf der Suche nach anderen Lösungen, aber Mixins in Verbindung zu sein scheint, mehr logische hier.
Ich hasse Microsoft für nicht hinzufügen, das ich wirklich tun; ich habe eine Menge von code-Duplizierung Dank nicht mit einem straight-forward Weg, dies zu tun.

InformationsquelleAutor Vayrex | 2016-11-25

Schreibe einen Kommentar