Problema con propiedad "prototype"

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