funciones Instantiate JavaScript con prototipos personalizados

Question

utilizo la siguiente función para crear instancias de funciones en JavaScript de una serie de argumentos:

var instantiate = function (instantiate) { 
    return function (constructor, args, prototype) { 
     "use strict"; 

     if (prototype) { 
      var proto = constructor.prototype; 
      constructor.prototype = prototype; 
     } 

     var instance = instantiate(constructor, args); 
     if (proto) constructor.prototype = proto; 
     return instance; 
    }; 
}(Function.prototype.apply.bind(function() { 
    var args = Array.prototype.slice.call(arguments); 
    var constructor = Function.prototype.bind.apply(this, [null].concat(args)); 
    return new constructor; 
})); 

Uso de la función de arriba se puede crear instancias de la siguiente manera (ver la fiddle):

var f = instantiate(F, [], G.prototype); 

alert(f instanceof F); // false 
alert(f instanceof G); // true 

f.alert(); // F 

function F() { 
    this.alert = function() { 
     alert("F"); 
    }; 
} 

function G() { 
    this.alert = function() { 
     alert("G"); 
    }; 
} 

El código anterior funciona para los constructores construida por el usuario como F. Sin embargo, no funciona para constructores nativos como Array por razones obvias de seguridad. Siempre puedes crear una matriz y luego cambiar su propiedad __proto__ pero estoy usando este código en Rhino para que no funcione allí. ¿Hay alguna otra forma de lograr el mismo resultado en JavaScript?

Answer 1

No puede fully subclass an array. No se puede usar Object.create para eliminar mucha complejidad de su código actual (ex).

Answer 2

No creo que esté logrando lo que pretende aquí. Primero en sus funciones F y G usted están definiendo una función de alerta en este objeto. Esto significa que cada vez que instancia un objeto se creará un nuevo objeto de función y se le asignará una alerta. Esto no es lo que quiere, es necesario definir alerta en el prototipo del F y G.

function F() { } 

F.prototype.alert = function() { 
    alert("F"); 
}; 

function G() { } 

G.prototype.alert = function() { 
    alert("G"); 
}; 

Sin embargo, usted todavía tiene un problema en su función instantiate. Si se llama a la forma que tiene

var f = instantiate(F, [], G.prototype); 

todo lo que está haciendo es establecer el prototipo de f para G.prototype, que no es lo que creo que quiere. Supongo que si crea una instancia de un objeto F, querría poder invocar todas las funciones definidas en F.prototype, pero tal como están las cosas, este no es el caso.

function F() { } 

F.prototype.alert = function() { 
    alert("F"); 
}; 

F.prototype.foo = function() { 
    alert("F foo"); 
}; 

function G() { } 

G.prototype.alert = function() { 
    alert("G"); 
}; 


var f = instantiate(F, [], G.prototype); 
f.foo(); // error! 

El motivo del error aquí es como he dicho que acaba de asignar prototipo de f para G.prototype y G.prototype no tiene una función foo definido.

Si usted está buscando para hacer la herencia de esta manera echar un vistazo a el blog de John Resig que tiene una buena implementación de dichas mejoras: http://ejohn.org/blog/simple-javascript-inheritance/

también Douglas Crockford ha preparado una serie de buenos ejemplos: http://www.crockford.com/javascript/inheritance.html