Evitar un nuevo operador en JavaScript: la mejor manera

Advertencia: esta es una publicación larga.

Hagámoslo simple. Quiero evitar tener que prefijar el nuevo operador cada vez que llamo a un constructor en JavaScript. Esto se debe a que tiendo a olvidarlo, y mi código se arruina mal.

La forma simple de evitar esto es esto ...

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

  // do your stuff...
}

Pero, necesito esto para aceptar la variable no. de argumentos como este ...

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

La primera solución inmediata parece ser el método 'aplicar' como este ...

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

  // do your stuff
}

Sin embargo, esto es INCORRECTO: el nuevo objeto se pasa al applymétodo y NO a nuestro constructor arguments.callee.

Ahora, he encontrado tres soluciones. Mi simple pregunta es: cuál parece mejor. O, si tiene un método mejor, dígalo.

Primero , use eval()para crear dinámicamente código JavaScript que llame al constructor.

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

Segundo : cada objeto tiene una __proto__propiedad que es un enlace 'secreto' a su objeto prototipo. Afortunadamente, esta propiedad se puede escribir.

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

Tercero : esto es algo similar a la segunda solución.

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 solución parece torpe y viene con todos los problemas de "evaluación malvada".

• __proto__ la solución no es estándar y el "Gran navegador de MISERY" no la cumple.

• La tercera solución parece demasiado complicada.

Pero con las tres soluciones anteriores, podemos hacer algo como esto, de lo contrario no podemos ...

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

Entonces, efectivamente, las soluciones anteriores nos dan constructores "verdaderos" que aceptan la variable no. de argumentos y no requieren new. Cuál es su opinión sobre esto.

- ACTUALIZACIÓN -

Algunos han dicho "solo arroja un error". Mi respuesta es: estamos haciendo una aplicación pesada con más de 10 constructores y creo que sería mucho más manejable si cada constructor pudiera "inteligentemente" manejar ese error sin lanzar mensajes de error en la consola.

En primer lugar, arguments.calleeestá obsoleto en ES5 estricto, por lo que no lo usamos. La verdadera solución es bastante simple.

No lo usas newen absoluto.

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

Eso es un dolor en el culo ¿verdad?

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

Ahora, por supuesto, esto requiere ES5, pero todos usan la cuña ES5 ¿verdad?

Usted también podría estar interesado en patrones alternativos de js OO

Como aparte, puede reemplazar la opción dos con

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

  return that;
}

En caso de que quieras tu propia Object.createcuña ES5, entonces es realmente fácil

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

Hagámoslo simple. Quiero evitar tener que prefijar el nuevo operador cada vez que llamo a un constructor en JavaScript. Esto se debe a que tiendo a olvidarlo, y mi código se arruina mal.

La respuesta obvia sería no olvidar la newpalabra clave.

Estás cambiando la estructura y el significado del lenguaje.

Lo cual, en mi opinión, y por el bien de los futuros mantenedores de su código, es una idea horrible.

La solución más fácil es recordar newy lanzar un error para que sea obvio que lo olvidó.

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

Hagas lo que hagas, no lo uses eval. Me gustaría evitar el uso de propiedades no estándar como __proto__específicamente porque no son estándar y su funcionalidad puede cambiar.

De hecho, escribí una publicación sobre esto. 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 incluso puede generalizarlo para no tener que agregarlo a la parte superior de cada constructor. Puedes ver eso visitando mi publicación

Descargo de responsabilidad No uso esto en mi código, solo lo publiqué por el valor didáctico. Descubrí que olvidar a newes un error fácil de detectar. Como otros, no creo que realmente necesitemos esto para la mayoría del código. A menos que esté escribiendo una biblioteca para crear herencia JS, en cuyo caso podría usarla desde un solo lugar y ya estaría usando un enfoque diferente al de la herencia directa.

¿Qué tal esto?

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

EDITAR: Olvidé agregar:

"Si su aplicación es realmente 'pesada', lo último que desea es algún mecanismo de construcción sobrecargado para ralentizarla"

Estoy totalmente de acuerdo: al crear 'cosa' anterior sin la palabra clave 'nueva', es más lenta / más pesada que con ella. Los errores son tus amigos, porque te dicen lo que está mal. Además, le dicen a sus compañeros desarrolladores qué están haciendo mal.