0

我有一个看起来像这样的对象：

var myObj = {
  _fooCon: function(f) {
             if (typeof f != 'function') throw new TypeError('Bad Foo');
             this.fn = f;
           },

  _barCon: function(f) {
             if (typeof f != 'function') throw new TypeError('Bad Bar');
             this.fn = f;
           },

  someFoo: function(v) {
             return new this._fooCon(function(x) {
               return x + ' Foo ' + v;
             });
           },

  someBar: function(v) {
             return new this._barCon(function(x) {
               return x + ' Bar ' + v;
             });
           }
};

这样做的原因是我可以instanceof高效地使用（即，我可以区分在不同场景中使用的两个对象，尽管它们在结构上是相同的）。someFoo（忽略和someBar相似的事实！）

有没有办法可以抽象构造函数，所以如果我需要创建，比如说，_bazCon我不需要重复自己；或者，如果有错误，我不必修复每个构造函数定义？

我试着做一个工厂成员，像这样：

_factory: function(type, f) {
            if (typeof f != 'function') throw new TypeError('Bad ' + type);
            this.fn = f;
          }

...然后：

_fooCon: function(f) { return new this._factory('Foo', f); }

即使不尝试这个，我也可以看到它不起作用！关于如何实现我正在寻找的任何想法？

4

1 回答 1

2

如果你的函数真的做同样的事情，那么它就像这样简单：

var myObj = {
  _factory: function(err) {
                return function(f) {
                    if (typeof f != 'function') throw new TypeError('Bad ' + err);
                    this.fn = f;
                };
            },
  someFoo: function(v) {
             return new this._fooCon(function(x) {
               return x + ' Foo ' + v;
             });
           },

  someBar: function(v) {
             return new this._barCon(function(x) {
               return x + ' Bar ' + v;
             });
           }
};

myObj._fooCon = myObj._factory("Foo");
myObj._barCon = myObj._factory("Bar");

如果还有其他行为可以区分它们，那么您可能会_factory收到一个在构造函数中调用的函数参数。该函数可以使用.call或.apply设置this正在构造的对象的值。

另一种方法是使用构造函数来创建myObj，并利用变量范围，这样您就不需要公开_xxxCon构造函数。

这使用匿名函数作为构造函数，因为我们不再需要它。

var myObj = new function() {
    var _factory = function(err) {
                return function(f) {
                    if (typeof f != 'function') throw new TypeError('Bad ' + err);
                    this.fn = f;
                };
            };

    var _fooCon = _factory("Foo");
    var _barCon = _factory("Bar");

    this.someFoo = function(v) {
             return new _fooCon(function(x) {
               return x + ' Foo ' + v;
             });
           },

    this.someBar = function(v) {
             return new _barCon(function(x) {
               return x + ' Bar ' + v;
             });
           }
};

您不一定需要将外部函数用作构造函数，但您确实需要一个将对象返回到myObj.

如果您确实想公开这些_xxxCon功能，请更改var为this., 并将this.后面放入someFooand someBar。

于 2013-01-19T18:49:09.857 回答