Iniciar teste gratuito
Popular Novos Gêneros Autores
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Pesquisando...
SoBrief
Async JavaScript

Async JavaScript

Crie JavaScript assíncrono confiável sem callbacks emaranhados, surpresas de temporização ou workers sobrecarregados.
por Trevor Burnham 2012 84 páginas
4.00
204 avaliações
Ouvir
Imersivo
V2.3
Amazon Kindle Audible
Experimente o Acesso Completo por 3 Dias
Desbloqueie o áudio e muito mais!
Continuar

Principais Lições

Trate o JavaScript como trabalho enfileirado, não como várias threads se alternando

Uma pilha é executada por vez. No modelo do livro, o JavaScript executa o código atual até o fim antes que os manipuladores de eventos enfileirados possam rodar. Um timer não interrompe um script ocupado. Ele torna um callback elegível para execução após o atraso, quando a thread estiver livre. Por isso, um loop que dura um segundo pode adiar um callback programado para meio segundo depois, e um timer com atraso zero significa mais tarde, não agora.

Closures também importam. Em um loop que usa `var i`, três callbacks programados podem ler a mesma variável depois que o loop terminar, produzindo três cópias do valor final, em vez de três valores distintos. A fila de eventos evita uma categoria de condição de corrida envolvendo estado compartilhado, mas não torna previsível todo comportamento assíncrono. Timers são imprecisos, e código de longa duração ainda congela a página.

Análise

O aspecto útil aqui é a mudança de perspectiva: em vez de imaginar execução paralela, acompanhamos quando o trabalho se torna elegível e quando pode de fato ser executado. Esse modelo facilita entender callbacks adiados, travamentos da interface e resultados inesperados. Ele também se assemelha ao escalonamento cooperativo: cada tarefa precisa ceder a vez retornando antes que outra tarefa enfileirada possa ser executada. Mas há um limite importante. Uma única thread de JavaScript não impede corridas lógicas, em que os resultados dependem de qual resposta chega primeiro, nem torna inofensivas as tarefas lentas. O modelo esclarece o escalonamento, mas não substitui um projeto cuidadoso do estado.

Faça com que todos os callbacks sejam assíncronos de maneira consistente e pare de consultar resultados repetidamente

Caminhos rápidos podem surpreender. Uma função pode chamar seu callback imediatamente quando tem uma resposta em cache, mas chamá-lo mais tarde quando precisa fazer I/O. O código que usa essa função passa a ter dois comportamentos temporais distintos. O exemplo do livro é um cálculo solicitado a um worker: programar repetidamente um timer para verificar se o resultado apareceu é recursão assíncrona, uma forma ineficiente de consulta repetida que cria trabalho desnecessário na fila.

Armazene os ouvintes. Se vários chamadores solicitarem o mesmo cálculo antes de ele terminar, mantenha os callbacks deles em uma lista associada àquele cálculo. Quando o worker retornar, armazene o resultado e avise os chamadores que estão aguardando. Para um resultado em cache, programe o callback para ser executado depois que a função retornar ou, de outra forma, garanta um contrato consistente. Um timer com atraso zero pode adiar a execução, mas não é um relógio preciso.

Análise

Uma API assíncrona tem um contrato temporal, além de um contrato de dados. Manter consistente o momento em que os callbacks são chamados evita que os chamadores precisem lidar com casos distintos para resultados em cache e sem cache, um problema estreitamente relacionado à reentrância em sistemas orientados a eventos. Armazenar ouvintes também expressa a dependência real: esses chamadores estão aguardando um resultado, não perguntando repetidamente se ele já chegou. Às vezes, a consulta repetida é necessária quando uma interface não oferece nenhum mecanismo de notificação, mas deve ser uma solução alternativa deliberada, não o padrão de projeto.

Trate as falhas assíncronas quando os callbacks forem chamados, não em torno da chamada que agenda a tarefa

O `catch` externo chega cedo demais. Um `try/catch` em torno de `setTimeout` não consegue capturar uma exceção lançada dentro de seu callback, porque o callback é executado mais tarde, depois que a pilha de chamadas original terminou. O mesmo princípio se aplica a outras operações assíncronas. Em APIs no estilo Node, os callbacks costumam receber um erro como primeiro argumento, o que dá a eles a oportunidade de tratar a falha quando o resultado chega. Bibliotecas de navegador podem oferecer, em vez disso, manipuladores separados para sucesso e falha.

Defina quem responde pelos erros. O livro recomenda tratar falhas comuns perto de sua origem: exibir um erro, tentar novamente ou escolher outra resposta apropriada. Manipuladores globais, como `window.onerror` no navegador ou os mecanismos do Node para exceções não capturadas, são apresentados como ferramentas de depuração ou último recurso, não como planos rotineiros de recuperação. Lançar uma exceção dentro de um callback assíncrono geralmente encaminha o erro aos mecanismos do ambiente para erros não capturados.

Análise

Esta é uma regra útil sobre limites: um erro deve ser tratado por código que ainda tenha contexto suficiente para tomar uma decisão significativa. Isso se assemelha aos sistemas distribuídos, nos quais uma solicitação pode falhar depois que a função que a iniciou já retornou; por isso, a falha precisa percorrer um canal explícito. Tratar erros como dados do callback torna esse canal visível, embora também responsabilize cada chamador por não ignorar falhas silenciosamente. Um manipulador global pode registrar uma falha, mas registrá-la não é o mesmo que restaurar um estado válido da aplicação.

Use publicação/assinatura para distribuir eventos, mas verifique se a entrega é síncrona

Um evento, muitos ouvintes. PubSub, abreviação de publicação/assinatura, permite que um objeto anuncie um evento nomeado ao qual vários manipuladores independentes respondem. O `EventEmitter` do Node, os modelos com eventos do Backbone e o sistema de eventos do jQuery são exemplos apresentados no livro. Um editor de documentos, por exemplo, pode reagir a uma tecla pressionada atualizando a exibição, a contagem de palavras, o histórico de desfazer e a sincronização com o servidor, sem enfiar todas essas tarefas em um único manipulador enorme.

Um evento não é necessariamente assíncrono. Acionar um evento do jQuery a partir do código da aplicação executa seus manipuladores imediatamente, em sequência. Um manipulador que aciona o mesmo evento pode criar um ciclo infinito. Os modelos do Backbone publicam alterações quando são atualizados por meio de seus métodos, e as coleções podem retransmitir essas alterações. Eventos personalizados do jQuery podem se propagar pelo DOM, por isso a propagação de eventos e a estrutura da aplicação precisam de limites bem definidos.

Análise

PubSub reduz as dependências diretas: quem produz o evento não precisa conhecer todos os ouvintes nem a ordem em que os recursos foram adicionados. Isso se assemelha às arquiteturas orientadas a mensagens, nas quais os componentes se coordenam por sinais nomeados, em vez de chamadas diretas. A contrapartida é que o grafo de dependências fica menos visível. Uma alteração pode acionar vários ouvintes, possivelmente por propagação ou retransmissão, e manipuladores síncronos ainda podem monopolizar a execução. Por isso, nomes de eventos, responsabilidades claras e prevenção de ciclos não são detalhes cosméticos. São o que impede que o desacoplamento se transforme em um emaranhado invisível.

Use Promises para tarefas de execução única e mantenha em privado o poder de resolvê-las

Uma Promise representa um resultado. O livro define uma Promise como um objeto que armazena callbacks para uma tarefa assíncrona de execução única, como uma solicitação Ajax, que pode ter sucesso ou falhar. Na terminologia do jQuery, `done` trata do sucesso, `fail` trata da falha e `always` trata de qualquer um dos resultados. Uma Promise pendente torna-se resolvida ou rejeitada uma única vez e, depois disso, não muda de estado. Algumas versões também oferecem notificações de progresso enquanto o trabalho continua pendente.

Separe o controle da observação. Um `Deferred` do jQuery é uma Promise com métodos como `resolve` e `reject`, que permitem a quem o controla definir seu resultado. Chamar o método `promise` fornece a outras partes do programa uma interface somente para leitura: elas podem adicionar manipuladores, mas não decidir o resultado da tarefa. Essa distinção favorece o encapsulamento, seja a operação uma chamada Ajax, uma animação ou a escolha de uma opção por parte de uma pessoa usuária.

Análise

A distinção entre um Deferred e sua Promise é um pequeno exemplo de projeto baseado em capacidades: cada componente recebe apenas a autoridade de que precisa. Quem controla a tarefa pode alterar seu estado, enquanto os observadores podem reagir sem interferir. Isso torna a coordenação mais segura e também esclarece quem é responsável quando a conclusão demora. O livro aborda a terminologia e a API específicas do jQuery, portanto seus detalhes não devem ser confundidos com um padrão universal de Promise. A ideia duradoura é separar o controle de uma tarefa da observação de seu resultado eventual.

Componha cadeias e junções de Promises em vez de aninhar callbacks dependentes

Use uma cadeia para expressar dependências. Na API do jQuery apresentada no livro, `pipe` cria uma nova Promise com base no resultado de um callback. Se o callback iniciar outra tarefa que produza uma Promise, a nova Promise acompanhará essa tarefa. Assim, uma sequência como buscar dados, enviá-los a outro lugar e, em seguida, fazer uma solicitação final pode ser representada como uma cadeia, em vez de callbacks escondidos dentro de outros callbacks. As falhas podem percorrer a cadeia quando nenhum manipulador de recuperação altera o resultado.

Use uma junção para trabalho paralelo. `$.when` combina Promises, resolvendo-se quando todas as tarefas fornecidas têm sucesso e sendo rejeitada se alguma falhar. O exemplo consiste em iniciar um jogo somente depois que os dados do servidor forem carregados e o vídeo tutorial terminar. O livro alerta que pode ser complicado desempacotar todos os argumentos combinados dos callbacks; por isso, os resultados podem ser coletados em cada Promise individual antes da junção.

Análise

Essas operações transformam tarefas assíncronas em uma pequena álgebra. Uma cadeia expressa dependência, enquanto uma junção expressa uma condição que várias tarefas independentes precisam satisfazer. Isso vai além de simplificar a sintaxe: torna possível inspecionar a estrutura de um fluxo de trabalho. Uma nuance importante é que uma Promise combinada que relata uma falha não necessariamente cancela o restante do trabalho já em andamento. A composição organiza a observação e o fluxo dos resultados, mas cancelamento, limpeza e políticas de novas tentativas ainda exigem um projeto explícito. O livro também enfatiza que bibliotecas de Promise podem se comportar de maneiras diferentes; misturar suas convenções sem cuidado prejudica a clareza que a composição deveria proporcionar.

Escolha execução em série, paralela ou filas limitadas conforme a ordem e a capacidade

Escolha primeiro a política de execução. Async.js oferece operações para coleções e executores de tarefas voltados a padrões comuns. Os métodos de série executam as tarefas uma após a outra, preservando a ordem e evitando solicitações de I/O simultâneas em excesso. Os métodos paralelos iniciam as tarefas ao mesmo tempo e reúnem os resultados na ordem da lista de tarefas, mesmo que elas terminem em outra ordem. Na demonstração com timers do livro, três tarefas que levam cerca de 100, 300 e 200 milissegundos demoram aproximadamente 600 milissegundos em série e cerca de 300 milissegundos em paralelo.

Limite a concorrência quando necessário. `async.queue` aceita tarefas à medida que chegam e executa um worker até um limite de concorrência escolhido. É útil quando há muitos arquivos ou solicitações e o trabalho paralelo ilimitado poderia sobrecarregar um recurso. O callback de conclusão sinaliza que a fila foi esvaziada, mas a ordenação e a coleta dos resultados ficam a cargo da aplicação. A biblioteca Step, mais enxuta, oferece uma alternativa mais minimalista.

Análise

A decisão importante não é simplesmente se o trabalho paralelo é mais rápido. É se a ordem, a vazão e os limites de recursos são adequados à tarefa. Uma fila limitada é uma forma elementar de controle de fluxo: impede que um produtor transforme todas as operações disponíveis em carga simultânea. Essa ideia aparece em toda a engenharia de sistemas, de pools de conexões com bancos de dados a serviços de rede. Uma fila ainda pode ocultar questões operacionais, como o efeito das falhas sobre as tarefas restantes ou a forma de indexar os resultados. Escolher o método da biblioteca é apenas o primeiro passo; a aplicação também precisa definir essas políticas.

Envie o trabalho pesado para workers isolados e troque mensagens de forma deliberada

Mantenha os cálculos dispendiosos fora da thread principal. Os Web Workers do navegador podem executar tarefas exigentes, como analisar código ou decodificar vídeo, sem bloquear a interação com a página. Um worker não pode manipular o DOM nem inspecionar os objetos da thread principal. Em vez disso, os dois lados trocam mensagens, e os objetos são copiados por serialização, em vez de serem compartilhados diretamente. Isso preserva o modelo do livro baseado em eventos e, ao mesmo tempo, permite executar trabalho em outra thread.

Use os núcleos por meio da separação. A abordagem `cluster` do Node inicia processos workers, comumente um por núcleo da CPU, e um processo mestre os coordena. Os workers se comunicam por mensagens, sem compartilhar livremente o estado da aplicação. O livro recomenda limitar a comunicação entre workers e, quando apropriado, colocar o estado compartilhado em um armazenamento externo. Workers ajudam quando as tarefas podem ser divididas em partes em grande medida independentes; os custos de comunicação e cópia de dados fazem deles uma escolha inadequada para toda carga de trabalho.

Análise

A troca de mensagens envolve uma escolha: o isolamento facilita o raciocínio sobre a coordenação, mas a comunicação acrescenta custos e torna explícitos os limites dos dados. Isso se assemelha a sistemas no estilo de atores, em que unidades independentes recebem mensagens em vez de modificar memória compartilhada. Essa abordagem é especialmente atraente para cálculos dispendiosos que podem ser separados com clareza. A ressalva é importante: mover trabalho para outro worker não garante uma aplicação mais rápida se a serialização, a coordenação ou a desigualdade no tamanho das tarefas dominarem o processo. A pergunta certa é se o trabalho pode ser dividido com pouca comunicação o suficiente.

Carregue scripts conforme a urgência, a independência e a ordem das dependências

Não transforme todos os scripts em bloqueios. Um script normal pode atrasar a renderização enquanto é baixado e executado. O livro recomenda manter no início o código essencial à renderização e tirar do caminho crítico os scripts menos urgentes. No contexto de navegador que descreve, `defer` permite que um script seja baixado enquanto o documento carrega e, depois, executa os scripts adiados em ordem, quando o documento estiver pronto. Scripts com `async` são executados assim que ficam disponíveis, sem uma ordem garantida; por isso, são mais adequados a widgets independentes do que a scripts com dependências.

Escolha um carregador conforme a complexidade. O carregamento programático pode buscar um script somente quando um recurso ou uma condição o exigir. O livro apresenta yepnope para carregamento condicional leve e Require.js para grafos de dependências maiores, usando a definição assíncrona de módulos (Asynchronous Module Definition, AMD). Essas ferramentas e suas suposições de compatibilidade são da época de 2012. A lição duradoura é explicitar a prioridade e as dependências dos scripts, em vez de depender de uma ordem de download acidental.

Análise

O carregamento de scripts é um problema de escalonamento na escala da página: uma página rápida depende de qual trabalho bloqueia o primeiro uso, não apenas de quantos arquivos ela contém. A distinção entre dependências ordenadas e trabalho independente é a mesma usada na composição de Promises e nas filas de tarefas. O carregamento dinâmico também pode reduzir o trabalho que a pessoa usuária nunca precisa realizar, mas introduz modos de falha, como a solicitação de um recurso antes que seu código esteja pronto. As APIs e bibliotecas de navegador citadas refletem a época de publicação do livro. O princípio de priorização continua útil mesmo quando o ecossistema de carregamento específico muda.

Análise

A contribuição mais forte de Burnham é uma taxonomia prática do trabalho assíncrono. Os eventos descrevem como algo tem a oportunidade de ser executado. PubSub descreve como um evento chega a vários ouvintes. Promises descrevem o resultado eventual de uma tarefa. Os utilitários de controle de fluxo descrevem quantas tarefas são executadas, em que ordem e com que nível de concorrência. Workers transferem trabalho adequado para contextos de execução isolados, enquanto os carregadores de scripts decidem qual código deve ficar disponível e quando. Essas camadas resolvem problemas diferentes, e grande parte da confusão com callbacks surge quando se espera que uma camada faça o trabalho de outra.

A narrativa do livro começa com a aparente maldição do JavaScript de thread única e, em seguida, mostra como essa restrição pode se tornar uma vantagem de projeto. Callbacks enfileirados evitam interrupções durante a execução de um manipulador, mas o texto também demonstra onde termina essa tranquilidade: callbacks podem ser executados de forma síncrona quando o caminho usa dados em cache, eventos podem formar ciclos e resultados podem chegar em ordens inesperadas. A lição mais profunda não é que o JavaScript elimine os perigos da concorrência. É que ele torna explícitos muitos limites de estado e de escalonamento, desde que as APIs mantenham uma temporização consistente e contratos claros para erros.

O conselho mais duradouro é, portanto, arquitetural, não específico de uma biblioteca: evite consultas repetidas, impeça que o aninhamento de callbacks carregue todo o fluxo de trabalho, separe quem publica eventos de quem os assina e escolha um padrão de controle de fluxo adequado à tarefa. Uma cadeia de Promises não é uma fila com limites de capacidade; PubSub não é inerentemente assíncrono; um worker não equivale a paralelismo com memória compartilhada. Preservar essas distinções facilita a análise de sistemas assíncronos.

O livro é explicitamente um guia de 2012. Seus exemplos se baseiam no comportamento então vigente das Promises do jQuery, nas convenções do Node, nas estimativas de suporte dos navegadores e nas bibliotecas de carregamento de scripts. Esses detalhes devem ser vistos como um retrato histórico, não como uma referência atual de APIs. Ainda assim, as abstrações sobrevivem às mudanças de sintaxe e ferramentas porque tratam de questões recorrentes: quem é responsável por um resultado, quem trata uma falha, o que precisa acontecer primeiro e quanto trabalho simultâneo é seguro. Por isso, o livro continua valioso como forma de pensar, mesmo que as ferramentas que nomeia tenham envelhecido.

Resumo em 30 Segundos
O JavaScript executa callbacks enfileirados em uma única thread principal; por isso, tarefas longas atrasam as respostas, e temporizadores não podem interromper o código em execução. Manter a temporização dos callbacks consistente evita que resultados em cache se comportem de maneira diferente dos resultados mais demorados, enquanto tratar os erros no ponto em que os resultados chegam mantém as falhas ligadas à sua origem. Promessas representam resultados de uma única execução e facilitam a composição de tarefas dependentes ou paralelas. Execução em série, em paralelo e filas com limite controlam a ordem e a capacidade das tarefas. Workers transferem tarefas que exigem muito da CPU para fora da thread principal, mas é preciso levar em conta os custos de comunicação e o isolamento.
Contém spoilers

Última atualização:

Reportar Problema

Resumo das Resenhas

4.00 de 5
Média de 204 avaliações do Goodreads e Amazon.

Async JavaScript recebe avaliações majoritariamente positivas, com leitores elogiando sua abordagem focada na programação assíncrona. Muitos o consideram informativo e esclarecedor, destacando sua cobertura de filas de eventos, promessas e Web Workers. Os leitores apreciam a concisão do livro e sua capacidade de aprimorar a compreensão do modelo de thread única do JavaScript. Alguns o criticam por estar desatualizado ou não apresentar exemplos aprofundados, mas, no geral, ele é recomendado a quem deseja aprimorar suas habilidades em JavaScript, especialmente para lidar com operações assíncronas e criar aplicativos mais responsivos.

Sua avaliação:
4.47
122 avaliações
Quer ler o livro completo?

Glossário

laço de eventos (event loop)

executa callbacks enfileirados

O mecanismo descrito no livro pelo qual o JavaScript conclui sua execução atual antes de tratar eventos enfileirados que estejam prontos. Temporizadores, entradas do usuário e outras fontes de eventos podem deixar callbacks prontos para execução, mas esses callbacks não interrompem o código que já está em execução. Portanto, um trabalho síncrono de longa duração atrasa o tratamento de eventos e pode deixar um aplicativo sem resposta.

publicação/assinatura (PubSub)

distribui eventos nomeados

Abreviação de publicação/assinatura, PubSub é um padrão no qual um objeto anuncia um evento nomeado, ao qual qualquer número de manipuladores registrados pode responder. Entre os exemplos do livro estão o EventEmitter do Node, os modelos com eventos do Backbone e os eventos do jQuery. PubSub reduz as conexões diretas entre componentes, mas não garante a entrega assíncrona.

promessa (Promise)

representa o resultado de uma tarefa

Uma promessa (Promise) é um objeto que representa uma tarefa assíncrona e contém callbacks para seu resultado eventual. Na API do jQuery discutida no livro, é possível anexar manipuladores para sucesso, falha ou ambos. Uma promessa também permite composição, possibilitando representar tarefas dependentes ou aguardar várias operações em conjunto.

Deferred

controla o resultado de uma promessa

Na terminologia do jQuery usada no livro, um Deferred é uma promessa com métodos adicionais que permitem a quem o criou resolvê-la ou rejeitá-la e, às vezes, enviar notificações de progresso. Seu método promise expõe uma interface somente para observação. Manter o Deferred privado permite que outras partes do aplicativo anexem manipuladores sem controlar quando a tarefa é concluída.

pirâmide da desgraça (Pyramid of Doom)

callbacks profundamente aninhados

Nome dado pelo livro ao código assíncrono que aninha cada novo callback dentro do callback anterior. À medida que se acumulam etapas sequenciais, a indentação e o fluxo de controle ficam difíceis de acompanhar e ampliar. O livro recomenda callbacks nomeados, distribuição de eventos, promessas e utilitários de controle de fluxo para tornar a sequência mais administrável.

async.queue

limita tarefas simultâneas

Um utilitário do Async.js que aceita tarefas dinamicamente e executa uma função de trabalho para processá-las, até um limite de simultaneidade especificado. As tarefas aguardam até que haja uma vaga disponível para um trabalhador. A fila pode sinalizar quando fica vazia ou termina de ser processada, mas o aplicativo precisa gerenciar a coleta e a ordenação dos resultados quando isso for importante.

Web Workers

executam tarefas isoladas no navegador

Os workers do navegador executam JavaScript fora da thread principal da página, sendo úteis para cálculos exigentes que, de outro modo, atrasariam a interação. Eles não podem manipular diretamente o DOM nem acessar os objetos da thread principal. A comunicação ocorre por meio de mensagens, e os dados são copiados em vez de compartilhados livremente.

definição assíncrona de módulos (Asynchronous Module Definition, AMD)

declara dependências de scripts

AMD é um formato de módulos descrito no livro para aplicativos de navegador. Um módulo declara suas dependências e fornece um callback que as recebe quando são carregadas. Um carregador como o Require.js pode usar essas declarações para buscar scripts em paralelo e executá-los na ordem determinada pelas dependências.

Perguntas Frequentes

Sobre o que trata "Async JavaScript", de Trevor Burnham?

  • Foco em JavaScript assíncrono: O livro é dedicado a compreender e dominar o JavaScript assíncrono, essencial para criar aplicativos web responsivos.
  • Concorrência e tratamento de eventos: Explora como lidar com concorrência e tarefas assíncronas de forma eficaz, sem se deixar sobrecarregar pela complexidade.
  • Exemplos práticos: O livro apresenta exemplos práticos e trechos de código que ilustram como implementar padrões assíncronos tanto no JavaScript do lado do cliente quanto no do lado do servidor.
  • Guia abrangente: Serve como um guia abrangente para desenvolvedores de JavaScript de nível intermediário que desejam aprofundar sua compreensão da programação assíncrona.

Por que devo ler "Async JavaScript", de Trevor Burnham?

  • Melhore a responsividade: Aprenda a criar aplicativos mais responsivos gerenciando operações assíncronas com eficácia.
  • Evite armadilhas comuns: O livro ajuda a evitar armadilhas comuns do JavaScript assíncrono, como o inferno dos callbacks e as condições de corrida.
  • Aprimore suas habilidades em JavaScript: É um excelente recurso para desenvolvedores de nível intermediário que desejam aprimorar suas habilidades em JavaScript, especialmente no tratamento de tarefas assíncronas.
  • Insights práticos: Obtenha insights e técnicas práticas que podem ser aplicados diretamente a projetos reais, melhorando a qualidade e o desempenho do código.

Quais são os principais aprendizados de "Async JavaScript", de Trevor Burnham?

  • Compreensão dos eventos: Um estudo aprofundado do modelo de eventos do JavaScript e de como eventos assíncronos são agendados e tratados.
  • Promessas e Deferreds: Aprenda sobre promessas e Deferreds, essenciais para gerenciar operações assíncronas de maneira mais estruturada.
  • Bibliotecas de controle de fluxo: Introdução a bibliotecas como Async.js e Step, que ajudam a gerenciar fluxos assíncronos complexos.
  • Multithreading com workers: Explore como usar Web Workers e workers do Node.js para aproveitar o multithreading em aplicativos JavaScript.

Como "Async JavaScript" explica os eventos do JavaScript?

  • Elegância conceitual: O livro explica que os eventos do JavaScript são conceitualmente elegantes e práticos, permitindo a execução ininterrupta do código.
  • Agendamento de eventos: Aborda como os eventos são agendados e executados em JavaScript, enfatizando a natureza de thread única da linguagem.
  • Fila de eventos: O livro descreve o mecanismo da fila de eventos, na qual os eventos são enfileirados e executados sequencialmente quando a pilha de execução atual fica livre.
  • Exemplos práticos: Apresenta exemplos práticos que ilustram como tratar eventos e evitar problemas comuns, como a "pirâmide da desgraça".

O que são promessas e Deferreds em "Async JavaScript"?

  • Definição de promessas: Promessas são objetos que representam uma tarefa com dois resultados possíveis: sucesso ou falha, permitindo o tratamento estruturado de operações assíncronas.
  • Deferreds como superconjuntos: Um Deferred é um superconjunto de uma promessa, que oferece métodos adicionais para provocar mudanças de estado na promessa.
  • Benefícios do encapsulamento: Promessas permitem encapsular melhor as tarefas assíncronas, facilitando o gerenciamento de vários callbacks e reduzindo a duplicação de código.
  • Combinação de promessas: O livro explica como combinar promessas para gerenciar fluxos assíncronos complexos, como aguardar a conclusão de várias tarefas.

Como "Async JavaScript" aborda o controle de fluxo com Async.js?

  • Visão geral do Async.js: Async.js é apresentado como uma biblioteca poderosa para gerenciar fluxos assíncronos, especialmente em ambientes Node.js.
  • Métodos para coleções: O livro aborda métodos do Async.js para coleções, como forEach, map e filter, que simplificam o tratamento de arrays de tarefas assíncronas.
  • Organização de tarefas: Explica como organizar tarefas com métodos como series, parallel e queue para controlar a ordem de execução e a simultaneidade.
  • Tratamento de erros: Aborda a forma como o Async.js trata erros, mostrando como eles são propagados por callbacks até um manipulador final.

Qual é o papel dos Web Workers em "Async JavaScript"?

  • Solução de multithreading: Web Workers são apresentados como uma solução para aproveitar o multithreading em JavaScript sem compartilhar estado entre threads.
  • Execução separada: Workers executam código em threads separadas, permitindo cálculos complexos sem bloquear a thread principal.
  • Troca de mensagens: O livro explica como se comunicar com workers por meio da troca de mensagens, preservando a natureza orientada a eventos do JavaScript.
  • Aplicações práticas: São apresentados exemplos de aplicações práticas para Web Workers, como decodificação de vídeo e análise de dados.

Como "Async JavaScript" sugere tratar o carregamento assíncrono de scripts?

  • Desafios do carregamento de scripts: O livro aborda os desafios do carregamento de scripts, como scripts que bloqueiam ou não bloqueiam a execução e seu impacto no desempenho da página.
  • Atributos do HTML5: Apresenta atributos do HTML5 como async e defer para otimizar o carregamento de scripts e a ordem de execução.
  • Bibliotecas de carregamento de scripts: Bibliotecas como yepnope e Require.js são abordadas em cenários mais avançados de carregamento de scripts, incluindo o carregamento condicional e modular.
  • Otimização de desempenho: Enfatiza a importância de otimizar o carregamento de scripts para melhorar o tempo de carregamento da página e a experiência do usuário.

Quais são as melhores citações de "Async JavaScript" e o que significam?

  • "O JavaScript agora funciona." Essa citação destaca a evolução do JavaScript: de uma linguagem frequentemente criticada por suas limitações a uma ferramenta poderosa para o desenvolvimento web.
  • "Qualquer aplicativo que possa ser escrito em JavaScript acabará sendo escrito em JavaScript." Conhecida como Lei de Atwood, essa citação ressalta a onipresença e a versatilidade do JavaScript em diferentes plataformas e aplicativos.
  • "Adoro programação assíncrona, mas não consigo programar assim." Essa citação reflete a frustração comum com o inferno dos callbacks e a necessidade de técnicas melhores para gerenciar a programação assíncrona.
  • "Vamos provar ao mundo que até os problemas mais complexos podem ser resolvidos com código JavaScript limpo e de fácil manutenção." Essa citação resume a missão do livro de capacitar desenvolvedores a escrever JavaScript assíncrono eficiente e de fácil manutenção.

Como "Async JavaScript" explica o uso de PubSub?

  • Padrão PubSub: O livro apresenta o padrão de publicação/assinatura (PubSub) como uma forma de distribuir eventos por um aplicativo.
  • EventEmitter no Node.js: Explica como o EventEmitter do Node.js oferece um mecanismo PubSub integrado para tratar eventos.
  • Modelos com eventos: Discute o uso de modelos com eventos em frameworks como Backbone.js para gerenciar mudanças no estado do aplicativo e disparar eventos.
  • Eventos personalizados do jQuery: O livro também aborda como usar eventos personalizados do jQuery para distribuir eventos relacionados ao DOM com eficiência.

Quais são as aplicações práticas dos conceitos de "Async JavaScript"?

  • Aplicativos web responsivos: Os conceitos ajudam a criar aplicativos web mais responsivos por meio do gerenciamento eficiente de tarefas assíncronas.
  • JavaScript no lado do servidor: Técnicas como promessas e Async.js podem ser usadas em ambientes JavaScript do lado do servidor, como o Node.js, para lidar com operações de E/S.
  • Tratamento complexo de eventos: O livro apresenta estratégias para lidar com arquiteturas complexas orientadas a eventos, facilitando o gerenciamento de aplicativos de grande escala.
  • Otimização de desempenho: Ao compreender e aplicar padrões assíncronos, desenvolvedores podem otimizar o desempenho e melhorar a experiência do usuário em aplicativos web.

Quais recursos "Async JavaScript" recomenda para continuar aprendendo?

  • JavaScript Weekly: O livro recomenda o JavaScript Weekly para acompanhar as últimas notícias e tendências relacionadas ao JavaScript.
  • Codecademy e CodeSchool: Essas plataformas são sugeridas para tutoriais e cursos interativos sobre JavaScript e tecnologias relacionadas.
  • Eloquent JavaScript: O livro "Eloquent JavaScript", de Marijn Haverbeke, é recomendado como uma introdução formal ao JavaScript.
  • Mozilla Developer Network: Para documentação e recursos confiáveis sobre JavaScript, o livro recomenda o Mozilla Developer Network (MDN).

Sobre o Autor

Trevor Burnham é o autor de "Async JavaScript", livro que recebeu bastante atenção na comunidade de programação. O trabalho de Burnham se concentra em abordar um dos aspectos mais desafiadores da programação em JavaScript: a assincronicidade sem concorrência. Sua abordagem é descrita como bastante focada, mas muito informativa, oferecendo novos insights aos leitores em quase todas as páginas. Seu estilo de escrita se destaca pela acessibilidade, tornando temas complexos mais fáceis de compreender. Burnham incorpora referências culturais e exemplos práticos para ilustrar seus pontos. Embora alguns leitores mencionem que certos exemplos poderiam ser explicados com mais detalhes, sua experiência no assunto fica evidente ao longo do livro.

Baixar PDF

Para guardar este resumo de Async JavaScript para depois, baixe o PDF grátis. Você pode imprimi-lo ou ler offline quando quiser.
Download PDF

Baixar EPUB

Para ler este resumo de Async JavaScript no seu dispositivo ou aplicativo de leitura, baixe o EPUB grátis. O formato digital .epub é ideal para ler e-books em celulares, tablets e leitores digitais.
Download EPUB
Quer ler o livro completo?
Seguir
Ouvir
Início
Swipe
Biblio
App
Experimente o Acesso Completo por 3 Dias
Ouça, salve e muito mais
Comparar Recursos Gratuito Pro
📖 Ler Resumos
Leia resumos ilimitados. Usuários gratuitos recebem 3 por mês
🎧 Ouvir Resumos
Ouça resumos ilimitados em 40 idiomas
—
❤️ Favoritos Ilimitados
Usuários gratuitos são limitados a 4
—
📜 Histórico Ilimitado
Usuários gratuitos são limitados a 4
—
📥 Downloads Ilimitados
Usuários gratuitos são limitados a 1
—
Cronograma Sem Risco
Hoje: Acesso Imediato
Ouça resumos completos de mais de 26.000 livros. São mais de 12.000 horas de áudio!
Dia 2: Lembrete do Teste
Enviaremos uma notificação avisando que seu teste está acabando.
Dia 3: Sua assinatura começa
A cobrança será feita em 24 de nov.,
cancele a qualquer momento antes.
Consume 2.8× More Books
2.8× mais livros Audição Leitura
Nossos usuários nos amam
1M+ leitores
Trustpilot Rating
TrustPilot
4.6 Excelente
Este site é revolucionário. Tenho lido resumos de livros como nunca antes. Recomendo muito, muito mesmo.
— Dave G
Vale o meu dinheiro e tempo, e muito bem feito. Nunca vi essa qualidade de resumos em outros sites. Muito útil!
— Em
Altamente recomendado!! Serviço fantástico. Perfeito para quem quer algo além de uma prévia, mas sem todos os detalhes de um audiolivro completo.
— Greg M
Economize 62%
Anual
$119.88 $44.99/ano/ano
$3.75/mês
Mensal
$9.99/mês
Iniciar Teste Gratuito de 3 Dias
3 dias grátis, depois $44.99/ano. Cancele quando quiser.
Unlock a world of fiction & nonfiction books
Mais de 26.000 livros pelo preço de 2 livros
Leia qualquer livro em 10 minutos
Descubra novos livros como no Tinder
Solicite qualquer livro se ainda não tiver resumo
Leia mais livros do que qualquer pessoa que você conhece
App nº 1 para amantes de livros
Lifelike & immersive summaries
Garantia de reembolso de 30 dias
Baixe resumos em EPUB ou PDF
Cancele a qualquer momento em poucos cliques

Por que só um resumo?

Scanner
Encontre um código de barras para escanear

⭐
⭐
⭐
Temos um presente especial para si
Abrir
38% de desconto
DESCONTO PARA VOCÊ
⭐
⭐
⭐
$79.99
$49.99/ano
Apenas $4.16 por mês
Continuar
Comece com 2 toques e cancele com facilidade
Configurações
Geral
Widget
Carregando...