JavaScript'te yeni operatörden kaçınmak - daha iyi bir yol

Uyarı: Bu uzun bir gönderi.

Basit tutalım. JavaScript'te her yapıcıyı çağırdığımda yeni operatörün önekini kullanmaktan kaçınmak istiyorum. Çünkü unutmaya eğilimliyim ve kodum kötü bir şekilde vidalanıyor.

Bunun basit yolu şudur ...

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

  // do your stuff...
}

Ancak, değişken no'yu kabul etmek için buna ihtiyacım var. gibi argümanların ...

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

İlk acil çözüm böyle 'uygula' yöntemi gibi görünüyor ...

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

  // do your stuff
}

Ancak bu YANLIŞ - yeni nesne yapıcıya applydeğil , yönteme geçirilir arguments.callee.

Şimdi üç çözüm buldum. Basit sorum şu: hangisi daha iyi görünüyor. Veya daha iyi bir yönteminiz varsa, söyleyin.

İlk olarakeval() , yapıcıyı çağıran JavaScript kodunu dinamik olarak oluşturmak için kullanın .

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...
}

İkincisi - Her nesnenin, __proto__prototip nesnesine bir 'gizli' bağlantı olan özelliği vardır. Neyse ki bu özellik yazılabilir.

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

Üçüncü - Bu ikinci çözüme benzer bir şeydir.

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 çözüm beceriksiz görünüyor ve "kötü eval" tüm sorunları ile geliyor.

• __proto__ çözüm standart değildir ve "mIsERY'nin Büyük Tarayıcısı" onurlandırmaz.

• Üçüncü çözüm aşırı karmaşık görünüyor.

Ancak yukarıdaki üç çözümün hepsiyle, bunun gibi bir şey yapabiliriz, aksi takdirde yapamayız ...

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

Dolayısıyla yukarıdaki çözümler bize değişken no'yu kabul eden "gerçek" kurucuları vermektedir. ve gerektirmez new. Bu konuda ne düşünüyorsun.

-- GÜNCELLEME --

Bazıları "sadece bir hata at" dedi. Benim cevabım: 10'dan fazla kurucu ile ağır bir uygulama yapıyoruz ve her kurucu konsolda hata mesajları atmadan bu hatayı "akıllıca" ele alsaydı çok daha zahmetli olacağını düşünüyorum.

Öncelikle arguments.calleeES5'te kesin olarak kullanılmıyor, bu yüzden kullanmıyoruz. Gerçek çözüm oldukça basit.

Hiç kullanmıyorsun new.

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

Bu eşek için doğru bir acı değil mi?

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

Şimdi elbette bu ES5 gerektirir, ancak herkes ES5-shim kullanıyor değil mi?

Ayrıca ilginizi çekebilir alternatif js OO desenleri

Bir yana, ikinci seçeneği

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

  return that;
}

Kendi ES5 şiminizi istiyorsanız, Object.createo zaman gerçekten kolay

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

Basit tutalım. JavaScript'te her yapıcıyı çağırdığımda yeni operatörün önekini kullanmak zorunda kalmamak istiyorum. Çünkü unutmaya eğilimliyim ve kodum kötü bir şekilde vidalanıyor.

Açık cevap newanahtar kelimeyi unutma olacaktır .

Dilin yapısını ve anlamını değiştiriyorsunuz.

Bence ve kodunuzun gelecekteki koruyucular uğruna korkunç bir fikir.

En kolay çözüm, newunuttuğunuzun anlaşılması için sadece hatırlamak ve bir hata atmaktır.

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

Ne yaparsan yap, kullanma eval. Standart olmayan özellikler __proto__ve işlevlerini değiştirebileceği için standart olmayan özellikleri kullanmaktan çekiniyorum .

Aslında bu konuda bir yazı yazdım. http://js-bits.blogspot.com/2010/08/constructors-without-using-new.html

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

Ve hatta genelleştirebilirsiniz, böylece bunu her kurucuya eklemek zorunda kalmazsınız. Yazımı ziyaret ederek görebilirsiniz

Yasal Uyarı Ben bu benim kod kullanmıyorum, ben sadece didaktik değeri için gönderdi. Bir unutmanın newkolay bir hata olduğunu gördüm . Diğerleri gibi, aslında çoğu kod için buna ihtiyacımız olduğunu düşünmüyorum. JS mirası oluşturmak için bir kitaplık yazmadığınız sürece, bu durumda tek bir yerden kullanabilirsiniz ve zaten düz mirastan farklı bir yaklaşım kullanıyorsunuzdur.

Buna ne dersin?

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

EDIT: Eklemeyi unuttum:

"Uygulamanız gerçekten 'ağır' ise, istediğiniz son şey, uygulamayı yavaşlatmak için aşırı işlenmiş bir inşaat mekanizmasıdır"

Kesinlikle katılıyorum - 'yeni' anahtar kelime olmadan yukarıdaki 'şey' oluştururken, ondan daha yavaş / daha ağır. Hatalar arkadaşın, çünkü sana neyin yanlış olduğunu söylüyorlar. Dahası, ne diğer geliştiricilerin anlatmak onlar konum yanlış yapıyor.