将 .apply() 与 'new' 运算符一起使用。 这可能吗？

Question

在 JavaScript 中，我想创建一个对象实例（通过new运算符），但将任意数量的参数传递给构造函数。 这可能吗？

我想做的是这样的事情（但下面的代码不起作用）：

function Something(){
    // init stuff
}
function createSomething(){
    return new Something.apply(null, arguments);
}
var s = createSomething(a,b,c); // 's' is an instance of Something

---

答案

从这里的回复来看，很明显没有使用new运算符调用.apply()内置方法。 然而，人们针对这个问题提出了许多非常有趣的解决方案。

我的首选解决方案是来自 Matthew Crumley 的这个解决方案（我已经修改了它以传递arguments属性）：

var createSomething = (function() {
    function F(args) {
        return Something.apply(this, args);
    }
    F.prototype = Something.prototype;

    return function() {
        return new F(arguments);
    }
})();

Answer 1

使用 ECMAScript5 的Function.prototype.bind事情变得非常干净：

function newCall(Cls) {
    return new (Function.prototype.bind.apply(Cls, arguments));
    // or even
    // return new (Cls.bind.apply(Cls, arguments));
    // if you know that Cls.bind has not been overwritten
}

它可以按如下方式使用：

var s = newCall(Something, a, b, c);

甚至直接：

var s = new (Function.prototype.bind.call(Something, null, a, b, c));

var s = new (Function.prototype.bind.apply(Something, [null, a, b, c]));

这和基于 eval 的解决方案是唯一始终有效的解决方案，即使使用像Date这样的特殊构造函数：

var date = newCall(Date, 2012, 1);
console.log(date instanceof Date); // true

---

编辑

一点解释：我们需要在一个接受有限数量参数的函数上运行new 。 bind方法允许我们这样做：

var f = Cls.bind(anything, arg1, arg2, ...);
result = new f();

anything参数无关紧要，因为new关键字会重置f的上下文。 但是，出于语法原因，它是必需的。 现在，对于bind调用：我们需要传递可变数量的参数，所以这就是诀窍：

var f = Cls.bind.apply(Cls, [anything, arg1, arg2, ...]);
result = new f();

让我们把它包装在一个函数中。 Cls作为参数 0 传递，所以它会是我们的anything 。

function newCall(Cls /*, arg1, arg2, ... */) {
    var f = Cls.bind.apply(Cls, arguments);
    return new f();
}

实际上，根本不需要临时f变量：

function newCall(Cls /*, arg1, arg2, ... */) {
    return new (Cls.bind.apply(Cls, arguments))();
}

最后，我们应该确保bind是我们真正需要的。 （ Cls.bind可能已被覆盖）。 所以用Function.prototype.bind替换它，我们得到最后的结果如上。

Answer 2

这是一个通用的解决方案，可以使用参数数组调用任何构造函数（除了作为函数调用时行为不同的本机构造函数，如String 、 Number 、 Date等）：

function construct(constructor, args) {
    function F() {
        return constructor.apply(this, args);
    }
    F.prototype = constructor.prototype;
    return new F();
}

通过调用construct(Class, [1, 2, 3])创建的对象与使用new Class(1, 2, 3)创建的对象相同。

您还可以制作更具体的版本，这样您就不必每次都传递构造函数。 这也稍微更有效，因为它不需要每次调用内部函数时都创建一个新实例。

var createSomething = (function() {
    function F(args) {
        return Something.apply(this, args);
    }
    F.prototype = Something.prototype;

    return function(args) {
        return new F(args);
    }
})();

像这样创建和调用外部匿名函数的原因是为了防止函数F污染全局命名空间。 它有时被称为模块模式。

[更新]

对于那些想在 TypeScript 中使用它的人，因为如果F返回任何内容，TS 会给出错误：

function construct(constructor, args) {
    function F() : void {
        constructor.apply(this, args);
    }
    F.prototype = constructor.prototype;
    return new F();
}

Answer 3

如果您的环境支持ECMA Script 2015 的扩展运算符 ( ... ) ，您可以像这样简单地使用它

function Something() {
    // init stuff
}

function createSomething() {
    return new Something(...arguments);
}

注意：现在 ECMA Script 2015 的规范已经发布并且大多数 JavaScript 引擎都在积极实施它，这将是执行此操作的首选方式。

您可以在此处查看少数主要环境中对 Spread 运算符的支持。

Answer 4

假设你有一个 Items 构造函数，它包含你抛出的所有参数：

function Items () {
    this.elems = [].slice.call(arguments);
}

Items.prototype.sum = function () {
    return this.elems.reduce(function (sum, x) { return sum + x }, 0);
};

您可以使用 Object.create() 创建一个实例，然后使用该实例创建 .apply() ：

var items = Object.create(Items.prototype);
Items.apply(items, [ 1, 2, 3, 4 ]);

console.log(items.sum());

由于 1 + 2 + 3 + 4 == 10，运行时打印 10：

$ node t.js
10

Answer 5

在 ES6 中， Reflect.construct()非常方便：

Reflect.construct(F, args)

Answer 6

@Matthew我认为最好也修复构造函数属性。

// Invoke new operator with arbitrary arguments
// Holy Grail pattern
function invoke(constructor, args) {
    var f;
    function F() {
        // constructor returns **this**
        return constructor.apply(this, args);
    }
    F.prototype = constructor.prototype;
    f = new F();
    f.constructor = constructor;
    return f;
}

Answer 7

你可以移动的init东西出来成一个单独的方法Something原型的：

function Something() {
    // Do nothing
}

Something.prototype.init = function() {
    // Do init stuff
};

function createSomething() {
    var s = new Something();
    s.init.apply(s, arguments);
    return s;
}

var s = createSomething(a,b,c); // 's' is an instance of Something

Answer 8

@Matthew 答案的改进版本。 这种形式通过将临时类存储在闭包中获得了轻微的性能优势，以及可以使用一个函数来创建任何类的灵活性

var applyCtor = function(){
    var tempCtor = function() {};
    return function(ctor, args){
        tempCtor.prototype = ctor.prototype;
        var instance = new tempCtor();
        ctor.prototype.constructor.apply(instance,args);
        return instance;
    }
}();

这将通过调用applyCtor(class, [arg1, arg2, argn]);

Answer 9

我刚遇到这个问题，我是这样解决的：

function instantiate(ctor) {
    switch (arguments.length) {
        case 1: return new ctor();
        case 2: return new ctor(arguments[1]);
        case 3: return new ctor(arguments[1], arguments[2]);
        case 4: return new ctor(arguments[1], arguments[2], arguments[3]);
        //...
        default: throw new Error('instantiate: too many parameters');
    }
}

function Thing(a, b, c) {
    console.log(a);
    console.log(b);
    console.log(c);
}

var thing = instantiate(Thing, 'abc', 123, {x:5});

是的，它有点难看，但它解决了问题，而且非常简单。

Answer 10

这个答案有点晚了，但认为看到这个的任何人都可以使用它。 有一种方法可以使用 apply 返回一个新对象。 尽管它需要对您的对象声明进行一点更改。

function testNew() {
    if (!( this instanceof arguments.callee ))
        return arguments.callee.apply( new arguments.callee(), arguments );
    this.arg = Array.prototype.slice.call( arguments );
    return this;
}

testNew.prototype.addThem = function() {
    var newVal = 0,
        i = 0;
    for ( ; i < this.arg.length; i++ ) {
        newVal += this.arg[i];
    }
    return newVal;
}

testNew( 4, 8 ) === { arg : [ 4, 8 ] };
testNew( 1, 2, 3, 4, 5 ).addThem() === 15;

要在testNew使用第一个if语句，您必须return this; 在函数的底部。 因此，以您的代码为例：

function Something() {
    // init stuff
    return this;
}
function createSomething() {
    return Something.apply( new Something(), arguments );
}
var s = createSomething( a, b, c );

更新：我已将第一个示例更改为对任意数量的参数求和，而不仅仅是两个。

Answer 11

如果您对基于 eval 的解决方案感兴趣

function createSomething() {
    var q = [];
    for(var i = 0; i < arguments.length; i++)
        q.push("arguments[" + i + "]");
    return eval("new Something(" + q.join(",") + ")");
}

Answer 12

这有效！

var cls = Array; //eval('Array'); dynamically
var data = [2];
new cls(...data);

Answer 13

另请参阅 CoffeeScript 如何做到这一点。

s = new Something([a,b,c]...)

变成：

var s;
s = (function(func, args, ctor) {
  ctor.prototype = func.prototype;
  var child = new ctor, result = func.apply(child, args);
  return Object(result) === result ? result : child;
})(Something, [a, b, c], function(){});

Answer 14

这种构造方法在使用和不使用new关键字时都适用：

function Something(foo, bar){
  if (!(this instanceof Something)){
    var obj = Object.create(Something.prototype);
    return Something.apply(obj, arguments);
  }
  this.foo = foo;
  this.bar = bar;
  return this;
}

它假设支持Object.create但如果你支持旧浏览器，你总是可以填充它。 在此处查看 MDN 上的支持表。

这是一个JSBin，可以通过控制台输出查看它的运行情况。

Answer 15

没有ES6 或 polyfill 的解决方案：

var obj = _new(Demo).apply(["X", "Y", "Z"]);


function _new(constr)
{
    function createNamedFunction(name)
    {
        return (new Function("return function " + name + "() { };"))();
    }

    var func = createNamedFunction(constr.name);
    func.prototype = constr.prototype;
    var self = new func();

    return { apply: function(args) {
        constr.apply(self, args);
        return self;
    } };
}

function Demo()
{
    for(var index in arguments)
    {
        this['arg' + (parseInt(index) + 1)] = arguments[index];
    }
}
Demo.prototype.tagged = true;


console.log(obj);
console.log(obj.tagged);

输出

演示 {arg1: "X", arg2: "Y", arg3: "Z"}


...或“更短”的方式：

var func = new Function("return function " + Demo.name + "() { };")();
func.prototype = Demo.prototype;
var obj = new func();

Demo.apply(obj, ["X", "Y", "Z"]);

编辑：
我认为这可能是一个很好的解决方案：

this.forConstructor = function(constr)
{
    return { apply: function(args)
    {
        let name = constr.name.replace('-', '_');

        let func = (new Function('args', name + '_', " return function " + name + "() { " + name + "_.apply(this, args); }"))(args, constr);
        func.constructor = constr;
        func.prototype = constr.prototype;

        return new func(args);
    }};
}

Answer 16

您不能像使用new运算符那样调用具有可变数量参数的构造函数。

您可以做的是稍微更改构造函数。 代替：

function Something() {
    // deal with the "arguments" array
}
var obj = new Something.apply(null, [0, 0]);  // doesn't work!

改为这样做：

function Something(args) {
    // shorter, but will substitute a default if args.x is 0, false, "" etc.
    this.x = args.x || SOME_DEFAULT_VALUE;

    // longer, but will only put in a default if args.x is not supplied
    this.x = (args.x !== undefined) ? args.x : SOME_DEFAULT_VALUE;
}
var obj = new Something({x: 0, y: 0});

或者，如果您必须使用数组：

function Something(args) {
    var x = args[0];
    var y = args[1];
}
var obj = new Something([0, 0]);

Answer 17

function createSomething() {
    var args = Array.prototype.concat.apply([null], arguments);
    return new (Function.prototype.bind.apply(Something, args));
}

如果您的目标浏览器不支持 ECMAScript 5 Function.prototype.bind ，代码将无法工作。 不过，这不太可能，请参阅兼容性表。

Answer 18

修改了@Matthew 的答案。 在这里，我可以像往常一样传递任意数量的参数（不是数组）。 此外，“Something”也没有硬编码到：

function createObject( constr ) {   
  var args =  arguments;
  var wrapper =  function() {  
    return constr.apply( this, Array.prototype.slice.call(args, 1) );
  }

  wrapper.prototype =  constr.prototype;
  return  new wrapper();
}


function Something() {
    // init stuff
};

var obj1 =     createObject( Something, 1, 2, 3 );
var same =     new Something( 1, 2, 3 );

Answer 19

这个单行应该这样做：

new (Function.prototype.bind.apply(Something, [null].concat(arguments)));

Answer 20

虽然其他方法可行，但它们过于复杂。 在 Clojure 中，您通常会创建一个实例化类型/记录的函数，并将该函数用作实例化机制。 将其翻译成 JavaScript：

function Person(surname, name){
  this.surname = surname;
  this.name = name;
}

function person(surname, name){ 
  return new Person(surname, name);
}

通过采用这种方法，您可以避免使用new除非如上所述。 当然，这个函数在使用apply或任何其他函数式编程特性时没有问题。

var doe  = _.partial(person, "Doe");
var john = doe("John");
var jane = doe("Jane");

通过使用这种方法，您所有的类型构造函数（例如Person ）都是普通的、无所作为的构造函数。 您只需传入参数并将它们分配给同名的属性。 毛茸茸的细节进入构造函数（例如person ）。

创建这些额外的构造函数并不费事，因为无论如何它们都是一个很好的做法。 它们很方便，因为它们允许您潜在地拥有多个具有不同细微差别的构造函数。

Answer 21

Matthew Crumley在 CoffeeScript 中的解决方案：

construct = (constructor, args) ->
    F = -> constructor.apply this, args
    F.prototype = constructor.prototype
    new F

或者

createSomething = (->
    F = (args) -> Something.apply this, args
    F.prototype = Something.prototype
    return -> new Something arguments
)()

Answer 22

任何函数（甚至是构造函数）都可以接受可变数量的参数。 每个函数都有一个“参数”变量，可以使用[].slice.call(arguments)将其转换为数组。

function Something(){
  this.options  = [].slice.call(arguments);

  this.toString = function (){
    return this.options.toString();
  };
}

var s = new Something(1, 2, 3, 4);
console.log( 's.options === "1,2,3,4":', (s.options == '1,2,3,4') );

var z = new Something(9, 10, 11);
console.log( 'z.options === "9,10,11":', (z.options == '9,10,11') );

上述测试产生以下输出：

s.options === "1,2,3,4": true
z.options === "9,10,11": true

Answer 23

function FooFactory() {
    var prototype, F = function(){};

    function Foo() {
        var args = Array.prototype.slice.call(arguments),
            i;     
        for (i = 0, this.args = {}; i < args.length; i +=1) {
            this.args[i] = args[i];
        }
        this.bar = 'baz';
        this.print();

        return this;
    }

    prototype = Foo.prototype;
    prototype.print = function () {
        console.log(this.bar);
    };

    F.prototype = prototype;

    return Foo.apply(new F(), Array.prototype.slice.call(arguments));
}

var foo = FooFactory('a', 'b', 'c', 'd', {}, function (){});
console.log('foo:',foo);
foo.print();

Answer 24

这是我的createSomething版本：

function createSomething() {
    var obj = {};
    obj = Something.apply(obj, arguments) || obj;
    obj.__proto__ = Something.prototype; //Object.setPrototypeOf(obj, Something.prototype); 
    return o;
}

基于此，我尝试模拟了 JavaScript 的new关键字：

//JavaScript 'new' keyword simulation
function new2() {
    var obj = {}, args = Array.prototype.slice.call(arguments), fn = args.shift();
    obj = fn.apply(obj, args) || obj;
    Object.setPrototypeOf(obj, fn.prototype); //or: obj.__proto__ = fn.prototype;
    return obj;
}

我对其进行了测试，它似乎适用于所有场景。 它也适用于像Date这样的本机构造函数。 以下是一些测试：

//test
new2(Something);
new2(Something, 1, 2);

new2(Date);         //"Tue May 13 2014 01:01:09 GMT-0700" == new Date()
new2(Array);        //[]                                  == new Array()
new2(Array, 3);     //[undefined × 3]                     == new Array(3)
new2(Object);       //Object {}                           == new Object()
new2(Object, 2);    //Number {}                           == new Object(2)
new2(Object, "s");  //String {0: "s", length: 1}          == new Object("s")
new2(Object, true); //Boolean {}                          == new Object(true)

Answer 25

是的，我们可以，JavaScript 本质上更像是prototype inheritance 。

function Actor(name, age){
  this.name = name;
  this.age = age;
}

Actor.prototype.name = "unknown";
Actor.prototype.age = "unknown";

Actor.prototype.getName = function() {
    return this.name;
};

Actor.prototype.getAge = function() {
    return this.age;
};

当我们用“ new ”创建一个对象时，我们创建的对象getAge ()，但是如果我们使用apply(...) or call(...)来调用Actor，那么我们正在为"this"传递一个对象，但是我们传递的对象WON'T从Actor.prototype继承

除非，我们直接通过 apply 或 call Actor.prototype 但是……“this”将指向“Actor.prototype”，而 this.name 将写入： Actor.prototype.name 。 因此影响了所有其他用Actor...创建的对象Actor...因为我们覆盖了原型而不是实例

var rajini = new Actor('Rajinikanth', 31);
console.log(rajini);
console.log(rajini.getName());
console.log(rajini.getAge());

var kamal = new Actor('kamal', 18);
console.log(kamal);
console.log(kamal.getName());
console.log(kamal.getAge());

让我们尝试apply

var vijay = Actor.apply(null, ["pandaram", 33]);
if (vijay === undefined) {
    console.log("Actor(....) didn't return anything 
           since we didn't call it with new");
}

var ajith = {};
Actor.apply(ajith, ['ajith', 25]);
console.log(ajith); //Object {name: "ajith", age: 25}
try {
    ajith.getName();
} catch (E) {
    console.log("Error since we didn't inherit ajith.prototype");
}
console.log(Actor.prototype.age); //Unknown
console.log(Actor.prototype.name); //Unknown

通过将Actor.prototype作为第一个参数传递给Actor.call() ，当 Actor() 函数运行时，它会执行this.name=name ，因为“this”将指向Actor.prototype ，因此this.name=name; means Actor.prototype.name=name; this.name=name; means Actor.prototype.name=name;

var simbhu = Actor.apply(Actor.prototype, ['simbhu', 28]);
if (simbhu === undefined) {
    console.log("Still undefined since the function didn't return anything.");
}
console.log(Actor.prototype.age); //simbhu
console.log(Actor.prototype.name); //28

var copy = Actor.prototype;
var dhanush = Actor.apply(copy, ["dhanush", 11]);
console.log(dhanush);
console.log("But now we've corrupted Parent.prototype in order to inherit");
console.log(Actor.prototype.age); //11
console.log(Actor.prototype.name); //dhanush

回到最初的问题如何将new operator with apply ，这是我的看法....

Function.prototype.new = function(){
    var constructor = this;
    function fn() {return constructor.apply(this, args)}
    var args = Array.prototype.slice.call(arguments);
    fn.prototype = this.prototype;
    return new fn
};

var thalaivar = Actor.new.apply(Parent, ["Thalaivar", 30]);
console.log(thalaivar);

Answer 26

由于 ES6 这可以通过 Spread 运算符实现，请参阅https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator#Apply_for_new

这个答案已经在评论https://stackoverflow.com/a/42027742/7049810中给出，但似乎被大多数人错过了

Answer 27

其实最简单的方法是：

function Something (a, b) {
  this.a = a;
  this.b = b;
}
function createSomething(){
    return Something;
}
s = new (createSomething())(1, 2); 
// s == Something {a: 1, b: 2}

Answer 28

来自@jordancpaul 答案的修订解决方案。

var applyCtor = function(ctor, args)
{
    var instance = new ctor();
    ctor.prototype.constructor.apply(instance, args);
    return instance;
}; 

Answer 29

制作一个匿名原型并使用参数将Something原型应用于它，然后创建该匿名原型的新实例。 这样做的一个缺点是它不会通过s instanceof Something检查，虽然它是相同的，但它基本上是一个克隆的实例。

function Something(){
    // init stuff
}
function createSomething(){
    return new (function(){Something.apply(this, arguments)});
}
var s = createSomething(a,b,c); // 's' is an instance of Something

Answer 30

看看如何通过使用arguments.callee解决重用临时F()构造函数的问题也很有趣，也就是创建者/工厂函数本身： http ://www.dhtmlkitchen.com/?category=/JavaScript/& date =2008/05/11/&entry=装饰器-工厂-方面

Answer 31

感谢这里的帖子，我以这种方式使用它：

SomeClass = function(arg1, arg2) {
    // ...
}

ReflectUtil.newInstance('SomeClass', 5, 7);

和实施：

/**
 * @param strClass:
 *          class name
 * @param optionals:
 *          constructor arguments
 */
ReflectUtil.newInstance = function(strClass) {
    var args = Array.prototype.slice.call(arguments, 1);
    var clsClass = eval(strClass);
    function F() {
        return clsClass.apply(this, args);
    }
    F.prototype = clsClass.prototype;
    return new F();
};