组合/继承/工厂 - 本案例的最佳模式(Composition/Inheritance/Factory - Best Pattern For This Case)

 好[your_time_of_day]， 
 
 今天我一直在学习javascript（es6）中的构图和工厂函数。 我知道组合应该优于继承并且已经同意（至少在javascript中）。 然后，我意识到我有一种情况，我应该使用作文...... 
 
 问题第一： 
 
 有没有办法可以改变我复杂的，继承的结构，所以类是由函数组成而没有荒谬的装饰器数量？ 我是否错过了一般的构图（我觉得我有）？ 
 
 情况 
 
 我有一个基类AudioPlayer： 
 
class BaseAudioPlayer {
    public track;
    protected seekBar;

    public togglePlay() {
        //
    }

    public seek(time) {
       //some seek methods using this.seekBar
    }
}
 
 一些玩家类会从这样延伸： 
 
class MainAudioPlayer extends BaseAudioPlayer {
    public loadTrack(track) {
        //This is horrible
        this.track = track;
    }

    public setSeekBar(seekBar) {
        //This is horrible
        this.seekBar = seekBar
    }
}
 
 请记住，我实际上在父类和子类中有更多的方法，并且在一些孩子中有许多方法不在其他孩子中。 当然，没有涉及多重继承但我在某些时候看到可能成为多个相似的儿童玩家的可能性（糟糕！）。 
 
 我可以使用许多装饰器，如@playable() @seekable()等，但后来我看到，最终，mixin的数量会变得很大。 我想我也可以以类似的方式使用工厂功能，但看到同样的问题。 
 
 完全披露 ：我正在使用Angular2并且已经削减了很多代码以便继续讨论使用哪种设计模式而不是特定框架中的实现。 
 
 更新1： 
 
 正如@JocelynLecomte评论的那样，我的问题可能不清楚。 
 
 
 
 MainAudioPlayer（和其他播放器）继承自BaseAudioPlayer，因为所有音频播放器必须具有togglePlay ， seek和一些其他方法（特定于angular2，因此不包括在内）。 
 
 
 目前，有三个类继承自BaseAudioPlayer：MainAudioPlayer，DetailAudioPlayer和CardAudioPlayer。 将来可能会有更多，每个都有自己的具体方法。 
 
 
 继承用于避免重复，所有玩家都是 BaseAudioPlayers。 但是，所有玩家也都有 togglePlay和seek方法。 
 
 
 我想使用合成，因为我可以看到一个玩家没有seek方法的可能性，或者将来会出现这种情况。 
 
 
 似乎使用合成将导致所有玩家类中的大量锅炉板代码，我想避免这种情况。 
 
  
 
   
 可以有很多装饰器（ @playable ， @seekable ） 
 
   
 可以使用基本播放器服务（如@amuse的答案）并具有冗余方法。 
 
  
 

Good [your_time_of_day],
 
Today I have been learning about composition and factory functions in javascript (es6). I understand that composition should be preferred over inheritance and have come to agree with that (at least in javascript). Then, I realised that I have a situation where I should be using composition...
 
Question first:
 
Is there a way I can change my complex, inherited structure so classes are composed of functions without having ridiculous numbers of decorators? Have I missed something about composition in general (I feel like I have)?
 
Situation
 
I have a base class AudioPlayer:
 
class BaseAudioPlayer {
    public track;
    protected seekBar;

    public togglePlay() {
        //
    }

    public seek(time) {
       //some seek methods using this.seekBar
    }
}
 
And a few player classes would extend from this like so:
 
class MainAudioPlayer extends BaseAudioPlayer {
    public loadTrack(track) {
        //This is horrible
        this.track = track;
    }

    public setSeekBar(seekBar) {
        //This is horrible
        this.seekBar = seekBar
    }
}
 
Please bare in mind I actually have a lot more methods in parent and child classes and there are many methods in some children that are not in others. Of course, there is no multiple inheritance involved but I see at some point that might become a possibility with multiple alike child players (bad!).
 
I could use many decorators like @playable() @seekable() etc. but then I see that, eventually, the number of mixins would become huge. I guess I could also use factory functions in a similar manner but see the same problem. 
 
Full disclosure: I am using Angular2 and have cut back the code a lot to keep any discussion about which design pattern to use and not about an implementation in a specific framework.
 
Update 1:
 
As @JocelynLecomte commented, my question may be unclear.
 
 
 
The MainAudioPlayer (and other players) inherit from BaseAudioPlayer since all audio players must have togglePlay, seek, and a few other methods (angular2 specific so not included here).
 
 
Currently, there are three classes that inherit from BaseAudioPlayer: MainAudioPlayer, DetailAudioPlayer and CardAudioPlayer. In the future there may be more and each has there own specific methods. 
 
 
Inheritance was used to avoid duplication and all players are BaseAudioPlayers. However, all players also have togglePlay and seek methods.
 
 
I'd like to use composition since I could see a possibility of a player that does not have a seek method or something along those lines in the future. 
 
 
It seems to that using composition would lead to a lot of boiler plate code in all player classes and I'd like to avoid this.
 
  
 
   
Could have many decorators (@playable, @seekable)
 
   
Could use a base player service (as in @amuse 's answer) and have redundant methods.
 
  
 

原文：https://stackoverflow.com/questions/40895466