JavaScriptでの新しい演算子の回避-より良い方法

警告：これは長い投稿です。

シンプルにしましょう。JavaScriptでコンストラクターを呼び出すたびにnew演算子にプレフィックスを付ける必要はありません。これは、私がそれを忘れがちであり、私のコードがひどく失敗するからです。

これを回避する簡単な方法はこれです...

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

  // do your stuff...
}

しかし、変数noを受け入れるにはこれが必要です。このような引数の...

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。

今、私は3つの解決策を思いつきました。私の簡単な質問は次のとおりです。または、より良い方法がある場合は、それを教えてください。

最初 – 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...
}

2番目 -すべてのオブジェクト__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;
}

3番目 –これは2番目のソリューションに似ています。

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の素晴らしいブラウザ」はそれを尊重しません。

• 3番目の解決策は過度に複雑に思えます。

しかし、上記の3つのすべてのソリューションを使用すると、このようなことができます。

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

事実上、上記のソリューションは変数noを受け入れる「真の」コンストラクターを提供します。の引数を必要としませんnew。これについてどう思いますか。

-更新-

「エラーを投げるだけ」と言っている人もいます。私の回答は次のとおりです。10以上のコンストラクタで重いアプリを実行しているので、すべてのコンストラクタがコンソールにエラーメッセージをスローすることなくその間違いを「スマートに」処理できると、はるかに使いやすくなると思います。

まずarguments.callee、ES5 strictでは非推奨になっているため、使用しません。実際のソリューションはかなり単純です。

まったく使用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パターンにも興味があるかもしれません

余談ですが、オプション2を

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キーワードを忘れないでください。

言語の構造と意味を変更しています。

私の意見では、そしてあなたのコードの将来のメンテナーのために、これは恐ろしいアイデアです。

最も簡単な解決策は、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
}

さらに、それを一般化して、すべてのコンストラクタの先頭に追加する必要がないようにすることもできます。あなたは私の投稿にアクセスしてそれを見ることができます

免責事項私は自分のコードでこれを使用せず、教訓的な価値のためにのみ投稿しました。を忘れることnewは簡単に発見できるバグであることがわかりました。他の人と同じように、ほとんどのコードで実際にこれが必要だとは思いません。JS継承を作成するためのライブラリを作成している場合を除き、その場合は1つの場所から使用でき、単純な継承とは異なるアプローチを既に使用しています。

これはどう？

/* 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' */

編集：追加するのを忘れた：

「アプリが本当に「重い」場合、最後に望むのは、速度を落とすための過剰な構築メカニズムです」

私は完全に同意します-「新しい」キーワードなしで「もの」を作成する場合、それはそれよりも遅い/重いです。エラーはあなたの友達です。何が悪いのかを教えてくれるからです。さらに、彼らはあなたの仲間の開発者に彼らが間違っていることを伝えます。