1
00:00:02,260 --> 00:00:04,100
No, ho cancellato giochi a scacchi?

2
00:00:04,150 --> 00:00:08,590
Cadere di nuovo perché hai concluso che è un modulo di aggiornamento rapido.

3
00:00:09,010 --> 00:00:14,980
Mi tufferò nel concetto di non registrazione e questo è come lavorare con un codice sincrono.

4
00:00:15,520 --> 00:00:20,110
E per questo, prima di tutto dobbiamo capire cos'è il codice asincrono.

5
00:00:20,530 --> 00:00:25,340
Diciamo che ho impostato un timer con set timeout, che è una funzione integrata nel nodo J.

6
00:00:25,350 --> 00:00:26,850
S lì.

7
00:00:27,520 --> 00:00:31,380
Definiamo una funzione che dovrebbe essere eseguita dopo che un certo timer è scaduto.

8
00:00:31,870 --> 00:00:33,580
Qui, userò una funzione freccia.

9
00:00:33,880 --> 00:00:36,100
È possibile utilizzare una funzione con nome, qualunque cosa tu voglia.

10
00:00:37,060 --> 00:00:38,620
Il secondo argomento è il timer.

11
00:00:38,650 --> 00:00:39,850
Diciamo due secondi.

12
00:00:40,090 --> 00:00:41,710
Lo esprimi in millisecondi.

13
00:00:41,830 --> 00:00:46,250
Quindi due secondi sono duemila millisecondi nel loro.

14
00:00:47,540 --> 00:00:48,190
Tutto semplicemente bloccato.

15
00:00:48,260 --> 00:00:49,710
Il timer è terminato.

16
00:00:52,670 --> 00:00:58,490
Se ora eseguo questo file per due secondi, non succede nulla e poi vediamo che Taimur è fatto.

17
00:00:59,360 --> 00:01:05,060
Ora questo è un codice asincrono perché non termina immediatamente e sarebbe anche un codice di invio se

18
00:01:05,060 --> 00:01:06,680
avessimo un millisecondo lì.

19
00:01:06,770 --> 00:01:12,520
Quindi, se è super veloce, non accade immediatamente nel nostro passaggio di codice.

20
00:01:12,520 --> 00:01:15,350
È come se avessimo il blocco della console.

21
00:01:16,590 --> 00:01:17,100
Ciao.

22
00:01:19,020 --> 00:01:20,460
E registro della console.

23
00:01:22,400 --> 00:01:28,790
Ciao, questi due frammenti sono codice Synchronoss perché vengono eseguiti uno dopo l'altro, eppure tecnicamente,

24
00:01:28,790 --> 00:01:32,120
ovviamente, Noad impiegherà del tempo per eseguirli.

25
00:01:32,300 --> 00:01:35,750
Ma non ci sono ritardi diversi dal tuo hardware.

26
00:01:35,840 --> 00:01:39,020
Per così dire, e quindi fa un codice Synchronoss.

27
00:01:39,260 --> 00:01:45,110
Questo è un codice malato, asincrono perché non viene eseguito o terminato immediatamente.

28
00:01:45,260 --> 00:01:47,930
Ci vuole un po 'di tempo, anche se così corto.

29
00:01:49,000 --> 00:01:55,340
E infatti, se eseguo questo file in questo modo, vedi helo e high prima di vedere Taimur fatto, anche

30
00:01:55,520 --> 00:02:04,580
se è super veloce perché non c'è G. S. e JavaScript in generale non blocca l'esecuzione del codice fino a quando

31
00:02:04,580 --> 00:02:05,660
non viene eseguito.

32
00:02:06,260 --> 00:02:11,630
In effetti, qui riconoscerà questa cosiddetta funzione di callback.

33
00:02:11,990 --> 00:02:13,740
Quindi una funzione dovrebbe essere eseguita.

34
00:02:13,760 --> 00:02:18,120
In futuro, dovrebbe essere richiamato più tardi una volta terminato.

35
00:02:18,140 --> 00:02:24,470
Quindi una volta scaduto questo timer, lo riconoscerà e passerà immediatamente alla riga successiva

36
00:02:24,470 --> 00:02:30,740
ed eseguirà tutto il codice sincrono e quindi eseguirà il codice asincrono.

37
00:02:30,800 --> 00:02:36,890
Una volta fatto questo, ecco perché vediamo prima quanto in basso e in alto, anche se nel nostro codice il tempo è stato

38
00:02:36,890 --> 00:02:37,820
stampato per primo.

39
00:02:38,270 --> 00:02:43,380
E questo è un concetto cruciale che devi capire in JavaScript e soprattutto nel nodo.

40
00:02:43,700 --> 00:02:47,110
E ci tornerò su tutto il corso perché è così importante.

41
00:02:48,520 --> 00:02:54,430
Ora, quando si lavora con il debito e tutto aumenta a due secondi, di nuovo, per renderlo ancora più chiaro, vedrai

42
00:02:54,430 --> 00:02:56,740
di nuovo il nostro codice di sincronizzazione eseguito.

43
00:02:56,920 --> 00:02:58,990
E poi dopo due secondi, questo codice viene eseguito.

44
00:02:59,650 --> 00:03:05,380
Quando si lavora con il codice asincrono, si ottengono più tecniche di pozzo, gestendolo.

45
00:03:06,280 --> 00:03:12,320
La funzione di callback è una, la più antica, e la vedrai parecchio, in particolare nota G. S..

46
00:03:12,680 --> 00:03:20,350
Non c'è niente di sbagliato in questo, ma dovrai affrontare un problema se hai un paio di operazioni asincrone dipendenti.

47
00:03:20,980 --> 00:03:22,870
Quindi qui impostiamo il timer.

48
00:03:23,300 --> 00:03:27,280
E ora diciamo che creo un'altra funzione.

49
00:03:29,920 --> 00:03:32,270
Che chiamerò Fetch Data.

50
00:03:34,390 --> 00:03:40,390
E lì, imposterò anche un timer, perché non voglio impostare una base di dati o qualcosa del genere da cui

51
00:03:40,510 --> 00:03:43,520
prendiamo i dati, faremo tutto questo per tutto il corso.

52
00:03:43,720 --> 00:03:44,110
Ovviamente.

53
00:03:44,120 --> 00:03:44,620
Nessun problema.

54
00:03:45,250 --> 00:03:51,310
Quindi, qui di nuovo, ho un altro timer che impiega circa un secondo e mezzo.

55
00:03:52,940 --> 00:03:59,610
E ora qui in Fetch Data, ho bisogno di un modo, bene, di fare qualcosa.

56
00:03:59,640 --> 00:04:01,250
Quando viene eseguito il timer interno?

57
00:04:01,730 --> 00:04:07,190
Quindi qui mi aspetterò davvero un argomento che chiamerò richiamare, perché questo argomento sarà una

58
00:04:07,190 --> 00:04:07,820
funzione.

59
00:04:08,090 --> 00:04:12,740
Alla fine chiamerò la mia funzione interiore qui una volta che avrò finito con il timer.

60
00:04:13,340 --> 00:04:14,360
E lì posso passare.

61
00:04:14,390 --> 00:04:18,320
Fatto come valore conoscendo il luogo in cui un uso recupera i dati.

62
00:04:18,380 --> 00:04:20,490
Diciamo che è dentro questo set.

63
00:04:20,510 --> 00:04:20,730
Tempo.

64
00:04:20,930 --> 00:04:21,410
Chiamata.

65
00:04:22,540 --> 00:04:24,610
Chiamo il recupero dei dati come questo lì.

66
00:04:24,760 --> 00:04:27,140
Ora devo passare e non richiamare mai più.

67
00:04:27,940 --> 00:04:28,540
E qui.

68
00:04:29,690 --> 00:04:34,040
Riceverò il testo passato dal callback nella mia funzione quando eseguito.

69
00:04:34,550 --> 00:04:38,930
Quindi avremo un po 'di testo qui e potrò bloccarlo su console.

70
00:04:39,970 --> 00:04:44,890
Ora, questo potrebbe sembrare confuso alla fine qui, sto creando la mia funzione, che ottiene un callback

71
00:04:45,160 --> 00:04:50,950
in modo da poter definire una funzione che dovrebbe eseguire vuole che questo timer interno sia fatto da qualche altra parte.

72
00:04:51,010 --> 00:04:55,450
Quindi da questo posto qui, fa è la funzione che viene effettivamente passata come callback.

73
00:04:55,830 --> 00:04:57,490
E sto eseguendo quella funzione qui.

74
00:04:58,330 --> 00:05:00,460
Ora, se lo conservo, lo eseguo.

75
00:05:01,790 --> 00:05:04,680
Richiede due secondi, quindi questo tempo del timer è terminato.

76
00:05:04,730 --> 00:05:06,770
E poi dopo un secondo e mezzo, vedo fatto.

77
00:05:07,460 --> 00:05:15,170
Ora, se abbiamo un paio di chiamate asincrone annidate, come abbiamo fatto qui, andiamo sempre più in profondità da una prospettiva

78
00:05:15,170 --> 00:05:15,980
di richiamata.

79
00:05:16,790 --> 00:05:21,990
Ed è per questo che abbiamo sempre una funzione chiamata Promises, che possiamo usare.

80
00:05:22,010 --> 00:05:22,760
Nessuna possibilità.

81
00:05:23,570 --> 00:05:27,710
Ora, spesso utilizzeremo pacchetti di terze parti che già utilizzano promesse per noi.

82
00:05:28,400 --> 00:05:32,810
Quindi la sintassi che ti mostrerò ora è quella che raramente devi scrivere da solo.

83
00:05:33,260 --> 00:05:35,840
Ciò sarà fatto dai pacchetti dietro le quinte.

84
00:05:36,350 --> 00:05:39,680
Comunque è bello sapere che hai creato una promessa.

85
00:05:40,900 --> 00:05:43,450
All'interno della nostra funzione di recupero dati, diciamo.

86
00:05:44,800 --> 00:05:50,050
Memorizzandolo in una costante o variabile e quindi utilizzando la nuova parola chiave, che si utilizza in JavaScript per

87
00:05:50,050 --> 00:05:52,660
creare un nuovo oggetto basato su un costruttore.

88
00:05:53,110 --> 00:05:56,860
Se le funzioni del costruttore sono qualcosa che non ti dice nulla.

89
00:05:57,190 --> 00:06:04,030
Dai un'occhiata ad alcune risorse introduttive di base su JavaScript perché le funzioni di costruzione sono una caratteristica fondamentale

90
00:06:04,150 --> 00:06:04,930
di JavaScript.

91
00:06:05,680 --> 00:06:11,650
E qui ha usato la funzione di costruzione della promessa, che è integrata in JavaScript e non in G. S..

92
00:06:12,970 --> 00:06:18,660
E in realtà accetta anche una richiamata, che arriva agli argomenti, risolve e rifiuta.

93
00:06:18,850 --> 00:06:21,640
Potresti nominarli come vuoi, ma queste sono due funzioni.

94
00:06:22,180 --> 00:06:25,360
E il primo completa la promessa con successo.

95
00:06:25,450 --> 00:06:27,250
Lo risolve con successo.

96
00:06:27,640 --> 00:06:31,170
Il secondo lo rifiuta, è come lanciare un errore.

97
00:06:32,140 --> 00:06:34,870
Quindi prendi il tuo codice asincrono e lo trasferisci lì.

98
00:06:35,170 --> 00:06:37,840
E ancora, raramente devi scriverlo da solo.

99
00:06:38,110 --> 00:06:43,420
La maggior parte dei pacchetti lo fa già per te e ti dà la promessa finale, che fa tutta la magia

100
00:06:43,420 --> 00:06:45,160
dietro le quinte nascosta da te.

101
00:06:45,610 --> 00:06:46,690
Qui lo facciamo manualmente.

102
00:06:47,200 --> 00:06:48,510
Quindi ora e papà richiamano.

103
00:06:48,520 --> 00:06:51,690
Abbiamo il nostro set di funzioni.

104
00:06:51,710 --> 00:06:55,020
Purtroppo, il timeout non ci fornisce un'API promettente.

105
00:06:55,030 --> 00:06:56,830
Quindi qui tutti dobbiamo usare un callback.

106
00:06:57,430 --> 00:06:58,300
Ma nel loro.

107
00:07:00,240 --> 00:07:04,860
Ora sappiamo che non utilizziamo più alcuna funzione di callback che riceviamo.

108
00:07:04,950 --> 00:07:07,190
Non ottengo alcun argomento qui e recuperato più dati.

109
00:07:07,770 --> 00:07:09,900
Invece, qui risolvo.

110
00:07:10,230 --> 00:07:11,160
Fatto, diciamo.

111
00:07:11,520 --> 00:07:16,670
Quindi sono tornato con successo per risolvere il valore ora nel recupero dei dati.

112
00:07:17,100 --> 00:07:20,520
Dopo aver definito la promessa, non ci resta che restituirla.

113
00:07:21,060 --> 00:07:23,910
E tieni presente che questo è un codice sincrono.

114
00:07:24,240 --> 00:07:30,480
Quindi in realtà questo verrà restituito immediatamente dopo che la promessa è stata creata prima di codificare

115
00:07:30,480 --> 00:07:35,640
nell'esecuzione delle promesse, che accadrà qualche tempo dopo quando chiameremo effettivamente quella funzione.

116
00:07:35,820 --> 00:07:37,590
E quando questa volta Odyn completa.

117
00:07:38,250 --> 00:07:40,110
Quindi ora restituiamo questa promessa qui.

118
00:07:40,590 --> 00:07:45,450
E nel luogo in cui chiamiamo dati recuperati, ora non passiamo più una richiamata.

119
00:07:45,810 --> 00:07:51,900
Ma ora possiamo usare allora, che è richiamabile su una promessa e restituiamo una promessa.

120
00:07:53,490 --> 00:07:59,880
E questo ci permette semplicemente di definire qui una funzione chiamata, che verrà eseguita una volta risolta

121
00:07:59,910 --> 00:08:00,780
la promessa.

122
00:08:04,040 --> 00:08:05,610
Ora, qual è il vantaggio di questo?

123
00:08:06,420 --> 00:08:08,430
Se avessimo promesse multiple.

124
00:08:09,970 --> 00:08:16,540
Quindi diciamo di nuovo un recupero di dati freddi e lì quindi non devo usare quindi in questo modo.

125
00:08:17,750 --> 00:08:20,640
E quindi, finirei con nidificato.

126
00:08:22,110 --> 00:08:23,210
Richiami di nuovo.

127
00:08:24,280 --> 00:08:30,820
Ma invece, all'interno di una promessa e quindi il blocco fa parte di una promessa.

128
00:08:31,180 --> 00:08:39,220
Posso semplicemente restituire una nuova promessa e quindi aggiungere la successiva e bloccare dopo la precedente.

129
00:08:41,020 --> 00:08:41,650
Come questo.

130
00:08:42,310 --> 00:08:44,740
Quindi ora abbiamo una catena, quindi blocchi.

131
00:08:45,160 --> 00:08:50,290
Questo viene chiamato alla prima promessa, quindi nel blocco successivo restituisco un'altra promessa.

132
00:08:50,680 --> 00:08:54,120
E anche se ciò non ci darebbe un incentivo promettente.

133
00:08:54,280 --> 00:08:58,780
Quindi bloccare la restituzione lo convertirà in una promessa che si risolve immediatamente.

134
00:08:59,350 --> 00:09:03,700
E poi aggiungiamo un altro blocco, che ora si riferisce a questa promessa qui.

135
00:09:04,410 --> 00:09:08,680
E questo è più leggibile che avere callback infinitamente annidati.

136
00:09:09,460 --> 00:09:11,020
Quindi ora se corro quello che vediamo.

137
00:09:11,050 --> 00:09:11,350
Ciao.

138
00:09:11,350 --> 00:09:11,770
Ciao.

139
00:09:12,160 --> 00:09:13,150
Il timer è terminato.

140
00:09:13,690 --> 00:09:14,410
Abbiamo fatto.

141
00:09:14,680 --> 00:09:17,500
E lo vediamo di nuovo perché chiamo due volte i dati di recupero.

142
00:09:18,490 --> 00:09:22,330
Quindi potrebbe essere difficile avvolgere la testa per la prima volta.

143
00:09:22,690 --> 00:09:23,590
Lo riutilizzeremo.

144
00:09:23,590 --> 00:09:26,050
Compensato questo corso e che diventerà più chiaro.

145
00:09:26,380 --> 00:09:35,140
Ancora una volta, questo codice non è per lo più scritto da te, ma è un concetto cruciale che rende il nostro codice

146
00:09:35,350 --> 00:09:36,640
asincrono più gestibile.

147
00:09:37,420 --> 00:09:40,420
C'è sempre un altro modo di gestire questo asincrono.

148
00:09:40,460 --> 00:09:46,330
Attendi due parole chiave speciali che puoi utilizzare nel moderno JavaScript e avrò una sezione separata su questo verso

149
00:09:46,330 --> 00:09:47,830
la fine del corso.

150
00:09:48,130 --> 00:09:53,590
Voglio introdurlo qui perché in realtà può essere più confuso di questa sintassi qui.

151
00:09:53,860 --> 00:09:55,300
E voglio attenermi a questo.

152
00:09:55,320 --> 00:09:58,750
Non introdurre troppe nuove funzionalità contemporaneamente allo stesso tempo.

153
00:09:59,680 --> 00:10:02,290
Il codice asincrono è qualcosa che devi capire, però.

154
00:10:02,530 --> 00:10:08,230
E se non è del tutto chiaro ormai, va bene, anche se lo vedrai per un corso alterato

155
00:10:08,290 --> 00:10:11,510
un sacco, perché abbiamo molti eventi asincroni in nessuna possibilità.

156
00:10:12,130 --> 00:10:14,710
E lo spiegherò più volte.

157
00:10:14,950 --> 00:10:17,080
Spiegherò anche di nuovo le promesse.

158
00:10:17,380 --> 00:10:23,380
Voglio solo assicurarti che tu l'abbia visto ormai e che tu abbia quindi la possibilità di capirlo,

159
00:10:23,380 --> 00:10:25,870
come funziona e come lo affrontiamo.