Ereditarietà vs mixin in linguaggi dinamici?

Quando dovresti preferire i modelli ereditari rispetto ai mixin in linguaggi dinamici?

Per mixin, intendo il vero e proprio mixaggio, come nell'inserimento di funzioni e membri di dati in un oggetto in fase di esecuzione.

Quando useresti, ad esempio, l'eredità prototipale anziché i mixin? Per illustrare più chiaramente cosa intendo per mixin, alcuni pseudocodici:

asCircle(obj) {
  obj.radius = 0
  obj.area = function() {
    return this.radius * this.radius * 3.14
  }

myObject = {}
asCircle(myObject)
myObject.area() // -> 0

L'eredità prototipica è semplice. Ha un unico vantaggio rispetto ai mixin.

Cioè è un collegamento live. se si modifica il prototipo, tutto ciò che lo eredita viene modificato.

Esempio usando pd

var Circle = {
  constructor: function _constructor() {
    this.radius = 0;
    return this;
  },
  area: function _area() {
    return this.radius * this.radius * Circle.PI
  },
  PI: 3.14
};

var mixedIn = pd.extend({}, Circle).constructor();
var inherited = pd.make(Circle, {}).constructor();

Circle.perimeter = perimeter;

inherited.perimeter(); // wins
mixedIn.perimeter(); // fails

function perimeter() {
  return 2 * this.radius;
}

Quindi, fondamentalmente, se si desidera che le modifiche al cerchio "interfaccia" si riflettano in fase di esecuzione su tutti gli oggetti che "utilizzano" la sua funzionalità, quindi ereditare da esso.

Se non si desidera che le modifiche riflettano, mescolarle.

Nota che i mixin hanno anche più scopo di quello. I mixin sono il tuo meccanismo per molteplici "eredità".

Se si desidera un oggetto di implementare molteplici "interfacce" allora si avrà bisogno di mescolare un po 'in. Quello che si utilizza per l'ereditarietà prototipo è quello che si desidera in modo da riflettere le modifiche per a run-time, gli altri saranno mescolati in.

Il mio senso del cavallo mi dice questo:

• Se qualcosa è utile su più oggetti o gerarchie di classi, trasformalo in un mixin
• Se qualcosa è solo utile lungo una gerarchia singola - utilizzare l'ereditarietà

Note correlate:

• La parola "utile" dovrebbe essere presa metaforicamente
• Per quelle lingue che non hanno ereditarietà multiple, i mixin sono una buona alternativa
• PHP 5.4 introduce tratti che hanno bontà sia dai mixin che dai mondi ereditari multipli

Utilizzare il test "Is-a".

L'ereditarietà è limitata al caso in cui si può dire "Sottoclasse IS A Superclass". Sono lo stesso tipo di cose. "Il formaggio è un prodotto lattiero-caseario".

I mixin sono per tutto il resto. "Il formaggio può essere usato in un panino". Il formaggio non è un panino, ma partecipa al sandwich.

PS. Questo non ha nulla a che fare con i linguaggi dinamici. Qualsiasi linguaggio con ereditarietà multipla con compilazione statica (ad es., C ++) ha lo stesso punto di decisione.

Bene, il miglior esempio che posso darti è un attore per un gioco che ha eredità per alcune cose di base ma usa mixin / plugin per funzionalità condivisa. La funzionalità condivisa potrebbe essere (direttamente dal codice sorgente!):

var plugins = {
    SingleVisualEntity : SingleVisualEntity,
    JumpBehaviour      : JumpBehaviour,
    WeaponBehaviour    : WeaponBehaviour,
    RadarBehaviour     : RadarBehaviour,
    EnergyGatherer     : EnergyGatherer,
    LifeBarPlugin      : LifeBarPlugin,
    SelectionPlugin    : SelectionPlugin,
    UpgradePlugin      : UpgradePlugin,
    BrainPlugin        : BrainPlugin,
    PlanetObjectPlugin : PlanetObjectPlugin,
}