Principais Lições
Deixe a página aparecer antes que o JavaScript assuma o controle do navegador
Scripts podem deixar a página parada. No modelo de navegador descrito aqui, a execução do JavaScript compartilha um processo com a renderização da página e as atualizações da interface do usuário. Quando o navegador encontra uma tag de script, pode precisar baixar e executar esse código antes de continuar a analisar a página. Vários scripts posicionados perto do início podem causar uma longa espera até que qualquer coisa apareça na tela.
Carregue pensando no usuário. Coloque os scripts comuns perto do fim da página, reduza o número de arquivos separados combinando o código na ordem das dependências e considere carregar dinamicamente o código menos urgente depois que a página inicial estiver pronta. O carregamento dinâmico evita bloquear a página, mas os arquivos que dependem uns dos outros ainda precisam ser executados em uma ordem confiável. Menos requisições ajudam, mas um único script enorme também pode atrasar a página se for executado de uma só vez.
O importante é distinguir entre uma página completa e uma página que já é útil. Os usuários podem começar a ler antes que todos os recursos estejam disponíveis, então a estratégia de carregamento também é uma decisão de produto: priorize o que faz a primeira visualização funcionar e, depois, carregue os recursos secundários. Os exemplos de navegador do livro são de uma época anterior, e o comportamento exato do carregamento varia entre gerações de navegadores. O princípio duradouro é examinar o caminho crítico real, em vez de tratar qualquer regra isolada sobre o posicionamento de scripts como substituta dos testes.
Avalie o gargalo que os usuários sentem, não o código que parece suspeito
Encontre a etapa mais custosa. Uma página lenta pode estar esperando uma requisição de rede, analisando um script, executando uma função ou recalculando o layout. O livro recomenda usar tanto ferramentas de perfilamento quanto analisadores de rede, em vez de fazer suposições. Uma ferramenta de perfilamento pode revelar quais funções consomem tempo e com que frequência são executadas; um gráfico em cascata da rede mostra quando scripts e outros recursos chegam e se uma requisição atrasa outra.
Meça com propósito. Cronômetros simples podem comparar duas implementações, enquanto ferramentas como Firebug, as ferramentas de desenvolvimento dos navegadores, Fiddler e YSlow oferecem visões mais detalhadas da execução e da entrega. Teste navegadores representativos e entradas realistas. No caso das expressões regulares, inclua cadeias de caracteres que quase correspondem, mas acabam falhando, pois elas podem revelar custos que correspondências fáceis ocultam.
O perfilamento transforma a otimização de uma preferência estética em um diagnóstico. Também incentiva uma visão sistêmica útil: a função mais lenta não é necessariamente o gargalo que o usuário percebe, caso o navegador esteja esperando pela rede ou pelo trabalho de layout. As medições, porém, podem enganar. Testes minúsculos exageram o ruído de temporização, enquanto cargas de trabalho sintéticas podem não se parecer com o tráfego real. Por isso, um bom trabalho de desempenho combina medições locais com resultados perceptíveis para o usuário e repete os testes em condições semelhantes às dos dispositivos e conexões que o aplicativo precisa atender.
Acesse o DOM com moderação e agrupe todas as mudanças visíveis
O trabalho com o DOM tem custos. O JavaScript e o modelo de documento do navegador são sistemas separados, então o acesso repetido através dessa fronteira pode custar mais do que cálculos comuns. Em um exemplo, acrescentar caracteres repetidamente a um elemento durante um loop de 15.000 iterações foi muito mais lento do que montar a cadeia de caracteres em JavaScript e atualizar o elemento uma única vez. O livro relata uma diferença de 155 vezes no Internet Explorer 6.
Evite trabalho desnecessário de layout. Um refluxo de layout recalcula a geometria dos elementos; uma repintura redesenha os pixels afetados. Ler medidas de layout depois de alterar estilos pode forçar a aplicação imediata de mudanças pendentes. Armazene em cache o tamanho das coleções e as referências a elementos acessadas repetidamente, monte o novo conteúdo em um fragmento de documento e aplique mudanças de estilo relacionadas em conjunto. A delegação de eventos também reduz custos, permitindo que um único manipulador no elemento pai responda aos eventos que se propagam a partir de vários elementos filhos.
A lição sobre o DOM se assemelha a um princípio geral de sistemas: atravessar fronteiras custa caro, mesmo quando cada travessia, isoladamente, parece insignificante. O agrupamento é eficaz porque permite que o navegador combine o trabalho, em vez de invalidar repetidamente o layout. Isso é especialmente valioso em interfaces com listas grandes ou atualizações frequentes. Ainda assim, minimizar as chamadas ao DOM não deve virar uma obsessão. A melhor abordagem depende das operações que acionam o layout, da quantidade de conteúdo que muda e de o código continuar compreensível e fácil de manter.
Armazene em cache consultas repetidas, mas use closures e escopo dinâmico com critério
Torne barato o acesso frequente. O JavaScript resolve identificadores percorrendo uma cadeia de escopos, o conjunto ordenado de ambientes nos quais uma função pode encontrar suas variáveis. As variáveis locais estão próximas; variáveis globais e outros valores fora do escopo podem exigir uma busca mais extensa. Salvar uma variável global usada com frequência, como o objeto document, em uma variável local, ou salvar uma propriedade de objeto lida repetidamente, evita consultas repetidas. Caminhos aninhados de objetos podem multiplicar esse trabalho.
Fique atento aos custos ocultos. Uma closure permite que uma função continue acessando variáveis da função que a envolve, mas esse ambiente mantido pode consumir mais memória e tornar algumas consultas mais lentas. O livro também alerta que with e eval podem tornar o escopo dinâmico, limitando algumas otimizações do mecanismo. Esses custos são mais relevantes em trechos de código executados intensamente; portanto, simplifique os acessos repetidos quando o perfilamento mostrar que isso importa, em vez de reescrever toda expressão legível.
Este é um lembrete útil de que as abstrações têm uma forma em tempo de execução. Closures não são, por si só, um projeto ruim: são fundamentais para muitos padrões bem estruturados de eventos e callbacks. A questão relevante é se um ambiente mantido ou o acesso repetido a propriedades cria um custo significativo em um trecho executado com frequência. O armazenamento local em cache pode ajudar, mas também pode ocultar valores que mudam ou criar suposições desatualizadas. Desempenho e correção precisam ser considerados em conjunto, especialmente quando o código depende de métodos de objetos cujo comportamento depende de this.
Escolha algoritmos que evitem trabalho, não loops engenhosos por si só
Reduza primeiro o trabalho total. O livro constata que loops for, while e do-while comuns têm velocidades bastante semelhantes, enquanto for-in pode ser muito mais lento porque, a cada passagem, pesquisa as propriedades do objeto. Para um conjunto conhecido de itens de um array, armazene o tamanho em cache, reduza as operações desnecessárias dentro do loop e avalie se todos os itens precisam ser processados. Testes históricos relataram ganhos com o desenrolamento de loops em contagens muito grandes de iterações, mas esses truques não compensam automaticamente em cargas de trabalho menores.
Reutilize resultados e simplifique decisões. Uma tabela de consulta pode substituir uma longa sequência de testes quando cada chave corresponde a um resultado. Memoização significa salvar os resultados de cálculos anteriores para reutilizá-los em requisições repetidas. Ela pode reduzir trabalho redundante em cálculos recursivos, enquanto converter a recursão em iteração pode evitar os limites de pilha de chamadas do navegador. A escolha prática depende do tamanho da entrada, da repetição e da legibilidade.
A ideia mais forte aqui é a economia algorítmica, não o código pelo código. Salvar um cálculo repetido pode importar muito mais do que eliminar uma operação de um loop, e uma tabela de consulta pode tornar mais claros tanto a execução quanto o propósito do código. Mas um cache também tem custos: uso de memória, invalidação e a possibilidade de que as entradas mudem. Afirmações antigas de desempenho, inclusive os ganhos com o desenrolamento de loops, devem ser tratadas como hipóteses a testar nos mecanismos atuais, não como instruções universais.
Estruture cadeias de caracteres e expressões regulares para evitar cópias repetidas e retrocessão
O custo das cadeias de caracteres depende do mecanismo. Nos testes entre navegadores descritos pelo livro, versões antigas do Internet Explorer lidavam mal com concatenações repetidas de cadeias de caracteres. Para muitas concatenações, usar um array para reunir as partes e depois juntá-las evitava copiar repetidamente uma cadeia de caracteres em crescimento. Outros navegadores muitas vezes otimizavam melhor o operador de adição, então o melhor método dependia dos mecanismos visados.
Torne barata a falha de uma expressão regular. Uma expressão regular pode tentar muitos caminhos alternativos quando uma correspondência falha. A retrocessão descontrolada ocorre quando essas possibilidades se multiplicam, especialmente com quantificadores aninhados ou alternativas sobrepostas. O livro apresenta um padrão que pode exigir mais de um bilhão de etapas de retrocessão em uma cadeia de 20 caracteres repetidos. Torne os padrões específicos, evite sobreposições ambíguas e teste correspondências parciais longas. Para buscas literais, métodos como indexOf ou charAt podem ser mais simples e rápidos do que uma expressão regular.
As expressões regulares são descrições compactas de buscas, mas sua concisão pode ocultar uma grande árvore de busca. A principal questão de segurança não é apenas saber se um padrão corresponde a uma entrada válida, mas também quanto trabalho ele exige diante de uma entrada malformada ou quase válida. Por isso, casos de teste adversariais são importantes para qualquer interface que processe texto fornecido pelo usuário. As recomendações sobre concatenação dependem mais do mecanismo: o capítulo registra diferenças reais entre os navegadores de sua época, mas as implementações modernas devem ser medidas, em vez de presumidas como equivalentes.
Mantenha cada tarefa na linha de execução da interface abaixo de 100 milissegundos
Tarefas longas fazem a interface parecer quebrada. No modelo de navegador apresentado aqui, o JavaScript e as atualizações da interface se alternam. Enquanto um script longo está em execução, o navegador pode não responder prontamente a cliques, redesenhos ou outras entradas. O livro usa 100 milissegundos como limite superior para uma tarefa contínua, com base em pesquisas sobre o tempo de resposta e a sensação de controle direto.
Ceda o controle em vez de congelar a interface. Temporizadores podem dividir trabalho longo em tarefas menores, permitindo que o navegador atualize a interface entre elas. Processe itens em lotes, em vez de um por temporizador: o livro estima que tratar individualmente 1.000 itens de um milissegundo, com atrasos de 25 milissegundos, poderia levar 26 segundos, enquanto lotes de 50 poderiam terminar em cerca de 1,5 segundo. Web Workers podem transferir para fora da linha de execução da interface tarefas adequadas e intensivas em dados, como analisar uma grande cadeia JSON.
A responsividade não consiste simplesmente em terminar depressa. Uma tarefa que leva mais tempo no total ainda pode parecer melhor se a interface continuar disponível enquanto ela é executada. Isso é tanto um problema de escalonamento quanto de velocidade. Dividir o trabalho em blocos funciona bem quando ele pode ser pausado com segurança; os workers são adequados para cálculos que não precisam de acesso direto à página. O limite de 100 milissegundos é uma orientação prática baseada nas fontes do livro, não uma garantia de que toda tarefa abaixo desse limite parecerá instantânea em qualquer dispositivo.
Escolha o transporte e o formato Ajax conforme o controle, o volume de dados e a confiança
Adapte o canal à tarefa. XMLHttpRequest oferece controle sobre requisições e respostas, mas os exemplos do livro o limitam ao domínio da página e tratam os dados recebidos como texto ou XML. A inserção dinâmica de scripts pode fazer requisições entre domínios e executar JavaScript diretamente, mas oferece menos controle e dá ao código importado acesso à página. Beacons de imagem são uma maneira leve de enviar pequenas quantidades de dados sem precisar de um corpo de resposta.
Mantenha os dados enviados enxutos. XML pode ser verboso e caro de analisar. JSON é compacto e se converte naturalmente em dados JavaScript, enquanto um formato personalizado delimitado por caracteres pode ser ainda menor em grandes conjuntos de dados. Em um teste, o formato personalizado levou cerca de 78 milissegundos no total para um conjunto de dados de aproximadamente 223 quilobytes. JSON-P, JSON executável envolvido em um callback, pode ser analisado rapidamente, mas não deve conter dados confidenciais.
A otimização de Ajax é uma negociação entre largura de banda, processamento no cliente e segurança. Um formato menor pode economizar tempo de download, mas exigir análise personalizada; respostas executáveis podem reduzir o trabalho de análise, mas ampliar o limite de confiança. Essas compensações são mais duradouras do que qualquer classificação baseada em um único benchmark. Formatos personalizados podem ser eficientes, mas a ordem implícita dos campos e os delimitadores exigem controle disciplinado de versões e validação. Escolher o transporte mais rápido sem considerar quem controla a resposta pode transformar um ganho de desempenho em uma falha de segurança.
Prepare-se para a rede: menos requisições, arquivos menores e cache mais inteligente
Considere a entrega parte do desempenho. Uma compilação de produção pode combinar arquivos JavaScript, remover comentários e espaços em branco desnecessários e comprimir respostas de texto com gzip. O livro relata que o gzip muitas vezes reduzia o tamanho dos dados enviados em cerca de 70%. Combinar arquivos pode reduzir a sobrecarga das requisições, enquanto uma ordenação cuidadosa preserva as dependências. Ferramentas de compilação podem automatizar essas etapas para que os desenvolvedores não precisem repeti-las manualmente.
Torne mais baratas as visitas seguintes. Arquivos estáticos que podem ser armazenados em cache evitam downloads desnecessários, e nomes de arquivo com versão permitem que recursos atualizados contornem cópias antigas no cache. Uma rede de distribuição de conteúdo pode servir arquivos de locais mais próximos dos usuários e reduzir o atraso da rede. O livro cita uma pesquisa segundo a qual a página inicial do Yahoo, com o cache completo, exigia 90% menos requisições e 83% menos bytes do que com o cache vazio. A estratégia de cache precisa levar em conta usuários cujos navegadores têm armazenamento limitado.
Este capítulo amplia a definição de desempenho de JavaScript: a qualidade do código não compensa viagens de rede evitáveis nem recursos de produção excessivamente grandes. A automação da compilação torna repetíveis as boas práticas de entrega, enquanto nomes de arquivo versionados resolvem o conflito entre manter o cache por muito tempo e disponibilizar atualizações rapidamente. Os benefícios específicos dependem dos padrões de tráfego, do comportamento do cache e da infraestrutura. Compressão e concatenação devem ser medidas em conjunto, e os processos de implantação devem preservar mapas de origem ou outro meio de depuração, para que a eficiência em produção não torne as falhas desnecessariamente obscuras.
Elimine interpretações repetidas antes de ajustar operações individuais de JavaScript
Evite avaliar cadeias de caracteres como código. O livro chama de avaliação dupla a análise e compilação extras causadas por eval, pelo construtor Function ou por argumentos em forma de cadeia de caracteres passados a temporizadores. Em seu benchmark histórico, ler 10.000 itens de um array por meio de eval levou cerca de cinco segundos no Internet Explorer 7, em comparação com aproximadamente 31 milissegundos usando código comum. Passe funções aos temporizadores e evite a avaliação dinâmica quando uma chamada direta de função for suficiente.
Deixe a linguagem e o navegador fazerem seu trabalho. Literais de objetos e arrays normalmente são mais rápidos e concisos do que criar contêineres vazios e atribuir cada membro separadamente. Detecte os recursos do navegador uma única vez, na primeira chamada de uma função ou durante a configuração, em vez de repetir o mesmo teste a cada chamada. Prefira operações nativas quando forem adequadas à tarefa, mas teste os resultados e preserve a clareza antes de aplicar micro-otimizações, como substituições por operações bit a bit.
O princípio geral é eliminar categorias inteiras de trabalho desnecessário antes de aperfeiçoar instruções individuais. A interpretação repetida e a detecção repetida de recursos são alvos particularmente promissores, pois eliminá-las pode melhorar muitas chamadas de uma só vez. Os tempos impressionantes de eval apresentados pelo livro também mostram por que médias entre navegadores podem ocultar casos extremos muito ruins. No entanto, código nativo não é automaticamente a melhor opção se alterar o comportamento ou prejudicar a portabilidade. Uma otimização só funciona se preservar a correção e melhorar a carga de trabalho que realmente importa.
Análise
O argumento central do livro é que o desempenho de JavaScript é uma propriedade da experiência completa no navegador, não apenas da velocidade de execução de expressões da linguagem. Uma página pode atrasar por causa do carregamento síncrono de scripts, de acessos repetidos ao DOM, de recálculos de layout, de algoritmos custosos, de serialização, de latência de rede ou de uma implantação descuidada. Essa visão ampla continua sendo a contribuição mais valiosa da obra: ela responsabiliza o desenvolvedor pelo percurso desde a chegada dos bytes até a resposta da interface.
Sua estrutura acompanha esse percurso, do carregamento ao código e à interação, passando por Ajax, entrega em produção e medição. Essa abrangência torna difícil condensar o conteúdo. Algumas recomendações dizem respeito a custos duradouros, como trabalho excessivo, interação bloqueada ou expressões regulares ambíguas. Outras estão estreitamente ligadas às implementações de navegadores de 2010. O próprio livro mostra repetidamente por que essas distinções importam: uma técnica pode ser mais rápida em um mecanismo e mais lenta em outro. Portanto, os tempos históricos devem ser lidos como demonstrações de mecanismos, não como garantias atuais de desempenho.
O método prático mais sólido é um ciclo: identificar o atraso perceptível para o usuário, determinar se ele vem da rede, da execução, do trabalho com o DOM ou da renderização, alterar uma causa e medir novamente em condições representativas. Isso evita uma falha comum na otimização: passar dias trabalhando em código que não está no caminho crítico. Também explica por que o livro dá tanta atenção ao perfilamento e à análise de rede, em vez de se concentrar apenas em sintaxe engenhosa.
As recomendações contêm uma tensão útil. Armazenar consultas em cache, consolidar arquivos ou usar formatos personalizados pode melhorar a velocidade, mas também aumentar o acoplamento, a complexidade ou o risco à segurança. Desempenho não é um único número, independente da manutenção e da correção. A lição mais defensável é otimizar o gargalo medido, protegendo ao mesmo tempo a capacidade de interação do usuário e a capacidade da equipe de compreender o sistema.
Resumo das Resenhas
JavaScript de Alto Desempenho recebe avaliações variadas, com média de 4,11 de 5. Muitos leitores elogiam seus insights detalhados e dicas práticas para otimizar código JavaScript. No entanto, alguns criticam o conteúdo desatualizado, já que o livro foi publicado em 2010. Entre os aspectos positivos estão as explicações aprofundadas sobre técnicas de desempenho, interações com o DOM e expressões regulares. Os críticos observam que muitas práticas hoje são padrão e que os benchmarks de navegadores estão obsoletos. Apesar da idade, alguns leitores ainda consideram valiosos os fundamentos e a perspectiva histórica sobre a otimização do desempenho de JavaScript.
Outros Também Leram
Glossário
cadeia de escopos
Busca ordenada de variáveisA sequência de ambientes que uma função JavaScript percorre para resolver o nome de uma variável. Primeiro, a função busca em seu ambiente local, depois nos ambientes ao redor e, por fim, no ambiente global. O livro explica que, em muitos mecanismos da época, as buscas mais distantes nessa cadeia podiam ser mais lentas e que construções de escopo dinâmico podem complicar as otimizações.
refluxo de layout
Recálculo do layoutUma operação do navegador que recalcula a geometria e as posições dos elementos depois que uma alteração afeta o layout da página. Adicionar conteúdo, mudar dimensões ou mover elementos pode provocar um refluxo de layout. Como o recálculo pode afetar elementos vizinhos ou grande parte da página, alterações repetidas e solicitações de novas medições do layout podem tornar a interface menos responsiva.
delegação de eventos
O elemento pai trata eventos dos filhosUma técnica que associa um único manipulador de eventos a um elemento pai, em vez de associar manipuladores separados a muitos elementos filhos. Os eventos do navegador se propagam do alvo em direção aos ancestrais, permitindo que o manipulador do elemento pai identifique qual filho esteve envolvido. Isso pode reduzir o trabalho de configuração dos manipuladores e o uso de memória em páginas com muitos elementos interativos.
Dispositivo de Duff (Duff’s Device)
Técnica de desenrolamento de laçoUm método de desenrolamento de laço que executa várias unidades de trabalho em cada passagem, reduzindo o número de iterações de controle do laço. A versão em JavaScript descrita no livro processa itens em grupos, geralmente de oito por vez. O benefício depende do tamanho da carga de trabalho e do comportamento do mecanismo, por isso não é um substituto geral para laços comuns.
memoização
Armazenamento em cache de cálculos anterioresUma técnica que armazena os resultados de cálculos anteriores de uma função e retorna um resultado salvo quando a mesma entrada aparece novamente. Em algoritmos recursivos, isso pode evitar a repetição de subproblemas. O livro ilustra o método com cálculos de fatorial e observa que o armazenamento em cache aumenta o uso de memória e é mais útil quando os cálculos se repetem.
retrocessão descontrolada
Busca explosiva em expressões regularesUma falha de desempenho de expressões regulares em que o mecanismo explora um número rapidamente crescente de maneiras possíveis de corresponder a uma cadeia de caracteres antes de concluir que não há correspondência. Alternativas ambíguas e quantificadores aninhados podem causar esse problema, sobretudo em cadeias longas que quase correspondem ao padrão. Padrões específicos e testes com correspondências parciais ajudam a revelar e prevenir o problema.
JSON-P
JSON executável com callbackDados JSON encapsulados em um callback JavaScript para que possam ser carregados por meio de um elemento script inserido dinamicamente. Como o navegador executa a resposta como código, essa abordagem pode dispensar a análise sintática de uma cadeia JSON recebida e permitir solicitações entre domínios no ambiente histórico de navegadores descrito. Essa capacidade de execução também cria um risco de segurança, portanto dados confidenciais não devem ser expostos dessa forma.
XHR multipart (MXHR)
Vários recursos, uma solicitaçãoUma técnica que reúne vários recursos em uma única resposta XMLHttpRequest, separa-os com delimitadores e os reconstrói no navegador. Ela pode reduzir o número de solicitações HTTP, especialmente para recursos usados em apenas uma página. O livro observa que os recursos reconstruídos não são armazenados individualmente no cache do navegador e que a implementação se torna mais complexa quando é necessário oferecer suporte robusto a streaming.
Web Workers
Threads JavaScript em segundo planoUm recurso do navegador que executa JavaScript em um ambiente de worker separado da thread da interface do usuário da página. Os workers não podem manipular diretamente o DOM da página, então se comunicam com o código da página por meio de mensagens. Eles são adequados para cálculos demorados sobre dados, como análise sintática ou ordenação, quando manter a interface responsiva é mais importante do que compartilhar o mesmo contexto de execução.
Perguntas Frequentes
Sobre o que trata JavaScript de Alto Desempenho?
- Foco no desempenho: JavaScript de Alto Desempenho, de Nicholas C. Zakas, tem como foco otimizar JavaScript para melhorar o desempenho de aplicações web, abordando o tempo de execução, a interação com o DOM e a latência da rede.
- Contexto histórico: O livro oferece uma perspectiva histórica sobre JavaScript, acompanhando sua evolução de 1996 até o presente e destacando a crescente complexidade das aplicações web.
- Técnicas práticas: Apresenta técnicas práticas e boas práticas para escrever código JavaScript eficiente, tornando-se um recurso valioso para desenvolvedores que buscam aprimorar suas habilidades.
Por que devo ler JavaScript de Alto Desempenho?
- Melhore a experiência do usuário: Aplicando as técnicas deste livro, você pode melhorar significativamente a velocidade e a capacidade de resposta de aplicações web, proporcionando uma experiência melhor para o usuário.
- Mantenha-se atualizado: O livro aborda a evolução dos mecanismos JavaScript e das práticas de otimização, mantendo você em dia com as tendências mais recentes do desenvolvimento web.
- Insights de um especialista: Escrito por Nicholas C. Zakas, especialista reconhecido, o livro oferece insights valiosos que podem ajudar você a se tornar um desenvolvedor JavaScript mais proficiente.
Quais são as principais lições de JavaScript de Alto Desempenho?
- Técnicas de otimização: O livro apresenta diversas técnicas de otimização, como minimizar o acesso ao DOM e usar algoritmos eficientes, para melhorar o desempenho de JavaScript.
- Estratégias de carregamento de JavaScript: Ressalta a importância de carregar JavaScript com eficiência e recomenda práticas como colocar os scripts no fim da página para evitar bloquear a renderização.
- Compreensão dos mecanismos JavaScript: Os leitores aprendem sobre mecanismos JavaScript modernos, incluindo compilação just-in-time e coleta de lixo, essenciais para escrever código de alto desempenho.
Quais são as melhores citações de JavaScript de Alto Desempenho e o que significam?
- Desempenho e usabilidade: "O desempenho de JavaScript no navegador é, sem dúvida, um dos problemas de usabilidade mais importantes que os desenvolvedores enfrentam." Isso destaca o papel fundamental do desempenho na satisfação do usuário e no sucesso das aplicações web.
- Minimize a interação com o DOM: "Interaja pouco com o DOM e permaneça tanto quanto possível dentro do ECMAScript." Este conselho enfatiza a importância de minimizar interações diretas com o DOM, que podem ser lentas, e de priorizar operações JavaScript mais rápidas.
- Técnicas abrangentes: "As técnicas e abordagens ensinadas neste livro tratam de muitos aspectos diferentes de JavaScript." Isso indica a abrangência do livro, que cobre tópicos essenciais para otimizar o desempenho de JavaScript.
Como JavaScript de Alto Desempenho aborda o desempenho de scripts no DOM?
- Custos de acesso ao DOM: O livro explica que acessar e modificar elementos do DOM é custoso e pode gerar gargalos de desempenho, especialmente em laços.
- Agrupe as alterações no DOM: Recomenda agrupar alterações no DOM para minimizar refluxos de layout e repinturas, que podem deixar a interface do usuário mais lenta.
- Métodos eficientes: O autor recomenda usar métodos como
document.createDocumentFragment()para fazer alterações fora do documento antes de adicioná-las ao DOM, reduzindo os refluxos de layout.
Quais são as melhores práticas para carregar JavaScript segundo JavaScript de Alto Desempenho?
- Scripts no fim da página: O livro recomenda colocar todas as tags
<script>logo antes da tag de fechamento</body>para garantir que a página seja renderizada antes do início da execução de JavaScript. - Carregamento assíncrono: Sugere usar os atributos
asyncoudefernas tags de script para evitar que o carregamento dos scripts bloqueie a renderização da página. - Minimize as tags de script: Agrupar vários scripts em um único arquivo reduz o número de solicitações HTTP e melhora significativamente o tempo de carregamento.
Quais técnicas JavaScript de Alto Desempenho recomenda para otimizar algoritmos?
- Minimize o trabalho por iteração: O livro recomenda reduzir as operações dentro dos laços para melhorar o desempenho, por exemplo, armazenando o comprimento dos arrays em variáveis locais.
- Estruturas de dados eficientes: Sugere usar tabelas de consulta em vez de condicionais para mapear valores, o que pode acelerar significativamente a execução.
- Evite a recursão: O autor recomenda soluções iterativas em vez de recursivas para evitar erros de estouro de pilha e melhorar o desempenho.
Como JavaScript de Alto Desempenho explica a importância de compreender os mecanismos JavaScript?
- Evolução dos mecanismos: O livro discute a evolução dos mecanismos JavaScript e suas melhorias de desempenho com técnicas como compilação just-in-time.
- Coleta de lixo: Explica como a coleta de lixo funciona em diferentes mecanismos e seu impacto no desempenho, enfatizando a necessidade de código que use a memória com eficiência.
- Implicações para o desempenho: Compreender a execução pelo mecanismo ajuda os desenvolvedores a escrever JavaScript otimizado, resultando em aplicações web mais rápidas.
Como JavaScript de Alto Desempenho aborda a thread da interface do usuário do navegador?
- Gerenciamento em um único processo: O livro explica que a maioria dos navegadores tem um único processo compartilhado entre a execução de JavaScript e as atualizações da interface do usuário, o que pode deixar as interfaces sem resposta se não houver um gerenciamento adequado.
- Sistema de fila de tarefas: Zakas descreve como a thread da interface do usuário usa um sistema de filas para gerenciar tarefas, ajudando os desenvolvedores a otimizar o código para que as atualizações da interface não sejam bloqueadas.
- Importância da capacidade de resposta: Manter a capacidade de resposta das aplicações web é essencial, e os desenvolvedores são incentivados a minimizar o tempo de execução de JavaScript para que a interface continue responsiva.
Quais técnicas JavaScript de Alto Desempenho recomenda para otimizar Ajax?
- Formatos de dados eficientes: O livro recomenda usar JSON em vez de XML nas solicitações Ajax por ser mais leve e permitir análise sintática mais rápida.
- Minimize as solicitações HTTP: Zakas aconselha combinar várias solicitações Ajax em uma única sempre que possível, para reduzir os tempos de carregamento.
- Aproveite o cache: Configurar o cache corretamente pode reduzir a carga do servidor e melhorar os tempos de resposta para usuários recorrentes.
Como posso melhorar meu código JavaScript com base em JavaScript de Alto Desempenho?
- Evite a avaliação dupla: O livro recomenda não usar
eval()nem o construtorFunction()por causa das penalidades de desempenho e sugere chamadas diretas a funções. - Literais de objetos e arrays: Zakas enfatiza os benefícios de desempenho do uso de literais de objetos e arrays para criar estruturas de dados, além de resultar em código mais limpo.
- Implemente o carregamento sob demanda: Técnicas de carregamento sob demanda adiam o trabalho até que ele seja necessário, otimizando o desempenho ao executar apenas o código essencial durante interações críticas.
Quais são as implicações de desempenho do uso de Web Workers, segundo JavaScript de Alto Desempenho?
- Delegue o processamento: Web Workers permitem executar código JavaScript em segundo plano, separado da thread principal da interface do usuário, melhorando o desempenho ao transferir cálculos pesados para fora dela.
- Acesso limitado ao DOM: Web Workers não podem acessar diretamente o DOM, evitando problemas relacionados à interface do usuário e garantindo que tarefas longas não interfiram nas interações do usuário.
- Comunicação eficiente: Web Workers se comunicam com a thread principal usando o método
postMessage(), permitindo a transferência eficiente de dados e mantendo a interface responsiva.
Baixar PDF
Baixar EPUB
.epub é ideal para ler e-books em celulares, tablets e leitores digitais.