Neste artigo, vamos exploarr as relações entre construtores, instâncias e objetos protótipos, além da conexão entre os construtores Object e Function.

Relacionamentos entre Construtores, Instâncias e Protótipos

Dado um construtor MeuConstrutor, uma instância minhaInstancia e seu protótipo MeuConstrutor.prototype, podemos analisar as seguintes propriedades:

const exibir = console.log;

function MeuConstrutor() {}
const minhaInstancia = new MeuConstrutor();

// Relação com o construtor MeuConstrutor
exibir(minhaInstancia.constructor === MeuConstrutor); // true
exibir(MeuConstrutor.prototype.constructor === MeuConstrutor); // true
exibir(minhaInstancia.__proto__ === MeuConstrutor.prototype); // true

// Relação com o construtor Function
exibir((new Function()).constructor === Function); // true
exibir(Function.prototype.constructor === Function); // true
exibir((new Function()).__proto__ === Function.prototype); // true

// Relação com o construtor Object
exibir((new Object()).constructor === Object); // true
exibir(Object.prototype.constructor === Object); // true
exibir((new Object()).__proto__ === Object.prototype); // true

• Todos os construtores podem acessar seus protótipos através da propriedade prototype.
• Todos os protótipos podem acessar seus construtores através da propriedade constructor.
• Todas as instâncias podem acessar seus construtores através da propriedade constructor.
• Todas as instâncias podem acessar seus protótipos através da propriedade __proto__.

Conexão entre Object e Function

Analisemos agora a relação entre os construtores Object e Function:

// Todos os construtores são instâncias de Function
exibir(Object.constructor === Function); // true
exibir(Object.__proto__ === Function.prototype); // true

// Protótipos podem ser vistos como instâncias de Object, mas não têm acesso direto ao construtor Object
exibir(Function.prototype.__proto__ === Object.prototype); // true
exibir(Function.prototype.constructor === Object); // false

• O construtor Object pode acessar Function.prototype através de __proto__ e também pode acessar o construtor Function através de constructor.
• O protótipo de Function pode acessar Object.prototype através de __proto__, mas não pode acessar o construtor Object através de constructor.

Portanto, todos os construtores podem ser considerados instâncias de Function, enquanto os protótipos podem ser aproximadamente considerados instâncias de Object. Essa relação forma a cadeia de protótipos em JavaScript.