Question

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

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); }

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

Answer 1

如果你的功能确实做同样的事情，那么它就像这样简单：

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.放回someFoo 1}}和someBar。

JavaScript DRY对象构造函数

1 个答案: