No, ho cancellato giochi a scacchi?
Cadere di nuovo perché hai concluso che è un modulo di aggiornamento rapido.
Mi tufferò nel concetto di non registrazione e questo è come lavorare con un codice sincrono.
E per questo, prima di tutto dobbiamo capire cos'è il codice asincrono.
Diciamo che ho impostato un timer con set timeout, che è una funzione integrata nel nodo J.
S lì.
Definiamo una funzione che dovrebbe essere eseguita dopo che un certo timer è scaduto.
Qui, userò una funzione freccia.
È possibile utilizzare una funzione con nome, qualunque cosa tu voglia.
Il secondo argomento è il timer.
Diciamo due secondi.
Lo esprimi in millisecondi.
Quindi due secondi sono duemila millisecondi nel loro.
Tutto semplicemente bloccato.
Il timer è terminato.
Se ora eseguo questo file per due secondi, non succede nulla e poi vediamo che Taimur è fatto.
Ora questo è un codice asincrono perché non termina immediatamente e sarebbe anche un codice di invio se
avessimo un millisecondo lì.
Quindi, se è super veloce, non accade immediatamente nel nostro passaggio di codice.
È come se avessimo il blocco della console.
Ciao.
E registro della console.
Ciao, questi due frammenti sono codice Synchronoss perché vengono eseguiti uno dopo l'altro, eppure tecnicamente,
ovviamente, Noad impiegherà del tempo per eseguirli.
Ma non ci sono ritardi diversi dal tuo hardware.
Per così dire, e quindi fa un codice Synchronoss.
Questo è un codice malato, asincrono perché non viene eseguito o terminato immediatamente.
Ci vuole un po 'di tempo, anche se così corto.
E infatti, se eseguo questo file in questo modo, vedi helo e high prima di vedere Taimur fatto, anche
se è super veloce perché non c'è G. S. e JavaScript in generale non blocca l'esecuzione del codice fino a quando
non viene eseguito.
In effetti, qui riconoscerà questa cosiddetta funzione di callback.
Quindi una funzione dovrebbe essere eseguita.
In futuro, dovrebbe essere richiamato più tardi una volta terminato.
Quindi una volta scaduto questo timer, lo riconoscerà e passerà immediatamente alla riga successiva
ed eseguirà tutto il codice sincrono e quindi eseguirà il codice asincrono.
Una volta fatto questo, ecco perché vediamo prima quanto in basso e in alto, anche se nel nostro codice il tempo è stato
stampato per primo.
E questo è un concetto cruciale che devi capire in JavaScript e soprattutto nel nodo.
E ci tornerò su tutto il corso perché è così importante.
Ora, quando si lavora con il debito e tutto aumenta a due secondi, di nuovo, per renderlo ancora più chiaro, vedrai
di nuovo il nostro codice di sincronizzazione eseguito.
E poi dopo due secondi, questo codice viene eseguito.
Quando si lavora con il codice asincrono, si ottengono più tecniche di pozzo, gestendolo.
La funzione di callback è una, la più antica, e la vedrai parecchio, in particolare nota G. S..
Non c'è niente di sbagliato in questo, ma dovrai affrontare un problema se hai un paio di operazioni asincrone dipendenti.
Quindi qui impostiamo il timer.
E ora diciamo che creo un'altra funzione.
Che chiamerò Fetch Data.
E lì, imposterò anche un timer, perché non voglio impostare una base di dati o qualcosa del genere da cui
prendiamo i dati, faremo tutto questo per tutto il corso.
Ovviamente.
Nessun problema.
Quindi, qui di nuovo, ho un altro timer che impiega circa un secondo e mezzo.
E ora qui in Fetch Data, ho bisogno di un modo, bene, di fare qualcosa.
Quando viene eseguito il timer interno?
Quindi qui mi aspetterò davvero un argomento che chiamerò richiamare, perché questo argomento sarà una
funzione.
Alla fine chiamerò la mia funzione interiore qui una volta che avrò finito con il timer.
E lì posso passare.
Fatto come valore conoscendo il luogo in cui un uso recupera i dati.
Diciamo che è dentro questo set.
Tempo.
Chiamata.
Chiamo il recupero dei dati come questo lì.
Ora devo passare e non richiamare mai più.
E qui.
Riceverò il testo passato dal callback nella mia funzione quando eseguito.
Quindi avremo un po 'di testo qui e potrò bloccarlo su console.
Ora, questo potrebbe sembrare confuso alla fine qui, sto creando la mia funzione, che ottiene un callback
in modo da poter definire una funzione che dovrebbe eseguire vuole che questo timer interno sia fatto da qualche altra parte.
Quindi da questo posto qui, fa è la funzione che viene effettivamente passata come callback.
E sto eseguendo quella funzione qui.
Ora, se lo conservo, lo eseguo.
Richiede due secondi, quindi questo tempo del timer è terminato.
E poi dopo un secondo e mezzo, vedo fatto.
Ora, se abbiamo un paio di chiamate asincrone annidate, come abbiamo fatto qui, andiamo sempre più in profondità da una prospettiva
di richiamata.
Ed è per questo che abbiamo sempre una funzione chiamata Promises, che possiamo usare.
Nessuna possibilità.
Ora, spesso utilizzeremo pacchetti di terze parti che già utilizzano promesse per noi.
Quindi la sintassi che ti mostrerò ora è quella che raramente devi scrivere da solo.
Ciò sarà fatto dai pacchetti dietro le quinte.
Comunque è bello sapere che hai creato una promessa.
All'interno della nostra funzione di recupero dati, diciamo.
Memorizzandolo in una costante o variabile e quindi utilizzando la nuova parola chiave, che si utilizza in JavaScript per
creare un nuovo oggetto basato su un costruttore.
Se le funzioni del costruttore sono qualcosa che non ti dice nulla.
Dai un'occhiata ad alcune risorse introduttive di base su JavaScript perché le funzioni di costruzione sono una caratteristica fondamentale
di JavaScript.
E qui ha usato la funzione di costruzione della promessa, che è integrata in JavaScript e non in G. S..
E in realtà accetta anche una richiamata, che arriva agli argomenti, risolve e rifiuta.
Potresti nominarli come vuoi, ma queste sono due funzioni.
E il primo completa la promessa con successo.
Lo risolve con successo.
Il secondo lo rifiuta, è come lanciare un errore.
Quindi prendi il tuo codice asincrono e lo trasferisci lì.
E ancora, raramente devi scriverlo da solo.
La maggior parte dei pacchetti lo fa già per te e ti dà la promessa finale, che fa tutta la magia
dietro le quinte nascosta da te.
Qui lo facciamo manualmente.
Quindi ora e papà richiamano.
Abbiamo il nostro set di funzioni.
Purtroppo, il timeout non ci fornisce un'API promettente.
Quindi qui tutti dobbiamo usare un callback.
Ma nel loro.
Ora sappiamo che non utilizziamo più alcuna funzione di callback che riceviamo.
Non ottengo alcun argomento qui e recuperato più dati.
Invece, qui risolvo.
Fatto, diciamo.
Quindi sono tornato con successo per risolvere il valore ora nel recupero dei dati.
Dopo aver definito la promessa, non ci resta che restituirla.
E tieni presente che questo è un codice sincrono.
Quindi in realtà questo verrà restituito immediatamente dopo che la promessa è stata creata prima di codificare
nell'esecuzione delle promesse, che accadrà qualche tempo dopo quando chiameremo effettivamente quella funzione.
E quando questa volta Odyn completa.
Quindi ora restituiamo questa promessa qui.
E nel luogo in cui chiamiamo dati recuperati, ora non passiamo più una richiamata.
Ma ora possiamo usare allora, che è richiamabile su una promessa e restituiamo una promessa.
E questo ci permette semplicemente di definire qui una funzione chiamata, che verrà eseguita una volta risolta
la promessa.
Ora, qual è il vantaggio di questo?
Se avessimo promesse multiple.
Quindi diciamo di nuovo un recupero di dati freddi e lì quindi non devo usare quindi in questo modo.
E quindi, finirei con nidificato.
Richiami di nuovo.
Ma invece, all'interno di una promessa e quindi il blocco fa parte di una promessa.
Posso semplicemente restituire una nuova promessa e quindi aggiungere la successiva e bloccare dopo la precedente.
Come questo.
Quindi ora abbiamo una catena, quindi blocchi.
Questo viene chiamato alla prima promessa, quindi nel blocco successivo restituisco un'altra promessa.
E anche se ciò non ci darebbe un incentivo promettente.
Quindi bloccare la restituzione lo convertirà in una promessa che si risolve immediatamente.
E poi aggiungiamo un altro blocco, che ora si riferisce a questa promessa qui.
E questo è più leggibile che avere callback infinitamente annidati.
Quindi ora se corro quello che vediamo.
Ciao.
Il timer è terminato.
Abbiamo fatto.
E lo vediamo di nuovo perché chiamo due volte i dati di recupero.
Quindi potrebbe essere difficile avvolgere la testa per la prima volta.
Lo riutilizzeremo.
Compensato questo corso e che diventerà più chiaro.
Ancora una volta, questo codice non è per lo più scritto da te, ma è un concetto cruciale che rende il nostro codice
asincrono più gestibile.
C'è sempre un altro modo di gestire questo asincrono.
Attendi due parole chiave speciali che puoi utilizzare nel moderno JavaScript e avrò una sezione separata su questo verso
la fine del corso.
Voglio introdurlo qui perché in realtà può essere più confuso di questa sintassi qui.
E voglio attenermi a questo.
Non introdurre troppe nuove funzionalità contemporaneamente allo stesso tempo.
Il codice asincrono è qualcosa che devi capire, però.
E se non è del tutto chiaro ormai, va bene, anche se lo vedrai per un corso alterato
un sacco, perché abbiamo molti eventi asincroni in nessuna possibilità.
E lo spiegherò più volte.
Spiegherò anche di nuovo le promesse.
Voglio solo assicurarti che tu l'abbia visto ormai e che tu abbia quindi la possibilità di capirlo,
come funziona e come lo affrontiamo.