Композиция, наследование и агрегация в JavaScript

... Может кто-нибудь дать мне пример, используя приведенный выше код, чтобы продемонстрировать состав и агрегация?

на первый взгляд приведенный пример не кажется лучшим выбор для демонстрации композиции в JavaScript. The prototype свойство Stock функция конструктора по-прежнему остается идеальной место для обоих методов total и list для обоих получите доступ к любому запасу собственные свойства объекта.

что можно сделать развязка реализаций этих методов из прототипа конструкторов и предоставления их обратно точно там - еще в дополнительной форме повторного использования кода-миксины ...

пример:

var Iterable_listAllKeys = (function () {

    var
        Mixin,

        object_keys = Object.keys,

        listAllKeys = function () {
            return object_keys(this).join(", ");
        }
    ;

    Mixin = function () {
        this.list = listAllKeys;
    };

    return Mixin;

}());


var Iterable_computeTotal = (function (global) {

  var
      Mixin,

      currencyFlag,

      object_keys = global.Object.keys,
      parse_float = global.parseFloat,

      aggregateNumberValue = function (collector, key) {
          collector.value = (
              collector.value
              + parse_float(collector.target[key], 10)
          );
          return collector;
      },
      computeTotal = function () {
          return [

              currencyFlag,
              object_keys(this)
                  .reduce(aggregateNumberValue, {value: 0, target: this})
                  .value
                  .toFixed(2)

          ].join(" ");
      }
    ;

    Mixin = function (config) {
        currencyFlag = (config && config.currencyFlag) || "";

        this.total = computeTotal;
    };

    return Mixin;

}(this));


var Stock = (function () {

  var
      Stock,

      object_keys = Object.keys,

      createKeyValueForTarget = function (collector, key) {
          collector.target[key] = collector.config[key];
          return collector;
      },
      createStock = function (config) { // Factory
          return (new Stock(config));
      },
      isStock = function (type) {
          return (type instanceof Stock);
      }
  ;

  Stock = function (config) { // Constructor
      var stock = this;
      object_keys(config).reduce(createKeyValueForTarget, {

          config: config,
          target: stock
      });
      return stock;
  };

  /**
   *  composition:
   *  - apply both mixins to the constructor's prototype
   *  - by delegating them explicitly via [call].
   */
  Iterable_listAllKeys.call(Stock.prototype);
  Iterable_computeTotal.call(Stock.prototype, {currencyFlag: "$"});

  /**
   *  [[Stock]] factory module
   */
  return {
      isStock : isStock,
      create  : createStock
  };

}());


var stock = Stock.create({MSFT: 25.96, YHOO: 16.13, AMZN: 173.10});

/**
 *  both methods are available due to JavaScript's
 *  - prototypal delegation automatism that covers inheritance.
 */
console.log(stock.list());
console.log(stock.total());

console.log(stock);
console.dir(stock);

существует много информации о композиции против наследования онлайн, но я не нашел достойных примеров с JavaScript. ...

Я не нашел много информации о композиции в JavaScript онлайн, только на других языках. ...

возможно, поисковый запрос был недостаточно конкретным, но даже в 2012 году поиск "JavaScript Mixin composition" должен был привести к не такое уж плохое направление.

... Если композиция предпочтительна для многих ситуаций в ООП, как большинство людей, использующих JavaScript, похоже, используют только прототипы а наследство?

потому что большинство из них используют то, что они получили, и / или то, что они знакомы. Может быть, так и должно быть. больше распространение знаний о JavaScript как языке на основе делегирования тоже и что может достигните с ним.

приложение:

это связанные темы, недавно обновленный и, надеюсь, помогает ...

• stackoverflow.com :: как правильно использовать mixins в Javascript
• stackoverflow.com :: черты в javascript
• stackoverflow.com :: Javascript различают состав против наследования

Я думаю, что могу показать вам, как переписать ваш код в моде "композиция объектов", используя простой JavaScript (ES5). Я использую заводские функции вместо функции конструктора для создания экземпляра объекта, поэтому нет new ключевое слово нужно. Таким образом, я могу оказать услугу увеличение объекта (композиция) над классическим/псевдоклассическим/прототипным наследованием, так что нет Object.create вызывается функция.

полученный объект хороший плоский объект:

/*
 * Factory function for creating "abstract stock" object. 
 */
var AbstractStock = function (options) {

  /**
   * Private properties :)
   * @see http://javascript.crockford.com/private.html
   */
  var companyList = [],
      priceTotal = 0;

  for (var companyName in options) {

    if (options.hasOwnProperty(companyName)) {
      companyList.push(companyName);
      priceTotal = priceTotal + options[companyName];
    }
  }

  return {
    /**
     * Privileged methods; methods that use private properties by using closure. ;)
     * @see http://javascript.crockford.com/private.html
     */
    getCompanyList: function () {
      return companyList;
    },
    getPriceTotal: function () {
      return priceTotal;
    },
    /*
     * Abstract methods
     */
    list: function () {
      throw new Error('list() method not implemented.');
    },
    total: function () {
      throw new Error('total() method not implemented.');
    }
  };
};

/*
 * Factory function for creating "stock" object.
 * Here, since the stock object is composed from abstract stock
 * object, you can make use of properties/methods exposed by the 
 * abstract stock object.
 */
var Stock = compose(AbstractStock, function (options) {

  return {
    /*
     * More concrete methods
     */
    list: function () {
      console.log(this.getCompanyList().toString());
    },
    total: function () {
      console.log('$' + this.getPriceTotal());
    }
  };
});

// Create an instance of stock object. No `new`! (!)
var portofolio = Stock({MSFT: 25.96, YHOO: 16.13, AMZN: 173.10});
portofolio.list(); // MSFT,YHOO,AMZN
portofolio.total(); // 5.19

/*
 * No deep level of prototypal (or whatsoever) inheritance hierarchy;
 * just a flat object inherited directly from the `Object` prototype.
 * "What could be more object-oriented than that?" –Douglas Crockford
 */ 
console.log(portofolio); 



/*
 * Here is the magic potion:
 * Create a composed factory function for creating a composed object.
 * Factory that creates more abstract object should come first. 
 */
function compose(factory0, factoryN) {
  var factories = arguments;

  /*
   * Note that the `options` passed earlier to the composed factory
   * will be passed to each factory when creating object.
   */
  return function (options) {

    // Collect objects after creating them from each factory.
    var objects = [].map.call(factories, function(factory) {
      return factory(options);
    });

    // ...and then, compose the objects.
    return Object.assign.apply(this, objects);
  };
};

Скрипка здесь.