避免在JavaScript中使用新运算符-更好的方法

警告：这是一篇冗长的文章。

让我们保持简单。我想避免每次在JavaScript中调用构造函数时都必须给新运算符添加前缀。这是因为我倾向于忘记它，并且我的代码严重搞砸了。

解决这个问题的简单方法是...

function Make(x) {
  if ( !(this instanceof arguments.callee) )
  return new arguments.callee(x);

  // do your stuff...
}

但是，我需要接受变量号。这样的论点...

m1 = Make();
m2 = Make(1,2,3);
m3 = Make('apple', 'banana');

第一个直接的解决方案似乎是这样的“应用”方法...

function Make() {
  if ( !(this instanceof arguments.callee) )
    return new arguments.callee.apply(null, arguments);

  // do your stuff
}

但是，这是错误的-新对象将传递给apply方法，而不是传递给我们的构造函数arguments.callee。

现在，我提出了三种解决方案。我的简单问题是：哪个似乎最好。或者，如果您有更好的方法，请告诉它。

首先 –用于eval()动态创建调用构造函数的JavaScript代码。

function Make(/* ... */) {
  if ( !(this instanceof arguments.callee) ) {
    // collect all the arguments
    var arr = [];
    for ( var i = 0; arguments[i]; i++ )
      arr.push( 'arguments[' + i + ']' );

    // create code
    var code = 'new arguments.callee(' + arr.join(',') + ');';

    // call it
    return eval( code );
  }

  // do your stuff with variable arguments...
}

第二 –每个对象都有__proto__属性，该属性是与其原型对象的“秘密”链接。幸运的是，该属性是可写的。

function Make(/* ... */) {
  var obj = {};

  // do your stuff on 'obj' just like you'd do on 'this'
  // use the variable arguments here

  // now do the __proto__ magic
  // by 'mutating' obj to make it a different object

  obj.__proto__ = arguments.callee.prototype;

  // must return obj
  return obj;
}

第三 –这类似于第二种解决方案。

function Make(/* ... */) {
  // we'll set '_construct' outside
  var obj = new arguments.callee._construct();

  // now do your stuff on 'obj' just like you'd do on 'this'
  // use the variable arguments here

  // you have to return obj
  return obj;
}

// now first set the _construct property to an empty function
Make._construct = function() {};

// and then mutate the prototype of _construct
Make._construct.prototype = Make.prototype;

• eval 解决方案似乎笨拙，并伴随着“邪恶评估”的所有问题。

• __proto__ 解决方案是非标准的，并且“ mIsERY的出色浏览器”不兑现它。

• 第三种解决方案似乎过于复杂。

但是使用以上三种解决方案，我们都可以做这样的事情，否则我们将无法避免……

m1 = Make();
m2 = Make(1,2,3);
m3 = Make('apple', 'banana');

m1 instanceof Make; // true
m2 instanceof Make; // true
m3 instanceof Make; // true

Make.prototype.fire = function() {
  // ...
};

m1.fire();
m2.fire();
m3.fire();

因此，上述解决方案有效地为我们提供了接受变量编号的“真实”构造函数。的论点，不需要new。您对此有何看法。

-更新-

有些人说“只是抛出一个错误”。我的回答是：我们正在使用10个以上的构造函数来制作一个繁重的应用程序，我认为如果每个构造函数都可以“聪明地”处理该错误而又不会在控制台上抛出错误消息，那将更加令人费解。

首先arguments.callee，在ES5中严格不推荐使用，因此我们不使用它。真正的解决方案非常简单。

你根本不用new。

var Make = function () {
  if (Object.getPrototypeOf(this) !== Make.prototype) {
    var o = Object.create(Make.prototype);
    o.constructor.apply(o, arguments);
    return o;
  }
  ...
}

这是对的屁股痛吗？

尝试 enhance

var Make = enhance(function () {
  ...
});

var enhance = function (constr) {
  return function () {
    if (Object.getPrototypeOf(this) !== constr.prototype) {
      var o = Object.create(constr.prototype);
      constr.apply(o, arguments);
      return o;
    }
    return constr.apply(this, arguments);
  }
}

现在当然需要ES5，但是每个人都使用ES5-shim对吗？

您可能也对替代js OO模式感兴趣

顺便说一句，您可以将选项二替换为

var Make = function () {
  var that = Object.create(Make.prototype);
  // use that 

  return that;
}

如果您想要自己的ES5 Object.create垫片，那真的很容易

Object.create = function (proto) {
  var dummy = function () {};
  dummy.prototype = proto;
  return new dummy;
};

让我们保持简单。我想避免每次在JavaScript中调用构造函数时都必须给新运算符添加前缀。这是因为我倾向于忘记它，并且我的代码严重搞砸了。

显而易见的答案是不要忘记new关键字。

您正在改变语言的结构和含义。

我认为，为了您的代码的未来维护者，这是一个可怕的想法。

最简单的解决方案是只记住new并抛出一个错误，使其变得很明显被您忘记了。

if (Object.getPrototypeOf(this) !== Make.prototype) {
    throw new Error('Remember to call "new"!');
}

无论您做什么，都不要使用eval。我会回避使用非标准属性，例如__proto__专门因为它们是非标准属性并且其功能可能会发生变化。

我实际上写了一篇关于此的文章。http://js-bits.blogspot.com/2010/08/constructors-without-using-new.html

function Ctor() {
    if (!(this instanceof Ctor) {
        return new Ctor(); 
    }
    // regular construction code
}

您甚至可以将其概括化，因此不必将其添加到每个构造函数的顶部。您可以通过访问我的帖子看到

免责声明我在我的代码中没有使用它，我只是出于教学目的发布了它。我发现忘记a new是一个容易发现的错误。像其他人一样，我认为大多数代码实际上都不需要这样做。除非您正在编写用于创建JS继承的库，否则在这种情况下，您可以在一个地方使用它，并且已经使用了与直接继承不同的方法。

这个怎么样？

/* thing maker! it makes things! */
function thing(){
    if (!(this instanceof thing)){
        /* call 'new' for the lazy dev who didn't */
        return new thing(arguments, "lazy");
    };

    /* figure out how to use the arguments object, based on the above 'lazy' flag */
    var args = (arguments.length > 0 && arguments[arguments.length - 1] === "lazy") ? arguments[0] : arguments;

    /* set properties as needed */
    this.prop1 = (args.length > 0) ? args[0] : "nope";
    this.prop2 = (args.length > 1) ? args[1] : "nope";
};

/* create 3 new things (mixed 'new' and 'lazy') */
var myThing1 = thing("woo", "hoo");
var myThing2 = new thing("foo", "bar");
var myThing3 = thing();

/* test your new things */
console.log(myThing1.prop1); /* outputs 'woo' */
console.log(myThing1.prop2); /* outputs 'hoo' */

console.log(myThing2.prop1); /* outputs 'foo' */
console.log(myThing2.prop2); /* outputs 'bar' */

console.log(myThing3.prop1); /* outputs 'nope' */
console.log(myThing3.prop2); /* outputs 'nope' */

编辑：我忘记添加：

“如果您的应用程序确实很“繁重”，那么您最后想要的就是某种过度使用的构建机制来降低它的速度”

我完全同意-在上面没有“ new”关键字的情况下创建“事物”时，它的速度要慢于/使用它。错误是您的朋友，因为错误会告诉您哪里出了问题。而且，他们会告诉您的开发人员他们在做什么错。