Problema con propiedad "prototype"

[Andres1433]

Estoy realizando un pequeño trabajo en Javascript.Instancio un objeto de clase Categorie e indico que su objeto prototype es una instancia de PrototypeCategorie, el problema es que al hacer una llamada a un metodo de PrototypeCategorie no lo reconoce a menos que se haga una referencia a prototype. Por ejemplo.

Código:

function PrototypeCategorie (anId,aName)
{	
	this.content=document.createElement("P");
	this.content.innerHTML=aName;
	this.content.id=anId;
       
	this.getContent = function(){
	  return (this.content.innerHTML);
	};
	
}

function Categorie(anId,aName){

	this.prototype = new PrototypeCategorie(anId,aName);

       this.subCategories= new Array();

}

var c = new Categorie(1,"productos");

alert(""+ c.getContent() + ""); //-->Esto no funciona
alert(""+ c.prototype.getContent()+""); //--> esto si funciona

En teoria el interprete de javascript si no encuentra un atributo o metodo en el objeto va a buscarlo a prototype automaticamente siguiendo la cadena , por eso no entiendo porque no funciona.

Gracias

[pedrogp9693]

Creo que prototype funciona desde fuera de la función, por ejemplo:
Categorie.prototype=function(){...}

[Andres1433]

No entendi que me quisiste decir :P

[utan]

hola,

Código Javascript:

this.prototype
 

estas instanciando la clase "PrototypeCategorie" en this.prototype no puedes llamarla directa sin la "propiedad" porque esta instaceada en esta y el metodo es parte de esta...

Necesitas llamar protoype para que puedas tener ese metodo disponible..

[zerokilled]

buenas,
un objeto no es quien posee la propiedad prototype, sino el constructor. en el código de ejemplo estás creando una propiedad con el nombre prototype para la nueva instancia. por tanto, lo que quisistes hacer fue lo siguiente:

Código:

function A(){}
function B(){
this.b = function(){ return 'b'; };
}
A.prototype = new B();

a = new A();
a.b(); // devuelve el string 'b';

[Andres1433]

Muchas gracias por la respuesta zerokilled. A ver si me quedo claro , el A.prototype=new B() no puede estar dentro de function A(){} ya que la asignacion de la jerarquia es propia de la "clase" en sí , no del objeto instanciado (en este caso a) que genera la función constructora ¿o no?

[dontexplain]

A ver, Andres1433. En javascript, cualquier función que se enuncie posee un constructor, que es la propia función o (function), y un prototipo que es una referencia a sí misma. El constructor padre de cualquier función javascript es la función Function() cuyo constructor también es Function de forma indefinida.

Los constructores en Javascript son llamados a cada instancia o réplica de la misma función con new, por lo que

Código Javascript:

function A(){
alert("instancia creada por la ejecución del constructor a su creación");
}
d =  new A(); // emitirá un alert por haberse creado una instancia de A ya que a la creación se llamó al constructor, que es la misma función
 

sin embargo, esto no daría alert porque las propiedades sólo serían almacenadas en memoria, pero igualmente el constructor habría sido ejecutado, por lo que el constructor de una función es un método de la clase u objeto, de ejecución automática a la hora de replicar.

Código Javascript:

function A(){
this.d = function(){alert("instancia creada por la ejecución del constructor a su creación");};
}
d =  new A();
 

Un constructor y la propiedad constructor (funcion.constructor) no son lo mismo. Lo primero es una subrutina de inicialización que se ejecuta cuando se inicializa una función replicándola usando new y lo segundo es una propiedad que retorna la función que la creó.

Código Javascript:

function a(){
if(this.constructor == a){
alert("la instanciación se realizó copiando el objeto");
} 
}
 
d = a()         // no muestra alert
d = new a() //  muestra alert
 

Por otro lado, un prototipo es una propiedad que ofrece una referencia al contenido del objeto mismo.

Código Javascript:

function A(){ this.d="asd"; };
A.prototype // devuelve la propiedad d, el [I]prototype[/I] y el [I]constructor[/I] pero no [I]F()[/I] ni [I]{ [/I]y [I]}[/I]
 

sin embargo, A.prototype.constructor devuelve el constructor del prototipo del objeto F que sería ni más ni menos que la función sin el contenido

function A(){}

El constructor inicial de todas las funciones instanciadas finalmente es Function, cuyo prototipo es nada ya que a la hora de instanciar una Function creando una función su contenido inicial u original es nada hasta que se rellena. Entonces, si se modifica el prototipo de Function añadiendo métodos o propiedades cualquier función creada en el documento ulteriormente contendrá tales métodos y propiedades.

Dado que prototype es el contenido de una función, hacer esto no tiene mucho sentido, porque la propiedad no existe como tal en el interior de la función, sino justo cuando se enuncia, ya que se crea después.

Código Javascript:

function F(){
this.prototype; // no existe
F.prototype; // es redundante
}
 

más bien existiría, desde un punto de vista imaginario en el siguiente ámbito o punto

(function F(){}).prototype

que no es más que una propiedad que existe cuando el objeto terminó de crearse, si se pudiera llamar así.

En resumen, suponiendo lo anterior:

F.prototype =
F.prototype.constructor = F(){}
F.constructor = function Function(){}
F.constructor.prototype = function Function(){}
.... Object

por lo que

Object.prototype.isPrototypeOf(Function) && Function.prototype.isPrototypeOf(F) // true

finalmente, una función es una invocación de Function que a su vez es un objeto de tipo function como puede verse

typeof Function == function || typeof F == function // true

y como juego se me ocurre que sería divertido hacer colapsar dos clases haciendose referencia mútuamente

Código Javascript:

function clase1(){
clase1.prototype=new clase2();
}
 
function clase2(){
clase2.prototype=new clase1();
}
 
clase1();
 

Lo cual genera un bucle infinito que genera error.

Espero que haya quedado mas o menos claro. Un saludo.