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

Eu estava aprendendo sobre 'extends' no JS. Ai tinha lido essa parte (e já entendi ela):…

  1. User

    Eu estava aprendendo sobre 'extends' no JS. Ai tinha lido essa parte (e já entendi ela):

    "Instance methods try to delegate to a minimal set of primitive methods where possible. For example, for a subclass of Promise, overriding then() automatically causes the behavior of catch() to change; or for a subclass of Map, overriding set() automatically causes the behavior of the Map() constructor to change."

    Ai teve outra parte que falava dessa parte citada a cima, e essa parte eu não entendi:

    "The third one leads to visible invocations of custom code, which makes a lot of optimizations harder to implement. For example, if the Map() constructor is called with an iterable of x elements, then it must visibly invoke the set() method x times, instead of just copying the elements into the internal storage."

  2. Assistant

    Claro, vou explicar essa parte de maneira mais detalhada.

    Contexto Inicial

    Quando você cria uma subclasse de uma classe incorporada do JavaScript, como Promise ou Map, você pode sobrescrever métodos (como then() em Promise ou set() em Map) para personalizar seu comportamento. Isso é feito utilizando a palavra-chave extends.

    O Que Você Já Entendeu

    Você mencionou que entendeu a parte que diz:

    "Instance methods try to delegate to a minimal set of primitive methods where possible. For example, for a subclass of Promise, overriding then() automatically causes the behavior of catch() to change; or for a subclass of Map, overriding set() automatically causes the behavior of the Map() constructor to change."

    Basicamente, isso significa que quando você sobrescreve métodos essenciais em uma subclasse, outros métodos que dependem desses métodos também são afetados. Por exemplo, se você sobrescrever set() em uma subclasse de Map, isso não afeta apenas o método set(), mas também o comportamento do construtor Map() que internamente pode chamar set() várias vezes.

    A Parte que Você Não Entendeu

    A parte que você está com dificuldade de entender é:

    "The third one leads to visible invocations of custom code, which makes a lot of optimizations harder to implement. For example, if the Map() constructor is called with an iterable of x elements, then it must visibly invoke the set() method x times, instead of just copying the elements into the internal storage."

    Vamos decompor isso:

    1. Invocações Visíveis de Código Personalizado:

      • Quando você sobrescreve métodos como set() em uma subclasse de Map, toda vez que o construtor Map() precisa adicionar elementos (por exemplo, ao passar um iterable com x elementos), ele precisa chamar explicitamente o método set() para cada elemento.
      • Isso significa que, em vez de o construtor simplesmente copiar todos os elementos diretamente para a estrutura interna de armazenamento de Map, ele precisa passar por cada chamada de método set() que pode conter lógica personalizada.
    2. Impacto nas Otimizações:

      • Motivo das Otimizações: Os motores JavaScript (como V8 no Chrome) otimizam o desempenho evitando passos desnecessários. Se o comportamento de adição de elementos for padrão, o motor pode otimizar a operação realizando uma cópia direta e eficiente dos dados.
      • Problema com Código Personalizado: Quando o construtor tem que chamar métodos sobrescritos que contêm código personalizado, o motor não pode simplesmente copiar os dados. Ele precisa executar o código personalizado em cada chamada de método, o que impede essas otimizações de desempenho.

    Por Que Isso é Importante

    Entender isso é crucial para:

    • Desempenho: Se você estiver criando subclasses que sobrescrevem métodos frequentemente usados no construtor, isso pode impactar negativamente o desempenho da sua aplicação, especialmente se essas operações forem realizadas em grande escala.

    • Comportamento: Alterações inesperadas no comportamento de métodos internos podem levar a bugs difíceis de detectar, já que operações aparentemente simples agora dependem de código personalizado.

    Exemplo Prático

    Imagine a seguinte subclasse de Map:

    class MeuMap extends Map {
      set(key, value) {
        console.log(`Adicionando chave: ${key}`);
        return super.set(key, value);
      }
    }
    
    const iterable = [['a', 1], ['b', 2], ['c', 3]];
    const meuMap = new MeuMap(iterable);
    

    Ao criar uma nova instância de MeuMap com um iterable de 3 elementos:

    1. O construtor de Map precisa adicionar cada par chave-valor.
    2. Como set() foi sobrescrito, ele precisa chamar set('a', 1), set('b', 2) e set('c', 3).
    3. Cada chamada de set() executa o console.log, o que impede que o motor otimize a operação de adição, pois ele tem que executar código customizado.

    Resumo

    • Sobrescrever Métodos: Permite personalizar o comportamento de classes incorporadas.
    • Impacto nas Otimizações: Quando métodos essenciais são sobrescritos, operações internas que usam esses métodos (como o construtor) ficam obrigadas a chamar o código personalizado, o que pode impedir otimizações de desempenho.
    • Importância: Entender essas implicações ajuda a tomar decisões mais informadas ao criar subclasses, equilibrando entre a necessidade de personalização e a eficiência do código.

    Espero que essa explicação tenha esclarecido o trecho que você estava com dúvida!