JavaScript 中的特征

Question

Closed. This question needs to be more focused. It is not currently accepting answers.

---

想要改进这个问题吗？通过编辑这篇文章来更新问题，使其仅关注一个问题。

9 年前已关闭。

社区去年审查了是否重新开放此问题，并将其关闭：

原始关闭原因未解决

Answer 1

function Trait (methods) {
  this.traits = [methods];
};

Trait.prototype = {
    constructor: Trait

  , uses: function (trait) {
      this.traits = this.traits.concat (trait.traits);
      return this;
    }

  , useBy: function (obj) {
      for (var i = 0; i < this.traits.length; ++i) {
        var methods = this.traits [i];
        for (var prop in methods) {
          if (methods.hasOwnProperty (prop)) {
            obj [prop] = obj [prop] || methods [prop];
          }
        }
      }
    }
};

Trait.unimplemented = function (obj, traitName) {
  if (obj === undefined || traitName === undefined) {
    throw new Error ("Unimplemented trait property.");
  }
  throw new Error (traitName + " is not implemented for " + obj);
};

例子：

var TEq = new Trait ({
    equalTo: function (x) {
      Trait.unimplemented (this, "equalTo");
    }

  , notEqualTo: function (x) {
      return !this.equalTo (x);
    }
});

var TOrd = new Trait ({
    lessThan: function (x) {
      Trait.unimplemented (this, "lessThan");
    }

  , greaterThan: function (x) {
      return !this.lessThanOrEqualTo (x);
    }

  , lessThanOrEqualTo: function (x) {
      return this.lessThan (x) || this.equalTo (x);
    }

  , greaterThanOrEqualTo: function (x) {
      return !this.lessThan (x);
    }
}).uses (TEq);


function Rational (numerator, denominator) {
  if (denominator < 0) {
    numerator *= -1;
    denominator *= -1;
  }
  this.numerator = numerator;
  this.denominator = denominator;
}

Rational.prototype = {
    constructor: Rational

  , equalTo: function (q) {
      return this.numerator * q.numerator === this.denominator * q.denominator;
    }

  , lessThan: function (q) {
      return this.numerator * q.denominator < q.numerator * this.denominator;
    }
};

TOrd.useBy (Rational.prototype);

var x = new Rational (1, 5);
var y = new Rational (1, 2);

[x.notEqualTo (y), x.lessThan (y)]; // [true, true]

Answer 2

有不同的方法，同时也有生产就绪的库。

Mixin 是跨类层次结构的代码重用的最古老的形式。它们需要按线性顺序组成，因为 Mixin 的概念不涵盖/识别冲突解决功能。

特征是代码重用的细粒度单元，也适用于类级别；但它们更加灵活，因为 Traits 必须提供用于组合、排除或别名方法的组合运算符。

我确实建议阅读两篇论文，它们都涵盖了与库无关的基于纯函数的 Mixins / Traits / Talents 方法。

1. 重新审视 JavaScript Mixins作者：Angus Croll，2011 年 5 月
2. JavaScript 的众多才华，用于概括 2014 年 4 月的 Traits 和 Mixins 等面向角色的编程方法。

纯函数基于委托的 mixin 机制与接下来的 2 个给定示例一样简单......

var Enumerable_first = function () {
  this.first = function () {
    return this[0];
  };
};
var list = ["foo", "bar", "baz"];

console.log("(typeof list.first)", (typeof list.first)); // "undefined"

Enumerable_first.call(list); // explicit delegation

console.log("list.first()", list.first()); // "foo"

第一个示例作用于“实例”级别，第二个示例覆盖“类”级别......

var Enumerable_first_last = function () {
  this.first = function () {
    return this[0];
  };
  this.last = function () {
    return this[this.length - 1];
  };
};
console.log("(typeof list.first)", (typeof list.first));  // "function"   // as expected
console.log("(typeof list.last)", (typeof list.last));    // "undefined"  // of course

Enumerable_first_last.call(Array.prototype);  // applying behavior to [Array.prototype]

console.log("list.last()", list.last());      // "baz"  // due to delegation automatism

如果需要已建立和/或生产就绪的库应该仔细查看

1. traits.js
2. CocktailJS

太长了

附录一

请参阅：

• stackoverflow.com :: 如何在 Javascript 中正确使用 mixins
• stackoverflow.com :: Javascript 特征模式资源

附录二

因为我有时显然在摆弄这个问题，所以我不想添加一些最终的想法......

没有太多粘合代码（如上所述）的库不可知方法仅起作用用于行为重用的非常细粒度的可组合单元。因此，只要不遇到超过 1 或 2 个容易解决的冲突，基于 Angus Croll 的 Flight Mixins 的模式就是可遵循的路径。

如果涉及到真实的特征，就必须有一个抽象层次。该层（例如作为某种语法糖提供，如 DSL）需要隐藏复杂性，例如从特征组合特征或在特征应用时（当特征的行为应用于对象/类型时）解决冲突。

到目前为止，SO 有 3 个例子，从我的角度来看，它们准确地提供了 OP 所要求的内容……

如何在 javascript 中实现特征？

• stackoverflow.com :: JS 中的组合和混合
• stackoverflow.com ： ： ES6 类的 Mixins，用 babel 转译
• stackoverflow .com :: 重构遗留的基于 mixin 的类层次结构
• stackoverflow .com :: 使用类的多重继承

Answer 3

我强烈建议您查看 trait.js 库。他们还有一篇关于一般模式及其具体实现的相当好的文章。我最近将其内置到我的项目中，它的工作就像一个魅力。