Javascript 使用数组中的参数初始化Mootools类

我有一门课：

var Foo = new Class({
    initialize: function(param1, param2) {
        // do stuff
    }
});

要初始化Foo的值位于数组中：

a = ['value1', 'value2'];

---

如何使用

a

中的值来初始化

Foo

的实例？

没有直接的方法来调用具有要展开的参数数组的构造函数，就像使用

函数那样。应用

如果使用
new Foo（）
创建类的新实例，MooTools将调用构造函数（
initialize
），并隐式传递调用Foo（）的参数。但是，
initialize
仍然作为实例的一个方法存在，所以您可以简单地将其称为“再次”，如下所示：

但这是一种非常糟糕的做法，因为构造函数通常不会被调用两次，而且很可能会遇到问题

另一种方法是创建实例，而不让MooTools调用构造函数。首先需要一个普通实例，然后调用
initialize
作为实例的方法。这是相当骇人听闻的，但可以这样实现：

var Foo = new Class({
    initialize: function(param1, param2) {
        this.param1 = param1;
        this.param2 = param2;
    },
    getParams: function() {
        console.log(this.param1 + ', ' + this.param2);
    }
});

Class.createInstance = function(klass, args) {
    klass.$prototyping = true;
    var inst = new klass();
    klass.$prototyping = false;
    inst.initialize.apply(inst, args);
    return inst;
}

var myFoo = Class.createInstance(Foo, ['a', 'b']);

// returns "a, b"
myFoo.getParams();

$prototyping
是MooTools不调用构造函数的开关。
没有直接的方法可以使用要扩展的参数数组调用构造函数，就像使用
函数那样。应用

如果使用
new Foo（）
创建类的新实例，MooTools将调用构造函数（
initialize
），并隐式传递调用Foo（）的参数。但是，
initialize
仍然作为实例的一个方法存在，所以您可以简单地将其称为“再次”，如下所示：

但这是一种非常糟糕的做法，因为构造函数通常不会被调用两次，而且很可能会遇到问题

另一种方法是创建实例，而不让MooTools调用构造函数。首先需要一个普通实例，然后调用
initialize
作为实例的方法。这是相当骇人听闻的，但可以这样实现：

var Foo = new Class({
    initialize: function(param1, param2) {
        this.param1 = param1;
        this.param2 = param2;
    },
    getParams: function() {
        console.log(this.param1 + ', ' + this.param2);
    }
});

Class.createInstance = function(klass, args) {
    klass.$prototyping = true;
    var inst = new klass();
    klass.$prototyping = false;
    inst.initialize.apply(inst, args);
    return inst;
}

var myFoo = Class.createInstance(Foo, ['a', 'b']);

// returns "a, b"
myFoo.getParams();

$prototyping
是MooTools不调用构造函数的开关。
我会扩展类的proto，这样它就不在乎了（参见Felix的答案）

它涉及较少的黑客攻击，并且可能比创建特殊的构造函数抽象更容易理解/维护

如果你能，你甚至能做到

var Foo2 = new Class({
     Extends: Foo,
     initialize: function () {
         var args = typeOf(arguments[0]) == 'array' ? arguments[0] : arguments;
         this.parent.apply(this, args);
     }
});

new Foo2(['one', 'two']);
new Foo2('three', 'four');

因此，在不修改父原型和期望的情况下进行非常清晰的抽象，并让讨厌的实体原则让混蛋们高兴：D
我会扩展类的原型，这样它就不在乎了（参见Felix的答案）

它涉及较少的黑客攻击，并且可能比创建特殊的构造函数抽象更容易理解/维护

如果你能，你甚至能做到

var Foo2 = new Class({
     Extends: Foo,
     initialize: function () {
         var args = typeOf(arguments[0]) == 'array' ? arguments[0] : arguments;
         this.parent.apply(this, args);
     }
});

new Foo2(['one', 'two']);
new Foo2('three', 'four');

因此，在不修改父原型和期望的情况下进行非常清晰的抽象，并让讨厌的可靠原则让混蛋们高兴：D
不确定，您是否尝试过类似于：Foo.apply（this，a）？这不适用于类的初始化。不确定，您是否尝试过类似：Foo.apply（This，a）？这不适用于类的初始化。+1但是#1模式不好，因为它将调用initialize两次#2更好，但由于它进入了API的内部/外部，所以很粗糙。我倾向于扩展类以获取数组、参数或列表。我同意@DimitarChristoff的观点，这看起来有点粗糙。但我不知道，它可以这样工作，所以+1+1但是#1模式并不好，因为它会调用initialize两次#2更好，但由于它进入了API的内部/外部，所以很粗糙。我倾向于扩展类以获取数组、参数或列表。我同意@DimitarChristoff的观点，这看起来有点粗糙。但我不知道，它可以像这样工作，因此+1感谢您的这种方法！谢谢你的这种方法！