vamos a crear un objeto vacío {} este objeto tiene un objeto constructor que representa la función responsable de crear el objeto vacío y el objeto constructor tiene un objeto prototipo que es responsable de establecer el prototipo para el objeto que se creará este objeto prototipo en sí mismo tiene una propiedad de constructor y así sucesivamente, puede ir con esto hasta donde pueda (constructor> prototipo> constructor> prototipo> constructor> prototipo> …)
la pregunta es ¿cómo maneja JavaScript todos estos objetos infinitamente anidados?
La propiedad de constructor de un objeto constructor.prototype no es el constructor del objeto prototipo sino el constructor mismo.
Si tengo una clase, diga A :
class A { } Y luego creas una instancia de A :
let a = new A(); La propiedad constructor de a será A . Es decir, A construyó a .
a.constructor === ALo que también significa que:
a.constructor.prototype = A.prototype // A.prototype = A.prototype // since A === a.constructor Ahora, el constructor de A.prototype no es A.prototype.constructor que sería Object (o más bien podría serlo, realmente no necesitas un constructor para crear un objeto). Porque el prototipo de A.prototype es en realidad Object.prototype y el prototipo de Object.prototype es nulo.
La propiedad de prototype de cualquier constructor será el prototipo de sus objetos construidos y NO es el prototipo del objeto al que pertenece.
Si sigues haciendo:
a.prototype.constructor.prototype.constructor... estará dando vueltas alrededor del prototipo del constructor y del propio constructor porque:
A.prototype.constructor = A