Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Eu estou lendo a documentação sobre 'extends' no MDN Docs. Eu estava lendo essa parte…

  1. User

    Eu estou lendo a documentação sobre 'extends' no MDN Docs.

    Eu estava lendo essa parte (eu já entendi ela):

    "When calling an instance method that returns a new instance (like Promise.prototype.then() or Array.prototype.map()) on a subclass, the returned instance is always an instance of the subclass."

    E ai tinha uma parte que fala dessa parte que citei acima, e essa parte eu não entendi:

    "The second one requires the instance method to read this.constructor to get the constructor function. However, new this.constructor() may break legacy code, because the constructor property is both writable and configurable and is not protected in any way."

    Não entendi do porque que new this.constructor() pode quebrar código legado.

  2. Assistant

    Entendi sua dúvida! Vamos detalhar por que usar new this.constructor() pode quebrar o código legado no contexto de herança em JavaScript.

    Contexto

    Quando você cria uma subclasse em JavaScript (usando extends), os métodos de instância que retornam novas instâncias (como Array.prototype.map ou Promise.prototype.then) normalmente retornam instâncias da subclasse. Isso é possível porque esses métodos utilizam o construtor da instância atual para criar novos objetos.

    Uma maneira comum de fazer isso é acessando this.constructor dentro do método de instância e, em seguida, usando new this.constructor() para criar a nova instância. Por exemplo:

    class MinhaClasse extends Array {
      meuMetodo() {
        return this.map(x => x * 2); // Retorna uma instância de MinhaClasse
      }
    }
    

    O Problema com this.constructor

    O constructor em JavaScript é uma propriedade que aponta para a função construtora do objeto. No entanto, essa propriedade tem duas características problemáticas:

    1. É mutável: Você pode sobrescrever a propriedade constructor em instâncias ou no protótipo.
    2. É configurável: Pode ser redefinida ou removida.

    Por causa disso, alguém pode, intencionalmente ou não, modificar a propriedade constructor em uma instância ou na cadeia de protótipos. Isso significa que this.constructor pode não apontar para o construtor original que você espera.

    Como Isso Pode Quebrar o Código Legado

    Considere o seguinte cenário em código legado:

    class MinhaClasse extends Array {
      meuMetodo() {
        return new this.constructor(); // Espera-se que crie uma instância de MinhaClasse
      }
    }
    
    // Em algum lugar do código legado, a propriedade constructor é modificada
    const instancia = new MinhaClasse();
    instancia.constructor = function OutraClasse() {};
    const novaInstancia = instancia.meuMetodo(); // new this.constructor() cria uma instância de OutraClasse
    

    Aqui, ao sobrescrever instancia.constructor, quando meuMetodo é chamado, ele não cria mais uma instância de MinhaClasse, mas sim de OutraClasse. Isso pode causar comportamentos inesperados, especialmente se outras partes do código pressupõem que os métodos sempre retornarão instâncias da classe original.

    Resumo

    Usar new this.constructor() pressupõe que a propriedade constructor aponta corretamente para o construtor desejado. No entanto, como essa propriedade pode ser alterada em JavaScript, especialmente em código legado onde talvez não haja essas proteções, depender de this.constructor pode levar a situações onde o método retorna instâncias inesperadas ou até mesmo causa erros se o construtor não for uma função válida.

    Como Evitar Esse Problema

    Uma abordagem mais segura é utilizar métodos e propriedades que não dependam de this.constructor. Por exemplo, você pode usar o método estático Symbol.species para controlar qual construtora deve ser usada para criar novas instâncias a partir de métodos que retornam novas instâncias:

    class MinhaClasse extends Array {
      static get [Symbol.species]() {
        return Array; // Especifica que métodos como map retornem instâncias de Array, não de MinhaClasse
      }
    
      meuMetodo() {
        return this.map(x => x * 2); // Retorna uma instância de Array
      }
    }
    

    Dessa forma, você tem mais controle sobre qual construtora é usada, independentemente de alterações na propriedade constructor.


    Espero que isso tenha esclarecido por que new this.constructor() pode ser problemático em certos contextos e como você pode mitigar esses problemas!