Não, eu apaguei você joga xadrez?
Caia novamente porque você concluiu que é um módulo de atualização rápida.
Vou mergulhar no conceito de não gravar e é assim que se trabalha com um código síncrono.
E, para isso, primeiro precisamos entender o que é código assíncrono.
Digamos que eu defina um cronômetro com tempo limite definido, que é uma função incorporada ao nó J.
S lá.
Definimos uma função que deve ser executada após um certo cronômetro expirar.
Aqui, vou usar uma função de seta.
Você pode usar uma função nomeada, como quiser.
O segundo argumento é o cronômetro.
Digamos dois segundos.
Você o expressa em milissegundos.
Portanto, dois segundos são dois mil milissegundos.
Tudo simplesmente bloqueado.
O temporizador está pronto.
Se agora eu rodar este arquivo por dois segundos, nada acontece e então vemos que o Taimur está pronto.
Agora, esse é um código assíncrono, porque não termina imediatamente e até seria um código de envio se
tivéssemos um milissegundo lá.
Portanto, se for super rápido, isso não acontece imediatamente em nossa etapa de código.
É como se tivéssemos bloqueio do console.
Olá.
E log do console.
Olá, esses dois trechos são de código Synchronoss porque são executados um após o outro e, no entanto, tecnicamente,
é claro, o Noad levará algum tempo para executá-los.
Mas não há outro atraso além do seu hardware.
Por assim dizer, e, portanto, faz um código Synchronoss.
Este é um código inválido, assíncrono porque não é executado ou finalizado imediatamente.
Demora um pouco de tempo, mesmo que seja super curto.
E, de fato, se eu executar esse arquivo assim, você verá helo e high antes de ver Taimur pronto,
mesmo que seja super rápido porque não G. S. e o JavaScript em geral não bloqueia a execução do seu código até
que isso seja feito.
De fato, aqui ele reconhecerá essa chamada função de retorno de chamada.
Portanto, uma função deve ser executada.
No futuro, ele deve ligar mais tarde assim que estiver pronto.
Assim que esse timer expirar aqui, ele reconhecerá isso e passará imediatamente para a próxima
linha e executará todo o código síncrono e, em seguida, executará seu código assíncrono.
Uma vez feito isso, é por isso que vemos quão alto e baixo primeiro, mesmo que em nosso tempo de código
seja feito primeiro.
E esse é um conceito crucial que você precisa entender em JavaScript e, especialmente, em nós.
E voltarei a isso ao longo do curso porque é muito importante.
Agora, ao trabalhar com dívidas e tudo aumentar para dois segundos, novamente, para torná-lo ainda mais claro, você
verá novamente nosso código de sincronização.
E depois de dois segundos, esse código é executado.
Ao trabalhar com código assíncrono, obtemos várias técnicas de bem, manipulando-o.
A função de retorno de chamada é uma, a mais antiga, e você a verá bastante, especialmente a nota G. S ..
Não há nada errado com isso, mas você enfrentará um problema se tiver algumas operações assíncronas dependentes.
Então aqui ajustamos o cronômetro.
E agora, digamos que eu crie outra função.
O qual chamarei Buscar dados.
E lá também vou definir um cronômetro, porque não quero configurar alguma base de dados ou algo parecido de onde
buscamos dados, faremos tudo isso para todo o curso.
Claro.
Não se preocupe.
Então, aqui novamente, eu tenho outro temporizador, que leva cerca de um segundo e meio.
E agora aqui na Fetch Data, preciso de alguma maneira de, bem, fazer alguma coisa.
Quando termina o temporizador interno?
Então, aqui, na verdade, espero um argumento que chamarei de retorno, porque esse argumento será uma
função.
Acabarei chamando minha função interna aqui assim que terminar o cronômetro.
E aí eu posso passar.
Feito como um valor, sabendo o local onde um uso busca dados.
Digamos que esteja dentro deste conjunto.
Tempo.
Ligar.
Eu chamo buscar dados como esse lá.
Agora preciso passar e nunca mais ligar.
E aqui.
Receberei o texto passado pelo retorno de chamada em minha função quando executado.
Então, vamos pegar um texto aqui e eu posso consertar o bloqueio desse texto.
Agora, no final das contas, isso pode parecer confuso. Estou criando minha própria função, que recebe um retorno
de chamada para que eu possa definir uma função que deve ser executada, quer que esse timer interno seja feito de outro lugar.
Portanto, deste lugar aqui, does é a função que efetivamente é passada como retorno de chamada.
E eu estou executando essa função aqui.
Agora, se eu salvar isso, execute isso.
Demora dois segundos, e esse tempo do timer está concluído.
E depois de um segundo e meio, vejo que está feito.
Agora, se tivermos algumas chamadas assíncronas aninhadas, como temos aqui, nos aprofundaremos mais na perspectiva de retorno de
chamada.
E é por isso que sempre temos um recurso chamado Promessas, que podemos usar.
Sem chance.
Agora, geralmente usamos pacotes de terceiros que já usam promessas para nós.
Portanto, a sintaxe que mostrarei agora é uma que você raramente precisa escrever por conta própria.
Isso será feito pelos pacotes nos bastidores.
Ainda é bom saber que você cria uma promessa.
Dentro da nossa função de dados buscados, você está, digamos.
Armazenando-o em uma constante ou variável e, em seguida, usando a nova palavra-chave, que você usa em JavaScript para
criar um novo objeto com base em um construtor.
Se as funções do construtor são algo que não diz nada.
Confira alguns recursos básicos de introdução ao JavaScript, porque as funções de construtor são um recurso essencial no
JavaScript.
E aqui ele usou a função de construtor de promessas, que é incorporada ao JavaScript e não ao G. S ..
E na verdade também recebe uma chamada de volta, que recebe argumentos, resolve e rejeita.
Você pode nomeá-los como quiser, mas essas são duas funções.
E o primeiro completa a promessa com sucesso.
Resolve com sucesso.
O segundo o rejeita, o que é como lançar um erro.
Você pega seu código assíncrono e o move para lá.
E, novamente, você raramente precisa escrever isso sozinho.
A maioria dos pacotes já faz isso por você e oferece a promessa final, que faz toda
a mágica nos bastidores escondida.
Aqui fazemos isso manualmente.
Então agora e papai ligam de volta.
Nós temos nosso próprio conjunto de funções.
Infelizmente, o tempo limite não nos dá uma API promissora.
Então aqui todos nós temos que usar um retorno de chamada.
Mas na deles.
Agora sabemos que não usamos mais nenhuma função de retorno de chamada que obtemos.
Não tenho argumento aqui e busco mais dados.
Em vez disso, aqui eu resolvo.
Feito, digamos.
Então, voltei com sucesso para resolver o valor agora na busca de dados.
Depois de definir a promessa, basta devolvê-la.
E observe que este é um código síncrono.
Portanto, na verdade, isso será retornado imediatamente após a promessa ser criada antes para codificar a execução
das promessas, o que acontecerá algum tempo depois quando realmente chamarmos essa função.
E quando desta vez Odyn terminar.
Então agora retornamos essa promessa aqui.
E no local em que chamamos de dados buscados, agora não transmitimos mais um retorno de chamada.
Mas agora podemos usar então, que é exigível em uma promessa e retornamos uma promessa.
E isso simplesmente nos permite agora definir uma função chamada aqui, que será executada assim que a promessa
for resolvida.
Agora, qual é a vantagem disso?
Se tivéssemos várias dessas promessas.
Então, digamos que os dados são buscados a frio novamente e aí não preciso usá-los assim.
E, portanto, eu terminaria com aninhado.
Retornos de chamada novamente.
Mas, em vez disso, dentro de uma promessa e, em seguida, o bloco faz parte de uma promessa.
Posso apenas retornar uma nova promessa e, em seguida, adicionar o próximo bloco e depois o anterior.
Como isso.
Então agora temos uma corrente, depois bloqueia.
Este é chamado na primeira promessa, então no bloco então eu retorno outra promessa.
E mesmo que isso não nos desse um incentivo de promessa.
Em seguida, o bloqueio do retorno o converteria em uma promessa que resolve instantaneamente.
E então adicionamos outro bloco, que agora se refere a essa promessa aqui.
E isso é mais legível do que ter retornos de chamada infinitamente aninhados.
Então agora se eu correr o que vemos.
Olá.
Oi.
O temporizador está pronto.
Fizemos.
E vemos isso novamente, porque estou chamando a busca de dados duas vezes.
Portanto, isso pode ser difícil de entender pela primeira vez.
Vamos reutilizá-lo.
Cheio deste curso e que se tornará mais claro.
Novamente, esse código geralmente não é escrito por você, mas é um conceito crucial que torna nosso código assíncrono
mais gerenciável.
Sempre há outra maneira de gerenciar esse assíncrono.
Aguarde duas palavras-chave especiais que você pode usar no JavaScript moderno, e eu terei uma seção separada sobre isso
no final do curso.
Eu quero apresentá-lo aqui, porque na verdade pode ser mais confuso do que esta sintaxe aqui.
E eu quero me ater a este.
Não introduza muitos recursos novos ao mesmo tempo aqui.
O código assíncrono é algo que você precisa entender.
E se não estiver totalmente claro até agora, tudo bem, embora você o veja por um curso
alterado muito, porque temos muitos eventos assíncronos sem chance.
E eu vou explicar isso várias vezes.
Também vou explicar promessas novamente.
Eu só quero garantir que você já tenha visto isso até agora e que tenha uma chance de entender isso,
como funciona e como lidamos com isso.