1
00:00:02,260 --> 00:00:04,100
Nein, ich habe geklärt, spielst du Schach?

2
00:00:04,150 --> 00:00:08,590
Fallen Sie erneut, weil Sie festgestellt haben, dass es sich um ein Schnellauffrischungsmodul handelt.

3
00:00:09,010 --> 00:00:14,980
Ich werde mich mit dem Konzept der Nichtaufzeichnung befassen und so mit einem synchronen Code arbeiten.

4
00:00:15,520 --> 00:00:20,110
Und dafür müssen wir zunächst verstehen, was asynchroner Code ist.

5
00:00:20,530 --> 00:00:25,340
Angenommen, ich setze einen Timer mit eingestelltem Timeout, eine in Knoten J integrierte Funktion.

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

7
00:00:27,520 --> 00:00:31,380
Wir definieren eine Funktion, die nach Ablauf eines bestimmten Timers ausgeführt werden soll.

8
00:00:31,870 --> 00:00:33,580
Hier verwende ich eine Pfeilfunktion.

9
00:00:33,880 --> 00:00:36,100
Sie können eine benannte Funktion verwenden, was immer Sie möchten.

10
00:00:37,060 --> 00:00:38,620
Das zweite Argument ist der Timer.

11
00:00:38,650 --> 00:00:39,850
Sagen wir zwei Sekunden.

12
00:00:40,090 --> 00:00:41,710
Sie drücken es in Millisekunden aus.

13
00:00:41,830 --> 00:00:46,250
Zwei Sekunden sind also zweitausend Millisekunden.

14
00:00:47,540 --> 00:00:48,190
Alles einfach verschlossen.

15
00:00:48,260 --> 00:00:49,710
Timer ist fertig.

16
00:00:52,670 --> 00:00:58,490
Wenn ich diese Datei jetzt zwei Sekunden lang ausführe, passiert nichts und dann sehen wir, dass Taimur fertig ist.

17
00:00:59,360 --> 00:01:05,060
Dies ist nun asynchroner Code, da er nicht sofort beendet wird und es sogar ein Sendecode wäre, wenn

18
00:01:05,060 --> 00:01:06,680
wir dort eine Millisekunde hätten.

19
00:01:06,770 --> 00:01:12,520
Wenn es also superschnell ist, passiert es nicht sofort in unserem Codeschritt.

20
00:01:12,520 --> 00:01:15,350
Es ist wie wenn wir eine Konsolensperre haben.

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

22
00:01:19,020 --> 00:01:20,460
Und Konsolenprotokoll.

23
00:01:22,400 --> 00:01:28,790
Hallo, diese beiden Snippets sind Synchronoss-Code, da sie direkt nacheinander ausgeführt werden, und technisch gesehen wird

24
00:01:28,790 --> 00:01:32,120
Noad natürlich einige Zeit brauchen, um sie auszuführen.

25
00:01:32,300 --> 00:01:35,750
Es gibt jedoch keine andere Verzögerung als Ihre Hardware.

26
00:01:35,840 --> 00:01:39,020
Sozusagen und damit ein Synchronoss-Code.

27
00:01:39,260 --> 00:01:45,110
Dies ist ein kranker Code, der asynchron ist, da er nicht sofort ausgeführt oder beendet wird.

28
00:01:45,260 --> 00:01:47,930
Es dauert ein wenig, auch wenn das super kurz ist.

29
00:01:49,000 --> 00:01:55,340
Und in der Tat, wenn ich diese Datei so ausführe, sehen Sie helo und high, bevor Sie sehen, dass Taimur

30
00:01:55,520 --> 00:02:04,580
fertig ist, obwohl es superschnell ist, weil kein G. S. und JavaScript blockiert im Allgemeinen Ihre Codeausführung erst, wenn

31
00:02:04,580 --> 00:02:05,660
dies erledigt ist.

32
00:02:06,260 --> 00:02:11,630
In der Tat wird hier diese sogenannte Rückruffunktion erkannt.

33
00:02:11,990 --> 00:02:13,740
Eine Funktion sollte also ausgeführt werden.

34
00:02:13,760 --> 00:02:18,120
In Zukunft sollte es später zurückrufen, sobald es fertig ist.

35
00:02:18,140 --> 00:02:24,470
Sobald dieser Timer hier abgelaufen ist, erkennt er dies nur und geht sofort zur nächsten Zeile

36
00:02:24,470 --> 00:02:30,740
über. Er führt den gesamten synchronen Code aus und führt dann Ihren asynchronen Code aus.

37
00:02:30,800 --> 00:02:36,890
Sobald dies erledigt ist, sehen wir, wie niedrig und hoch zuerst, obwohl in unserem Code die Zeit zuerst

38
00:02:36,890 --> 00:02:37,820
gedruckt wird.

39
00:02:38,270 --> 00:02:43,380
Und das ist ein entscheidendes Konzept, das Sie in JavaScript und insbesondere in Node verstehen müssen.

40
00:02:43,700 --> 00:02:47,110
Und ich werde während des gesamten Kurses darauf zurückkommen, weil es so wichtig ist.

41
00:02:48,520 --> 00:02:54,430
Wenn Sie jetzt mit Schulden arbeiten und alles auf zwei Sekunden ansteigt, um es noch klarer zu machen, werden Sie

42
00:02:54,430 --> 00:02:56,740
wieder sehen, dass unser Synchronisierungscode ausgeführt wird.

43
00:02:56,920 --> 00:02:58,990
Nach zwei Sekunden wird dieser Code ausgeführt.

44
00:02:59,650 --> 00:03:05,380
Wenn wir mit asynchronem Code arbeiten, erhalten wir mehrere Techniken, mit denen wir gut umgehen können.

45
00:03:06,280 --> 00:03:12,320
Die Rückruffunktion ist eine, die älteste, und Sie werden sie ziemlich oft sehen, insbesondere Hinweis G. S ..

46
00:03:12,680 --> 00:03:20,350
Es ist nichts falsch daran, aber Sie werden auf ein Problem stoßen, wenn Sie einige abhängige asynchrone Operationen haben.

47
00:03:20,980 --> 00:03:22,870
Also stellen wir hier den Timer ein.

48
00:03:23,300 --> 00:03:27,280
Angenommen, ich erstelle eine andere Funktion.

49
00:03:29,920 --> 00:03:32,270
Welches ich Fetch Data nennen werde.

50
00:03:34,390 --> 00:03:40,390
Und dort werde ich auch nur einen Timer einstellen, weil ich keine Datenbank oder ähnliches einrichten möchte, von der wir

51
00:03:40,510 --> 00:03:43,520
Daten abrufen, wir werden das alles für alle Kurse tun.

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

53
00:03:44,120 --> 00:03:44,620
Keine Sorge.

54
00:03:45,250 --> 00:03:51,310
Also hier habe ich wieder einen Timer, der ungefähr eineinhalb Sekunden dauert.

55
00:03:52,940 --> 00:03:59,610
Und jetzt hier in Fetch Data brauche ich eine Möglichkeit, etwas zu tun.

56
00:03:59,640 --> 00:04:01,250
Wann ist der innere Timer fertig?

57
00:04:01,730 --> 00:04:07,190
Hier erwarte ich also tatsächlich ein Argument, das ich zurückrufen werde, da dieses Argument eine Funktion sein

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

59
00:04:08,090 --> 00:04:12,740
Ich werde hier irgendwann meine innere Funktion aufrufen, sobald ich mit dem Timer fertig bin.

60
00:04:13,340 --> 00:04:14,360
Und dort kann ich passieren.

61
00:04:14,390 --> 00:04:18,320
Fertig als Wert, der den Ort kennt, an dem eine Verwendung Daten abruft.

62
00:04:18,380 --> 00:04:20,490
Nehmen wir an, das gehört zu diesem Set.

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

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

65
00:04:22,540 --> 00:04:24,610
Ich rufe dort solche Abrufdaten auf.

66
00:04:24,760 --> 00:04:27,140
Ich muss jetzt bestehen und nie wieder zurückrufen.

67
00:04:27,940 --> 00:04:28,540
Und hier.

68
00:04:29,690 --> 00:04:34,040
Ich werde den vom Rückruf übergebenen Text in meiner Funktion erhalten, wenn er ausgeführt wird.

69
00:04:34,550 --> 00:04:38,930
Also bekommen wir hier Text und ich kann diesen Text auf der Konsole sperren.

70
00:04:39,970 --> 00:04:44,890
Nun, das mag am Ende hier verwirrend aussehen. Ich erstelle meine eigene Funktion, die einen Rückruf erhält,

71
00:04:45,160 --> 00:04:50,950
damit ich eine Funktion definieren kann, die ausgeführt werden soll, wenn dieser innere Timer von einem anderen Ort aus ausgeführt wird.

72
00:04:51,010 --> 00:04:55,450
Von hier aus ist also die Funktion, die effektiv als Rückruf übergeben wird.

73
00:04:55,830 --> 00:04:57,490
Und ich führe diese Funktion hier aus.

74
00:04:58,330 --> 00:05:00,460
Nun, wenn ich das speichere, läuft das.

75
00:05:01,790 --> 00:05:04,680
Dauert zwei Sekunden, dann ist diese Zeit des Timers abgelaufen.

76
00:05:04,730 --> 00:05:06,770
Und dann nach anderthalb Sekunden sehe ich fertig.

77
00:05:07,460 --> 00:05:15,170
Wenn wir nun wie hier ein paar verschachtelte asynchrone Aufrufe haben, gehen wir aus Rückrufperspektive immer

78
00:05:15,170 --> 00:05:15,980
tiefer.

79
00:05:16,790 --> 00:05:21,990
Und deshalb haben wir immer eine Funktion namens Promises, die wir verwenden können.

80
00:05:22,010 --> 00:05:22,760
Keine Chance.

81
00:05:23,570 --> 00:05:27,710
Jetzt verwenden wir häufig Pakete von Drittanbietern, die bereits Versprechen für uns verwenden.

82
00:05:28,400 --> 00:05:32,810
Die Syntax, die ich Ihnen jetzt zeigen werde, ist eine, die Sie selten selbst schreiben müssen.

83
00:05:33,260 --> 00:05:35,840
Das erledigen die Pakete hinter den Kulissen.

84
00:05:36,350 --> 00:05:39,680
Immer noch schön zu wissen, dass Sie ein Versprechen machen.

85
00:05:40,900 --> 00:05:43,450
Innerhalb unserer abgerufenen Datenfunktion sind Sie beispielsweise.

86
00:05:44,800 --> 00:05:50,050
Indem Sie es in einer Konstanten oder Variablen speichern und dann das neue Schlüsselwort verwenden, das Sie in JavaScript verwenden, um

87
00:05:50,050 --> 00:05:52,660
ein neues Objekt basierend auf einem Konstruktor zu erstellen.

88
00:05:53,110 --> 00:05:56,860
Wenn Konstruktorfunktionen etwas sind, das Ihnen nichts sagt.

89
00:05:57,190 --> 00:06:04,030
Schauen Sie sich einige grundlegende Einführungsressourcen in JavaScript an, da Konstruktorfunktionen eine Kernfunktion in JavaScript

90
00:06:04,150 --> 00:06:04,930
sind.

91
00:06:05,680 --> 00:06:11,650
Und hier verwendete er die Versprechen-Konstruktor-Funktion, die in JavaScript und kein G eingebaut ist. S ..

92
00:06:12,970 --> 00:06:18,660
Und nimmt eigentlich auch einen Rückruf entgegen, der zu Argumenten führt, auflöst und ablehnt.

93
00:06:18,850 --> 00:06:21,640
Sie können sie benennen, wie Sie möchten, aber dies sind zwei Funktionen.

94
00:06:22,180 --> 00:06:25,360
Und der erste erfüllt das Versprechen erfolgreich.

95
00:06:25,450 --> 00:06:27,250
Es löst es erfolgreich auf.

96
00:06:27,640 --> 00:06:31,170
Der zweite lehnt es ab, was wie ein Fehler ist.

97
00:06:32,140 --> 00:06:34,870
Sie nehmen dann Ihren asynchronen Code und verschieben ihn dort hinein.

98
00:06:35,170 --> 00:06:37,840
Und wieder müssen Sie dies selten selbst schreiben.

99
00:06:38,110 --> 00:06:43,420
Die meisten Pakete erledigen das bereits für Sie und geben Ihnen das fertige Versprechen, das die ganze Magie hinter den

100
00:06:43,420 --> 00:06:45,160
Kulissen ausübt, die Ihnen verborgen bleiben.

101
00:06:45,610 --> 00:06:46,690
Hier machen wir es manuell.

102
00:06:47,200 --> 00:06:48,510
Also jetzt und Papa ruft zurück.

103
00:06:48,520 --> 00:06:51,690
Wir haben unseren eigenen Funktionssatz.

104
00:06:51,710 --> 00:06:55,020
Auszeit gibt uns leider keine Versprechen API.

105
00:06:55,030 --> 00:06:56,830
Hier müssen wir also alle einen Rückruf verwenden.

106
00:06:57,430 --> 00:06:58,300
Aber in ihren.

107
00:07:00,240 --> 00:07:04,860
Wir wissen jetzt, dass wir keine Rückruffunktion mehr verwenden, die wir erhalten.

108
00:07:04,950 --> 00:07:07,190
Ich bekomme hier kein Argument mehr und habe keine Daten mehr abgerufen.

109
00:07:07,770 --> 00:07:09,900
Stattdessen beschließe ich hier.

110
00:07:10,230 --> 00:07:11,160
Fertig, sagen wir mal.

111
00:07:11,520 --> 00:07:16,670
Also bin ich erfolgreich zurückgekehrt, um den Wert jetzt in Abrufdaten aufzulösen.

112
00:07:17,100 --> 00:07:20,520
Nachdem wir das Versprechen definiert haben, müssen wir es nur zurückgeben.

113
00:07:21,060 --> 00:07:23,910
Und bitte beachten Sie, dass dies synchroner Code ist.

114
00:07:24,240 --> 00:07:30,480
Tatsächlich wird dies sofort zurückgegeben, nachdem das Versprechen erstellt wurde, bevor es im Versprechungslauf codiert wird.

115
00:07:30,480 --> 00:07:35,640
Dies wird einige Zeit später geschehen, wenn wir diese Funktion tatsächlich aufrufen.

116
00:07:35,820 --> 00:07:37,590
Und wenn diesmal Odyn fertig ist.

117
00:07:38,250 --> 00:07:40,110
Also geben wir dieses Versprechen jetzt hier zurück.

118
00:07:40,590 --> 00:07:45,450
Und an der Stelle, an der wir abgerufene Daten aufrufen, geben wir jetzt keinen Rückruf mehr weiter.

119
00:07:45,810 --> 00:07:51,900
Aber wir können jetzt dann verwenden, was auf ein Versprechen abrufbar ist und wir geben ein Versprechen zurück.

120
00:07:53,490 --> 00:07:59,880
Und dies ermöglicht es uns einfach, hier eine so genannte Funktion zu definieren, die ausgeführt wird, sobald das Versprechen

121
00:07:59,910 --> 00:08:00,780
gelöst ist.

122
00:08:04,040 --> 00:08:05,610
Was ist nun der Vorteil davon?

123
00:08:06,420 --> 00:08:08,430
Wenn wir mehrere solcher Versprechen hätten.

124
00:08:09,970 --> 00:08:16,540
Sagen wir also nochmal einen kalten Abruf von Daten und da muss ich dann dann nicht mehr so verwenden.

125
00:08:17,750 --> 00:08:20,640
Und deshalb würde ich mit verschachtelt enden.

126
00:08:22,110 --> 00:08:23,210
Wieder Rückrufe.

127
00:08:24,280 --> 00:08:30,820
Aber stattdessen ist innerhalb eines Versprechens und dann Blockieren Teil eines Versprechens.

128
00:08:31,180 --> 00:08:39,220
Ich kann einfach ein neues Versprechen zurückgeben und dann den nächsten Block nach dem vorherigen hinzufügen.

129
00:08:41,020 --> 00:08:41,650
So was.

130
00:08:42,310 --> 00:08:44,740
Jetzt haben wir eine Kette und blockieren dann.

131
00:08:45,160 --> 00:08:50,290
Dieser wird beim ersten Versprechen angerufen, dann gebe ich im Then-Block ein weiteres Versprechen zurück.

132
00:08:50,680 --> 00:08:54,120
Und selbst wenn uns das keinen vielversprechenden Anreiz geben würde.

133
00:08:54,280 --> 00:08:58,780
Wenn Sie die Rückgabe blockieren, wird sie in ein Versprechen umgewandelt, das sofort aufgelöst wird.

134
00:08:59,350 --> 00:09:03,700
Und dann fügen wir einen weiteren then-Block hinzu, der sich jetzt hier auf dieses Versprechen bezieht.

135
00:09:04,410 --> 00:09:08,680
Und dies ist besser lesbar als unendlich verschachtelte Rückrufe.

136
00:09:09,460 --> 00:09:11,020
Wenn ich jetzt renne, sehen wir.

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

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

139
00:09:12,160 --> 00:09:13,150
Der Timer ist fertig.

140
00:09:13,690 --> 00:09:14,410
Wir sind fertig.

141
00:09:14,680 --> 00:09:17,500
Und wir sehen es wieder, weil ich zweimal Abrufdaten aufrufe.

142
00:09:18,490 --> 00:09:22,330
Es könnte also schwierig sein, den Kopf zum ersten Mal herumzuwickeln.

143
00:09:22,690 --> 00:09:23,590
Wir werden es wiederverwenden.

144
00:09:23,590 --> 00:09:26,050
Hat diesen Kurs durchbrochen und dass es klarer wird.

145
00:09:26,380 --> 00:09:35,140
Auch dieser Code wird größtenteils nicht von Ihnen geschrieben, aber es ist ein entscheidendes Konzept, das unseren asynchronen Code

146
00:09:35,350 --> 00:09:36,640
übersichtlicher macht.

147
00:09:37,420 --> 00:09:40,420
Es gibt immer eine andere Möglichkeit, diese Asynchronität zu verwalten.

148
00:09:40,460 --> 00:09:46,330
Warten Sie auf zwei spezielle Schlüsselwörter, die Sie in modernem JavaScript verwenden können, und ich werde gegen Ende des Kurses

149
00:09:46,330 --> 00:09:47,830
einen separaten Abschnitt dazu haben.

150
00:09:48,130 --> 00:09:53,590
Ich möchte es hier vorstellen, weil es hier verwirrender sein kann als diese Syntax.

151
00:09:53,860 --> 00:09:55,300
Und ich möchte mich an diesen halten.

152
00:09:55,320 --> 00:09:58,750
Führen Sie hier nicht zu viele neue Funktionen gleichzeitig ein.

153
00:09:59,680 --> 00:10:02,290
Async-Code muss man allerdings verstehen.

154
00:10:02,530 --> 00:10:08,230
Und wenn es bis jetzt nicht ganz klar ist, ist das in Ordnung, obwohl Sie es für einen veränderten Kurs ein

155
00:10:08,290 --> 00:10:11,510
paar sehen werden, weil wir viele asynchrone Ereignisse ohne Chance haben.

156
00:10:12,130 --> 00:10:14,710
Und ich werde das mehrmals erklären.

157
00:10:14,950 --> 00:10:17,080
Ich werde auch noch einmal Versprechen erklären.

158
00:10:17,380 --> 00:10:23,380
Ich möchte nur sicherstellen, dass Sie dies inzwischen gesehen haben und dann die Möglichkeit haben, dies zu verstehen, wie

159
00:10:23,380 --> 00:10:25,870
es funktioniert und wie wir damit umgehen.