1
00:00:03,650 --> 00:00:06,180
В предыдущем упражнении

2
00:00:06,180 --> 00:00:09,414
мы узнали о двух новых аспектах JavaScript,

3
00:00:09,414 --> 00:00:13,155
их поддержке функций первого класса и закрытия.

4
00:00:13,155 --> 00:00:20,250
Мы также видели, как Node обрабатывает аспект асинхронного программирования и как

5
00:00:20,250 --> 00:00:24,015
Node поддерживает асинхронное выполнение кода с

6
00:00:24,015 --> 00:00:28,365
использованием обратных вызовов, а также обработки ошибок.

7
00:00:28,365 --> 00:00:31,815
Давайте посмотрим на пример того, как мы используем это

8
00:00:31,815 --> 00:00:36,650
в нашем приложении Node в этом упражнении.

9
00:00:36,650 --> 00:00:42,315
Продолжая с того, где мы остановились в предыдущем упражнении,

10
00:00:42,315 --> 00:00:48,025
теперь я собираюсь пойти и изменить модуль прямоугольника Node,

11
00:00:48,025 --> 00:00:51,670
чтобы он мог принять помощь обратных вызовов.

12
00:00:51,670 --> 00:00:55,375
Поэтому я собираюсь удалить эти экспорты здесь,

13
00:00:55,375 --> 00:00:59,800
и вместо этого они собираются изменить эту функцию.

14
00:00:59,800 --> 00:01:03,190
Я собираюсь использовать эти две функции немного позже,

15
00:01:03,190 --> 00:01:05,925
поэтому я сохраняю их внизу.

16
00:01:05,925 --> 00:01:07,515
Так что позволь мне держать их в стороне.

17
00:01:07,515 --> 00:01:11,530
И тогда я изменю этот прямоугольный модуль следующим образом.

18
00:01:11,530 --> 00:01:15,270
Так что скажем module.exports.

19
00:01:15,270 --> 00:01:20,025
Таким образом, мы используем стандартный способ обработки модуля.

20
00:01:20,025 --> 00:01:26,185
И это будет экспортировать эту функцию, которая принимает эти три параметра,

21
00:01:26,185 --> 00:01:30,565
x и y и обратный вызов.

22
00:01:30,565 --> 00:01:37,300
Обратный вызов - это функция, которая будет поставляться при вызове этого модуля.

23
00:01:37,300 --> 00:01:43,825
Таким образом, это использование функций первого класса, о которых мы говорили ранее.

24
00:01:43,825 --> 00:01:46,775
Таким образом, внутри этого обратного вызова,

25
00:01:46,775 --> 00:01:49,940
чтобы вы могли видеть, что вы получаете два параметра

26
00:01:49,940 --> 00:01:51,965
, x и y. В этом случае для прямоугольника,

27
00:01:51,965 --> 00:01:55,520
x и y соответствуют длине и ширине

28
00:01:55,520 --> 00:02:01,550
прямоугольника, который передается в качестве двух значений.

29
00:02:01,550 --> 00:02:05,090
Итак, внутри здесь, мы собираемся проверить,

30
00:02:05,090 --> 00:02:10,300
если х меньше или равно нулю или у меньше или равно нулю.

31
00:02:10,300 --> 00:02:13,255
Мы написали такой код здесь.

32
00:02:13,255 --> 00:02:17,630
Поэтому я просто скопирую этот код отсюда,

33
00:02:17,630 --> 00:02:23,330
а затем принесу его сюда, а затем мы отредактируем.

34
00:02:23,330 --> 00:02:26,090
Таким образом, в этом случае, это если x

35
00:02:26,090 --> 00:02:30,135
меньше или равно нулю или y меньше или равно нулю.

36
00:02:30,135 --> 00:02:32,810
В этом случае, что нам делать?

37
00:02:32,810 --> 00:02:35,435
В этом случае мы замечаем, что

38
00:02:35,435 --> 00:02:39,750
размеры прямоугольника меньше или равны нулю.

39
00:02:39,750 --> 00:02:43,775
Так что мы должны справиться с этим по-другому,

40
00:02:43,775 --> 00:02:46,330
и мы сделаем остальную часть этого.

41
00:02:46,330 --> 00:02:52,790
Другая часть, где мы обрабатываем ситуацию, когда прямоугольник является допустимым прямоугольником.

42
00:02:52,790 --> 00:02:54,245
Таким образом, в этом случае

43
00:02:54,245 --> 00:03:04,580
мы будем делать, это использовать setTimeout.

44
00:03:04,580 --> 00:03:08,090
Итак, здесь я имитирую тот факт, что все, что

45
00:03:08,090 --> 00:03:11,860
делается в этом прямоугольнике, займет некоторое время.

46
00:03:11,860 --> 00:03:14,375
Таким образом, это асинхронная обработка.

47
00:03:14,375 --> 00:03:18,710
Теперь, поскольку у меня нет большой работы в фоновом режиме,

48
00:03:18,710 --> 00:03:22,530
поэтому я собираюсь имитировать это, просто используя

49
00:03:22,530 --> 00:03:24,830
функцию setTimeout JavaScript, а затем

50
00:03:24,830 --> 00:03:28,825
задержку перед вызовом функции обратного вызова.

51
00:03:28,825 --> 00:03:32,210
Таким образом, я организую это следующим образом.

52
00:03:32,210 --> 00:03:34,270
Поэтому внутри setTimeout

53
00:03:34,270 --> 00:03:40,445
я собираюсь вызвать эту функцию

54
00:03:40,445 --> 00:03:44,855
и организовать задержку в

55
00:03:44,855 --> 00:03:50,570
2 000 миллисекунд или две секунды, после чего эта функция будет вызвана.

56
00:03:50,570 --> 00:03:52,003
Поэтому, если вы помните,

57
00:03:52,003 --> 00:03:54,890
setTimeout, который поддерживается в JavaScript,

58
00:03:54,890 --> 00:03:58,070
он принимает в качестве первого параметра функцию, а

59
00:03:58,070 --> 00:04:03,450
вторым параметром будет период времени, для которого это будет отложено.

60
00:04:03,450 --> 00:04:07,120
Так что позвольте мне отстукнуть это.

61
00:04:07,120 --> 00:04:09,255
Теперь мне нужно заполнить эту функцию здесь.

62
00:04:09,255 --> 00:04:11,915
Поэтому я начал с функции стрелки здесь,

63
00:04:11,915 --> 00:04:15,575
которая не принимает параметров, а затем, когда вызывается,

64
00:04:15,575 --> 00:04:20,745
я собираюсь выдать вызов обратному вызову.

65
00:04:20,745 --> 00:04:22,880
Этот обратный вызов является функцией обратного вызова, которая

66
00:04:22,880 --> 00:04:25,760
будет передаваться в качестве третьего параметра здесь.

67
00:04:25,760 --> 00:04:33,440
Эта функция обратного вызова, как вы заметили, принимает два параметра.

68
00:04:33,440 --> 00:04:38,245
Первый - это ошибка, а второй - возвращаемое значение.

69
00:04:38,245 --> 00:04:40,625
Итак, в этом случае, поскольку у нас есть ошибка,

70
00:04:40,625 --> 00:04:44,750
потому что x меньше или равно нулю и y меньше или равно нулю,

71
00:04:44,750 --> 00:04:50,820
поэтому первое значение, которое я собираюсь передать как новая ошибка,

72
00:04:50,820 --> 00:05:00,603
и эта ошибка является именно той строкой, которую я использовал в console.log тогда,

73
00:05:00,603 --> 00:05:03,915
и это то, что я передам как ошибка здесь.

74
00:05:03,915 --> 00:05:06,160
Позвольте мне теперь удалить этот console.log,

75
00:05:06,160 --> 00:05:07,625
он мне больше не нужен.

76
00:05:07,625 --> 00:05:08,890
Поэтому для обратного вызова

77
00:05:08,890 --> 00:05:13,210
я собираюсь сгенерировать новый объект ошибки, а затем передать это

78
00:05:13,210 --> 00:05:18,850
в качестве возвращаемого значения для функции обратного вызова, первого параметра.

79
00:05:18,850 --> 00:05:23,770
Поэтому я скажу, что размеры прямоугольника должны быть больше нуля.

80
00:05:23,770 --> 00:05:28,240
Итак, мы скажем l,

81
00:05:28,240 --> 00:05:39,000
это значение x и y, которое мы получили в качестве входных значений там.

82
00:05:39,000 --> 00:05:40,650
Так что это обратный вызов.

83
00:05:40,650 --> 00:05:43,890
И вторая часть этого обратного вызова,

84
00:05:43,890 --> 00:05:51,290
я собираюсь передать как null, потому что это вернет ошибку.

85
00:05:51,290 --> 00:05:54,345
Поэтому, когда вы возвращаете ошибку в качестве первого параметра,

86
00:05:54,345 --> 00:05:59,250
второй параметр будет игнорироваться, когда этот обратный вызов был только что получен

87
00:05:59,250 --> 00:06:06,510
модулем узла, откуда мы вызываем эту конкретную функцию там.

88
00:06:06,510 --> 00:06:09,085
Итак, с этой договоренностью,

89
00:06:09,085 --> 00:06:10,700
так меньше нуля,

90
00:06:10,700 --> 00:06:18,590
так что позвольте мне дать немного места здесь, чтобы он был правильно отступом здесь.

91
00:06:18,590 --> 00:06:21,650
Итак, способ, который я устраиваю

92
00:06:21,650 --> 00:06:26,135
здесь, заключается в том, что если x меньше нуля и y меньше нуля,

93
00:06:26,135 --> 00:06:30,040
я собираюсь обратный вызов функции обратного вызова, которая была передана,

94
00:06:30,040 --> 00:06:32,424
но первый параметр будет передан по

95
00:06:32,424 --> 00:06:36,307
ошибке, потому что здесь мы замечаем, что есть ошибка,

96
00:06:36,307 --> 00:06:38,930
а второй параметр будет нулевым.

97
00:06:38,930 --> 00:06:40,940
Если это не так,

98
00:06:40,940 --> 00:06:44,550
то я собираюсь вызвать тот же обратный вызов,

99
00:06:44,550 --> 00:06:46,910
но с первым параметром.

100
00:06:46,910 --> 00:06:51,800
Так что позвольте мне скопировать этот код здесь.

101
00:06:51,800 --> 00:07:05,490
Я все еще собираюсь использовать setTimeout здесь.

102
00:07:05,490 --> 00:07:10,727
Но эта первая часть не будет ошибкой

103
00:07:10,727 --> 00:07:13,005
, а первая часть,

104
00:07:13,005 --> 00:07:15,235
в данном случае, ошибки нет.

105
00:07:15,235 --> 00:07:20,455
Поэтому я просто собираюсь передать это значение как null.

106
00:07:20,455 --> 00:07:22,950
Таким образом, это означает, что ошибка имеет значение null.

107
00:07:22,950 --> 00:07:26,335
Таким образом, это допустимый прямоугольник.

108
00:07:26,335 --> 00:07:29,965
Таким образом, мы можем вычислить значения для прямоугольника.

109
00:07:29,965 --> 00:07:35,165
Но вместо этого я просто передаю

110
00:07:35,165 --> 00:07:40,020
объект JavaScript, содержащий две функции в

111
00:07:40,020 --> 00:07:45,330
качестве двух значений внутри этого объекта JavaScript.

112
00:07:45,330 --> 00:07:50,355
Итак, здесь я возьму эти два,

113
00:07:50,355 --> 00:07:54,530
периметр и площадь,

114
00:07:55,250 --> 00:08:05,639
а затем эти два будут переданы в качестве двух значений здесь,

115
00:08:05,639 --> 00:08:07,807
периметр и площадь.

116
00:08:07,807 --> 00:08:12,740
И эти два, так как они являются объектом JavaScript,

117
00:08:12,740 --> 00:08:16,544
поэтому периметр и площадь будут

118
00:08:16,544 --> 00:08:22,690
двумя свойствами, которые я передам внутри этого объекта JavaScript,

119
00:08:22,690 --> 00:08:25,295
и это все.

120
00:08:25,295 --> 00:08:28,570
Итак, во втором случае

121
00:08:28,570 --> 00:08:32,034
ошибка устанавливается в null, потому что ошибки нет,

122
00:08:32,034 --> 00:08:33,190
но вторая часть,

123
00:08:33,190 --> 00:08:37,715
обратите внимание, что я передаю объект JavaScript, содержащий два свойства,

124
00:08:37,715 --> 00:08:41,530
периметр и площадь, которые являются двумя функциями здесь.

125
00:08:41,530 --> 00:08:46,060
Таким образом, две функции являются функцией периметра и функцией площади.

126
00:08:46,060 --> 00:08:49,390
Таким образом, этот объект JavaScript будет передан обратно

127
00:08:49,390 --> 00:08:53,705
в качестве возвращаемого значения для обратного вызова здесь, второе значение.

128
00:08:53,705 --> 00:08:56,035
И снова, я собираюсь отложить это на

129
00:08:56,035 --> 00:09:02,900
два второго интервала, прежде чем значение будет передано обратно этой функцией.

130
00:09:02,900 --> 00:09:07,075
Причина, по которой я использую setTimeout, заключается в имитации

131
00:09:07,075 --> 00:09:11,780
задержки до того, как обратный вызов поступит с другой стороны.

132
00:09:11,780 --> 00:09:15,280
Таким образом, этот вид представляет ситуации, когда, например,

133
00:09:15,280 --> 00:09:18,565
вы выдаете вызов базы данных в базу данных,

134
00:09:18,565 --> 00:09:23,300
и база данных должна быть прочитана, прежде чем значение будет передано вам обратно.

135
00:09:23,300 --> 00:09:25,855
Так что это займет определенное количество времени.

136
00:09:25,855 --> 00:09:32,560
Поэтому я в основном моделирую это в данный момент, используя функцию setTimeout здесь.

137
00:09:32,560 --> 00:09:37,000
Позже вы увидите, что когда мы интегрируем MongoDB с

138
00:09:37,000 --> 00:09:43,060
нашим Express в последующих упражнениях,

139
00:09:43,060 --> 00:09:45,580
что задержка должна быть смоделирована,

140
00:09:45,580 --> 00:09:48,670
она будет автоматически вызвана из-за того, что вам нужно делать

141
00:09:48,670 --> 00:09:54,190
операции с базой данных за кулисами до получения данных.

142
00:09:54,190 --> 00:10:00,325
Итак, здесь, завершив обновление модулей прямоугольника,

143
00:10:00,325 --> 00:10:03,135
поэтому здесь вы видите, что модуль прямоугольника принимает

144
00:10:03,135 --> 00:10:06,830
три параметра, поскольку это входной вызов здесь,

145
00:10:06,830 --> 00:10:08,920
x, y и обратный вызов.

146
00:10:08,920 --> 00:10:12,445
Итак, обратный вызов - это функция обратного вызова, которая поставляется здесь.

147
00:10:12,445 --> 00:10:16,585
И эта функция обратного вызова будет вызываться внутри здесь,

148
00:10:16,585 --> 00:10:18,685
и когда вызывается функция обратного вызова,

149
00:10:18,685 --> 00:10:22,495
либо вы передаете ошибку, либо

150
00:10:22,495 --> 00:10:28,045
передаете обратно функцию, которая позволяет вычислить периметр и площадь прямоугольника.

151
00:10:28,045 --> 00:10:33,835
Теперь этот шаблон вызова и передачи функции обратного вызова

152
00:10:33,835 --> 00:10:40,300
из одного модуля Node, а затем второго модуля Node, который, когда он завершит,

153
00:10:40,300 --> 00:10:44,800
будет передавать результат, используя функцию обратного вызова, является

154
00:10:44,800 --> 00:10:50,135
именно шаблоном, который вы увидите часто повторяющиеся в приложениях Node.

155
00:10:50,135 --> 00:10:52,360
Вот почему я иллюстрирую это.

156
00:10:52,360 --> 00:10:58,735
Конечно, это надуманный пример, который я иллюстрирую здесь, но он показывает

157
00:10:58,735 --> 00:11:02,525
все стандартные шаблоны, которые вы будете использовать с

158
00:11:02,525 --> 00:11:07,065
функциями узла и обратного вызова, а также обработку ошибок.

159
00:11:07,065 --> 00:11:10,955
Теперь мы обновили модуль прямоугольника здесь.

160
00:11:10,955 --> 00:11:16,870
Давайте исправим этот файл index.js, чтобы он мог передавать функцию обратного вызова, а

161
00:11:16,870 --> 00:11:23,770
затем обрабатывать возвращаемое значение, которое отправляется обратно из модуля прямоугольника.

162
00:11:23,770 --> 00:11:26,940
Возвращаясь к index.js,

163
00:11:26,940 --> 00:11:31,270
теперь мы собираемся обновить файл index.js следующим образом.

164
00:11:31,270 --> 00:11:37,955
Вместо этого я удалю это из файла index.js.

165
00:11:37,955 --> 00:11:42,430
Здесь, то, что мы будем делать, это вызвать

166
00:11:42,430 --> 00:11:49,120
этот прямоугольный модуль, а

167
00:11:49,120 --> 00:11:53,880
затем передать в l и b в качестве двух параметров.

168
00:11:53,880 --> 00:12:00,300
И третий параметр, который я собираюсь передать, - это функция обратного вызова.

169
00:12:00,300 --> 00:12:10,080
Таким образом, функция обратного вызова имеет два параметра, err и прямоугольник.

170
00:12:10,080 --> 00:12:15,860
И эта функция обратного вызова реализуется следующим образом.

171
00:12:15,860 --> 00:12:19,090
Итак, здесь вы видите, что я вызываю

172
00:12:19,090 --> 00:12:23,785
этот прямоугольный модуль узла,

173
00:12:23,785 --> 00:12:29,050
и я передаю длину и ширину первых двух параметров.

174
00:12:29,050 --> 00:12:31,285
И третий параметр - это, конечно,

175
00:12:31,285 --> 00:12:34,355
функция обратного вызова, которую я реализую здесь.

176
00:12:34,355 --> 00:12:38,250
Итак, это функция стрелки, которую я реализую здесь.

177
00:12:38,250 --> 00:12:40,510
Итак, внутри этой функции обратного вызова,

178
00:12:40,510 --> 00:12:43,245
как мне обрабатывать возвращаемое значение?

179
00:12:43,245 --> 00:12:46,860
Поэтому здесь я скажу, if (err),

180
00:12:46,860 --> 00:12:51,335
поэтому, если вам возвращается значение ошибки, я

181
00:12:51,335 --> 00:12:59,500
просто сделаю console.log, и я скажу

182
00:12:59,500 --> 00:13:09,100
«ERROR», а затем второе значение - err.message.

183
00:13:09,100 --> 00:13:11,445
Напомним, что в прямоугольнике

184
00:13:11,445 --> 00:13:14,820
мы создали этот новый объект ошибки,

185
00:13:14,820 --> 00:13:18,155
а затем передали эту строку внутри этого объекта ошибки.

186
00:13:18,155 --> 00:13:20,100
Эта строка будет прикреплена к

187
00:13:20,100 --> 00:13:24,380
объекту ошибки к свойству message объекта ошибки здесь.

188
00:13:24,380 --> 00:13:26,830
Итак, в файле index.js,

189
00:13:26,830 --> 00:13:30,090
поэтому я извлекаю свойство сообщения объекта ошибки,

190
00:13:30,090 --> 00:13:33,755
а затем печатаю его на моей консоли здесь.

191
00:13:33,755 --> 00:13:35,310
Поэтому, если произойдет ошибка,

192
00:13:35,310 --> 00:13:39,215
я собираюсь распечатать сообщение об ошибке, используя это.

193
00:13:39,215 --> 00:13:45,820
Итак, вот как я буду обрабатывать ошибку, которая была возвращена функцией обратного вызова.

194
00:13:45,820 --> 00:13:51,360
В противном случае, конечно, в этом случае

195
00:13:51,360 --> 00:13:57,450
модуль прямоугольника вернул функцию прямоугольника,

196
00:13:57,450 --> 00:14:01,620
объект, который содержит периметр и функции области,

197
00:14:01,620 --> 00:14:08,108
поэтому я могу идти вперед и распечатать это значение.

198
00:14:08,108 --> 00:14:14,175
Итак, здесь я скажу площадь

199
00:14:14,175 --> 00:14:23,030
прямоугольника размеров l равна,

200
00:14:23,140 --> 00:14:28,270
так что я скажу,

201
00:14:29,170 --> 00:14:37,155
и b равно.

202
00:14:37,155 --> 00:14:40,530
Причина, по которой я идентифицирую его

203
00:14:40,530 --> 00:14:47,340
явно, станет очень ясной, когда мы запускаем этот пример.

204
00:14:47,340 --> 00:15:01,480
Я скажу, что прямоугольный.area.

205
00:15:01,480 --> 00:15:04,188
Теперь обратите внимание, что для этой области

206
00:15:04,188 --> 00:15:09,555
я не отправляю никаких параметров здесь, потому что идет к значениям,

207
00:15:09,555 --> 00:15:14,540
длина и дыхание были переданы уже здесь, в l и b,

208
00:15:14,540 --> 00:15:19,065
и они будут уже доступны для этого

209
00:15:19,065 --> 00:15:24,245
и здесь из-за закрытия, которое поддерживает JavaScript.

210
00:15:24,245 --> 00:15:27,470
Поскольку эти x и y вошли в качестве параметров,

211
00:15:27,470 --> 00:15:32,710
поэтому они будут доступны прямо там в этой функции обратного вызова.

212
00:15:32,710 --> 00:15:37,315
Таким образом, эти x_y будут автоматически доступны для нас здесь.

213
00:15:37,315 --> 00:15:39,890
Итак, на самом деле,

214
00:15:39,890 --> 00:15:43,970
мне не нужно предоставлять эти параметры x и y здесь вообще, потому что

215
00:15:43,970 --> 00:15:49,090
эти x и y будут извлечены из этих x и y прямо там.

216
00:15:49,090 --> 00:15:53,375
Так что мне даже не нужно передавать эти два значения здесь.

217
00:15:53,375 --> 00:15:55,385
Вот почему, прямо там,

218
00:15:55,385 --> 00:15:57,905
я могу вызвать rectangle.area.

219
00:15:57,905 --> 00:16:03,170
И это вычисление площади автоматически получит l и b, которые были переданы

220
00:16:03,170 --> 00:16:09,505
путем вызова прямоугольника к модулю прямого узла ранее.

221
00:16:09,505 --> 00:16:14,980
Таким образом, это закрытие JavaScript, работающего здесь.

222
00:16:14,980 --> 00:16:17,945
Итак, это первый.

223
00:16:17,945 --> 00:16:23,305
Я печатаю область прямоугольника.

224
00:16:23,305 --> 00:16:32,990
То же самое, позвольте мне распечатать периметры.

225
00:16:32,990 --> 00:16:34,608
Так что, чтобы распечатать периметры,

226
00:16:34,608 --> 00:16:36,720
так что я скажу console.log.

227
00:16:36,720 --> 00:16:46,560
Периметр прямоугольника будет представлять собой периметр прямоугольника.

228
00:16:46,560 --> 00:16:53,280
Теперь я должен сказать вам, что такой подход для реализации требует немного

229
00:16:53,280 --> 00:17:02,335
усилий, чтобы понять и интернализировать способность асинхронной функции.

230
00:17:02,335 --> 00:17:06,360
Требуется некоторое время для того, чтобы полностью понять, как это работает на самом деле.

231
00:17:06,360 --> 00:17:08,550
Теперь, чтобы проиллюстрировать тот факт, что

232
00:17:08,550 --> 00:17:14,642
этот вызов функции приведет к вызову модуля Node,

233
00:17:14,642 --> 00:17:19,280
но эта часть будет выполнена только после

234
00:17:19,280 --> 00:17:24,830
двухсекундной задержки из-за того, что мы используем заданную метку времени.

235
00:17:24,830 --> 00:17:28,745
Теперь, когда мы изучали асинхронную работу,

236
00:17:28,745 --> 00:17:33,155
потому что мы перешли от обработки к спине,

237
00:17:33,155 --> 00:17:41,420
позвольте мне также представить еще один console.log здесь, чтобы сделать точку зрения.

238
00:17:41,420 --> 00:17:46,175
Так что мы скажем, что это

239
00:17:46,175 --> 00:17:53,869
заявление после вызова rect.

240
00:17:53,869 --> 00:18:00,210
Причина, по которой я иллюстрирую этот момент, заключается в том, что когда вы выдаете

241
00:18:00,210 --> 00:18:06,130
этот вызов, этот код не будет выполнен до двухсекундной задержки.

242
00:18:06,130 --> 00:18:08,070
Таким образом, пока

243
00:18:08,070 --> 00:18:10,360
ваша функция, основная функция здесь,

244
00:18:10,360 --> 00:18:16,340
будет продолжаться, а затем выполнять следующую строку кода, который вы видите здесь.

245
00:18:16,340 --> 00:18:19,745
Так что это продолжение, которое вы увидите здесь.

246
00:18:19,745 --> 00:18:21,805
Итак, с этими изменениями,

247
00:18:21,805 --> 00:18:27,815
давайте сохраним изменения, а затем посмотрим, как это приложение выполняется сейчас.

248
00:18:27,815 --> 00:18:29,410
Так что сохраняя изменения.

249
00:18:29,410 --> 00:18:35,220
Давайте перейдем к терминалу и выполним этот узел приложения.

250
00:18:35,220 --> 00:18:37,570
Теперь, перейдя к терминалу, добавьте подсказку.

251
00:18:37,570 --> 00:18:43,795
Позвольте мне ввести npm start, и вы сразу

252
00:18:43,795 --> 00:18:51,790
заметите, что решение и это заявление были распечатаны ранее.

253
00:18:51,790 --> 00:18:54,505
И затем после этой определенной задержки,

254
00:18:54,505 --> 00:18:57,855
площадь и периметр были распечатаны.

255
00:18:57,855 --> 00:19:02,130
Таким образом, это двухсекундная задержка, которую мы ввели с использованием заданного тайм-аута.

256
00:19:02,130 --> 00:19:05,755
Итак, вы заметили, что в более ранней версии

257
00:19:05,755 --> 00:19:10,290
это было напечатано, и сразу же под ним была напечатана область и периметр.

258
00:19:10,290 --> 00:19:15,120
Но теперь обратите внимание, что эти значения печатаются немного позже.

259
00:19:15,120 --> 00:19:20,460
Таким образом, между ними их вызовы функций с различными параметрами, которые уже

260
00:19:20,460 --> 00:19:26,505
вошли, а затем обратные вызовы вызываются после двух секунд задержки для каждого из них.

261
00:19:26,505 --> 00:19:32,500
И из-за того, что есть закрытие, которое поддерживает JavaScript,

262
00:19:32,500 --> 00:19:35,980
поэтому значения, которые передаются, сохраняются.

263
00:19:35,980 --> 00:19:38,440
И поэтому, когда вызывается функция обратного вызова,

264
00:19:38,440 --> 00:19:40,615
печатается соответствующее значение.

265
00:19:40,615 --> 00:19:42,730
Вот почему вы видите, что площадь и

266
00:19:42,730 --> 00:19:46,330
периметр напечатаны правильно и эти два здесь,

267
00:19:46,330 --> 00:19:48,070
эти два утверждения здесь,

268
00:19:48,070 --> 00:19:51,340
соответствуют этому конкретному вызову прямого

269
00:19:51,340 --> 00:19:55,100
с l равно два и b равно четырем.

270
00:19:55,100 --> 00:19:56,605
И тогда эти два,

271
00:19:56,605 --> 00:19:58,150
рядом с двумя, конечно,

272
00:19:58,150 --> 00:20:05,000
соответствуют этому конкретному, а остальные, как вы видите здесь.

273
00:20:05,000 --> 00:20:10,410
Итак, я хотел проиллюстрировать тот факт, что при асинхронном вычислении

274
00:20:10,410 --> 00:20:12,730
асинхронное вычисление занимает свое собственное время,

275
00:20:12,730 --> 00:20:16,270
чтобы вернуть значение, в то время как ваше основное вычисление

276
00:20:16,270 --> 00:20:22,460
будет продолжаться вперед, не дожидаясь завершения обратного вызова.

277
00:20:22,460 --> 00:20:25,245
Итак, когда вам нужно выполнить определенный объем работы,

278
00:20:25,245 --> 00:20:29,365
вы передали в качестве обратного вызова этому другому модулю.

279
00:20:29,365 --> 00:20:31,375
И когда этот другой модуль завершит свою работу,

280
00:20:31,375 --> 00:20:35,010
он будет обратный вызов, а затем этот код будет выполнен.

281
00:20:35,010 --> 00:20:40,350
Вот тот момент, который я проиллюстрировал, используя этот пример.

282
00:20:40,350 --> 00:20:41,565
Опять же, как я уже сказал,

283
00:20:41,565 --> 00:20:45,210
это требует немного воображения и понимания

284
00:20:45,210 --> 00:20:48,930
для вас, чтобы интернализировать, как это работает,

285
00:20:48,930 --> 00:20:55,185
но вы увидите, что с Node, а также Express, и когда мы используем MongoDB,

286
00:20:55,185 --> 00:21:01,785
вы увидите такой шаблон, повторяющийся очень часто в том, как мы пишем наш код.

287
00:21:01,785 --> 00:21:06,210
Таким образом, с помощью этой простой иллюстрации обратных вызовов и обработки ошибок

288
00:21:06,210 --> 00:21:08,940
мы завершаем это упражнение.

289
00:21:08,940 --> 00:21:13,675
Это хорошее время для вас сделать комментарий с этим сообщением,

290
00:21:13,675 --> 00:21:17,700
узлом, обратными вызовами и обработкой ошибок.