Evitare il nuovo operatore in JavaScript: il modo migliore

Attenzione: questo è un post lungo.

Manteniamolo semplice. Voglio evitare di dover aggiungere il prefisso al nuovo operatore ogni volta che chiamo un costruttore in JavaScript. Questo perché tendo a dimenticarlo e il mio codice si rovina male.

Il modo semplice per aggirare questo è questo ...

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

  // do your stuff...
}

Ma ho bisogno di questo per accettare la variabile no. di argomenti, come questo ...

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

La prima soluzione immediata sembra essere il metodo 'applica' come questo ...

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

  // do your stuff
}

Tuttavia, questo è SBAGLIATO: il nuovo oggetto viene passato al applymetodo e NON al nostro costruttore arguments.callee.

Ora, ho escogitato tre soluzioni. La mia semplice domanda è: quale sembra la migliore. Oppure, se hai un metodo migliore, dillo.

Primo : utilizzare eval()per creare dinamicamente codice JavaScript che chiama il costruttore.

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

Secondo : ogni oggetto ha __proto__proprietà che è un collegamento "segreto" al suo oggetto prototipo. Fortunatamente questa proprietà è scrivibile.

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

Terzo : è qualcosa di simile alla seconda soluzione.

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 la soluzione sembra goffa e presenta tutti i problemi di "malvagia valutazione".

• __proto__ la soluzione non è standard e il "Grande Browser di mIsERY" non lo onora.

• La terza soluzione sembra eccessivamente complicata.

Ma con tutte queste tre soluzioni, possiamo fare qualcosa del genere, che altrimenti non potremmo ...

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

Così efficacemente le soluzioni di cui sopra ci danno costruttori "veri" che accettano la variabile n. di argomenti e non richiedono new. Cosa ne pensi di questo.

-- AGGIORNARE --

Alcuni hanno detto "basta lanciare un errore". La mia risposta è: stiamo realizzando un'app pesante con oltre 10 costruttori e penso che sarebbe molto più utile se ogni costruttore potesse "intelligentemente" gestire l'errore senza inviare messaggi di errore sulla console.

Innanzitutto arguments.calleeè deprecato in ES5 rigoroso, quindi non lo usiamo. La vera soluzione è piuttosto semplice.

Non usi newaffatto.

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

Questo è un dolore nel culo giusto?

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

Ora ovviamente questo richiede ES5, ma tutti usano lo shim ES5 giusto?

Potresti anche essere interessato a modelli js OO alternativi

A parte puoi sostituire l'opzione due con

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

  return that;
}

Nel caso in cui desideri il tuo Object.createspessore ES5 , è davvero facile

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

Manteniamolo semplice. Voglio evitare di dover aggiungere il prefisso al nuovo operatore ogni volta che chiamo un costruttore in JavaScript. Questo perché tendo a dimenticarlo e il mio codice si rovina male.

La risposta ovvia sarebbe non dimenticare la newparola chiave.

Stai cambiando la struttura e il significato della lingua.

Il che, secondo me, e per il bene dei futuri manutentori del tuo codice, è un'idea orribile.

La soluzione più semplice è semplicemente ricordare newe lanciare un errore per rendere evidente che hai dimenticato.

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

Qualunque cosa tu faccia, non usare eval. Vorrei evitare di usare proprietà non standard come nello __proto__specifico perché sono non standard e la loro funzionalità può cambiare.

In realtà ho scritto un post su questo. http://js-bits.blogspot.com/2010/08/constructors-without-using-new.html

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

E puoi anche generalizzarlo in modo da non doverlo aggiungere all'inizio di ogni costruttore. Puoi vederlo visitando il mio post

Disclaimer Non lo uso nel mio codice, l'ho pubblicato solo per il valore didattico. Ho scoperto che dimenticare a newè un bug facile da individuare. Come altri, non penso che ne abbiamo davvero bisogno per la maggior parte del codice. A meno che tu non stia scrivendo una libreria per la creazione dell'ereditarietà JS, nel qual caso potresti utilizzare da un unico posto e utilizzeresti già un approccio diverso rispetto all'ereditarietà diretta.

Cosa ne pensi di questo?

/* 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: ho dimenticato di aggiungere:

"Se la tua app è veramente 'pesante', l'ultima cosa che vuoi è un meccanismo di costruzione rovinato per rallentarla"

Sono assolutamente d'accordo: quando si crea "cosa" sopra senza la "nuova" parola chiave, è più lento / più pesante che con esso. Gli errori sono tuoi amici, perché ti dicono che cosa c'è che non va. Inoltre, dicono ai tuoi colleghi sviluppatori cosa stanno facendo di sbagliato.