1
00:00:03,680 --> 00:00:07,140
Обсуждение модулей узлов является неполным,

2
00:00:07,140 --> 00:00:10,310
не говоря о обратных вызовах и обработке ошибок.

3
00:00:10,310 --> 00:00:14,820
Что такое обратные вызовы и почему они необходимы для

4
00:00:14,820 --> 00:00:17,250
поддержки асинхронных вычислений, которые очень

5
00:00:17,250 --> 00:00:20,610
полезны при написании приложений Node.js?

6
00:00:20,610 --> 00:00:25,130
Как выполняется обработка ошибок в приложениях Node?

7
00:00:25,130 --> 00:00:29,615
Давайте кратко поговорим об этом в этой лекции.

8
00:00:29,615 --> 00:00:34,305
Прежде чем мы продолжим говорить о модулях Node и обратных вызовах,

9
00:00:34,305 --> 00:00:40,315
нам нужно понять две характерные особенности самого языка JavaScript.

10
00:00:40,315 --> 00:00:46,295
Прежде всего, JavaScript поддерживает то, что называется первоклассными функциями.

11
00:00:46,295 --> 00:00:48,430
Что мы имеем в виду под первоклассными функциями?

12
00:00:48,430 --> 00:00:52,838
В том, что функция может обрабатываться так же, как и любая другая переменная.

13
00:00:52,838 --> 00:00:55,620
И, следовательно, функции могут передаваться как

14
00:00:55,620 --> 00:01:00,955
параметры внутри вызовов функций к другим функциям.

15
00:01:00,955 --> 00:01:06,630
И это по существу позволяет нам отправлять функции в качестве функций обратного вызова, которые могут быть

16
00:01:06,630 --> 00:01:14,110
вызваны из другого модуля Node, чтобы получить некоторую работу.

17
00:01:14,110 --> 00:01:20,010
Затем посмотрите, как это очень полезно при поддержке обратных вызовов в Node.js.

18
00:01:20,010 --> 00:01:25,107
Второй аспект JavaScript - это поддержка Closers.

19
00:01:25,107 --> 00:01:26,835
Что мы имеем в виду под закрытиями?

20
00:01:26,835 --> 00:01:31,185
Особенно, если вы знакомы с функциональными языками программирования,

21
00:01:31,185 --> 00:01:33,325
вы понимаете, как работает закрытие.

22
00:01:33,325 --> 00:01:37,050
Функция, определенная внутри другой функции,

23
00:01:37,050 --> 00:01:42,955
автоматически получает доступ к переменным, объявленным во внешней функции.

24
00:01:42,955 --> 00:01:46,185
Поэтому, даже если внешняя функция завершается выполнение,

25
00:01:46,185 --> 00:01:51,000
когда внутренняя функция выполняется позже, внутренняя функция все равно будет иметь доступ

26
00:01:51,000 --> 00:01:56,020
к значениям переменных внутри этой внешней функции.

27
00:01:56,020 --> 00:01:57,465
И это снова,

28
00:01:57,465 --> 00:02:05,244
очень эффективно используется, когда мы используем обратные вызовы в приложениях Node.

29
00:02:05,244 --> 00:02:08,790
Если вы привыкли к стандартному способу написания приложений,

30
00:02:08,790 --> 00:02:12,870
то вы знакомы с синхронными вычислениями, где вы

31
00:02:12,870 --> 00:02:17,918
указываете вычисление как набор шагов, которые должны выполняться один за другим.

32
00:02:17,918 --> 00:02:21,165
Теперь, если вы организуете вычисления следующим образом,

33
00:02:21,165 --> 00:02:27,885
как показано на левой стороне слайда здесь,

34
00:02:27,885 --> 00:02:33,260
у нас есть вычисление один, а затем длительное вычисление,

35
00:02:33,260 --> 00:02:36,095
затем вычисление два, и вычисление три.

36
00:02:36,095 --> 00:02:38,400
Таким образом, в этой договоренности

37
00:02:38,400 --> 00:02:41,940
давайте предположим, что вычисление два зависит от

38
00:02:41,940 --> 00:02:45,250
длительных вычислений, завершающих свою работу,

39
00:02:45,250 --> 00:02:48,690
тогда имеет смысл для вычисления два ждать, пока

40
00:02:48,690 --> 00:02:53,430
длительное вычисление не будет завершено, прежде чем оно будет выполнено.

41
00:02:53,430 --> 00:02:56,670
Теперь у нас может

42
00:02:56,670 --> 00:03:00,435
быть еще одна часть работы, которая определяется вычислением три.

43
00:03:00,435 --> 00:03:05,055
Вычисление три может быть в noway зависеть от вычисления два,

44
00:03:05,055 --> 00:03:11,092
или длительное вычисление для завершения до его выполнения.

45
00:03:11,092 --> 00:03:12,420
Поэтому в этом случае,

46
00:03:12,420 --> 00:03:16,635
если мы сделаем синхронное выполнение этого

47
00:03:16,635 --> 00:03:18,825
вычисления, то вычисление три

48
00:03:18,825 --> 00:03:23,895
застрянет, хотя это никоим образом не зависит от завершения либо вычисления два,

49
00:03:23,895 --> 00:03:25,800
либо длительных вычислений.

50
00:03:25,800 --> 00:03:29,310
Таким образом, объем работы, которая должна быть выполнена вычислением три,

51
00:03:29,310 --> 00:03:35,625
будет отложен, потому что это не собственная причина, не так ли?

52
00:03:35,625 --> 00:03:41,725
Вместо этого задерживается из-за чего-то, что предшествует ему в последовательности вычислений.

53
00:03:41,725 --> 00:03:45,735
Теперь, асинхронное вычисление, мы можем перестроить эту работу

54
00:03:45,735 --> 00:03:50,265
таким образом, что вычисление, когда оно завершится,

55
00:03:50,265 --> 00:03:57,350
может породить эти длительные вычисления, которые будут выполняться за кулисами независимо,

56
00:03:57,350 --> 00:04:02,706
и поскольку вычисление два зависит от длительных вычислений для завершения,

57
00:04:02,706 --> 00:04:09,314
то вычисление два может быть выполнено, когда длительное вычисление закончено.

58
00:04:09,314 --> 00:04:14,265
Теперь это освобождает вычисления три для продолжения,

59
00:04:14,265 --> 00:04:16,820
сразу после завершения вычисления.

60
00:04:16,820 --> 00:04:18,585
Таким образом, этот способ организации

61
00:04:18,585 --> 00:04:22,815
гарантирует, что вычисление три закончится намного быстрее, чем

62
00:04:22,815 --> 00:04:28,000
застряло за длительным вычислением, и вычисление два.

63
00:04:28,000 --> 00:04:33,945
Таким образом, этот подход к перестройке вашей работы очень полезен, особенно

64
00:04:33,945 --> 00:04:37,650
когда у вас есть длительное

65
00:04:37,650 --> 00:04:40,000
вычисление, связанное с вводом.

66
00:04:40,000 --> 00:04:43,174
Таким образом, в этом случае вы можете создать вычисление привязки ввода-вывода,

67
00:04:43,174 --> 00:04:44,700
и когда это завершится,

68
00:04:44,700 --> 00:04:47,580
то все, что нужно сделать после этого,

69
00:04:47,580 --> 00:04:51,830
может быть отправлено ему как обратный вызов.

70
00:04:51,830 --> 00:04:54,540
Таким образом, вычисление два будет превращено в

71
00:04:54,540 --> 00:04:58,490
обратный вызов, а затем отдано на длительное вычисление.

72
00:04:58,490 --> 00:05:01,440
Поэтому, когда это завершит свою работу,

73
00:05:01,440 --> 00:05:07,015
он вызовет функцию, которая заключена внутри обратного вызова.

74
00:05:07,015 --> 00:05:11,020
Таким образом, это очень эффективно используется Node.js при

75
00:05:11,020 --> 00:05:17,250
переорганизации вычислений в наших приложениях Node.

76
00:05:17,250 --> 00:05:20,740
Теперь это очень,

77
00:05:20,740 --> 00:05:25,520
очень полезно, когда мы смотрим на то, как работает сам Node.js.

78
00:05:25,520 --> 00:05:26,735
Таким образом, как мы понимаем,

79
00:05:26,735 --> 00:05:31,830
Node.js организован в один поточный цикл событий.

80
00:05:31,830 --> 00:05:34,690
Этот однопоточный цикл событий в основном

81
00:05:34,690 --> 00:05:39,620
собирает запросы по мере их поступления и выполняет его один за другим.

82
00:05:39,620 --> 00:05:42,592
Всякий раз, когда ему нужно вызвать запрос ввода-вывода,

83
00:05:42,592 --> 00:05:44,650
запрос ввода-вывода будет вызван,

84
00:05:44,650 --> 00:05:48,910
и любая работа, которая должна быть выполнена после завершения запроса ввода-вывода,

85
00:05:48,910 --> 00:05:51,330
будет заключена внутри обратного вызова.

86
00:05:51,330 --> 00:05:52,940
Поэтому, когда запрос ввода-вывода завершается,

87
00:05:52,940 --> 00:05:55,660
он поместит обратный вызов в очередь запросов,

88
00:05:55,660 --> 00:05:58,510
и обратный вызов будет обрабатываться после этого,

89
00:05:58,510 --> 00:06:00,030
циклом событий.

90
00:06:00,030 --> 00:06:02,890
Таким образом, цикл событий - это непрерывный цикл,

91
00:06:02,890 --> 00:06:06,595
который в основном забирает запросы из очереди запросов,

92
00:06:06,595 --> 00:06:09,240
а затем обслуживает их по одному за раз.

93
00:06:09,240 --> 00:06:11,470
Поэтому, когда вы вспоминаете об этом,

94
00:06:11,470 --> 00:06:14,093
вы понимаете, что Node.js является однопоточным

95
00:06:14,093 --> 00:06:15,340
, но в то же время

96
00:06:15,340 --> 00:06:19,645
он способен достичь гораздо более быстрой скорости завершения работы,

97
00:06:19,645 --> 00:06:24,580
просто из-за разумного использования обратных вызовов

98
00:06:24,580 --> 00:06:29,680
и асинхронного выполнения запросов ввода-вывода,

99
00:06:29,680 --> 00:06:32,815
например для файла доступа или базы данных,

100
00:06:32,815 --> 00:06:39,280
или длительной обработки, которая может быть выполнена независимо за кулисами.

101
00:06:39,280 --> 00:06:43,045
Теперь цикл событий Node.js обрабатывает все это,

102
00:06:43,045 --> 00:06:48,410
заключается в том, что цикл событий расположен в последовательности фаз.

103
00:06:48,410 --> 00:06:51,710
Так, как вы видите на диаграмме, показанной здесь,

104
00:06:51,710 --> 00:06:55,060
фазы включают обработку таймера,

105
00:06:55,060 --> 00:06:58,390
обработку обратного вызова ввода-вывода, затем у вас простоя, подготовка,

106
00:06:58,390 --> 00:07:05,800
затем опрос, где обрабатываются входящие запросы на подключения или данные,

107
00:07:05,800 --> 00:07:07,585
а затем этап проверки,

108
00:07:07,585 --> 00:07:10,290
а затем, наконец, этап закрытия обратных вызовов.

109
00:07:10,290 --> 00:07:16,351
Теперь некоторые подробности о том, что делается на каждом из этих этапов, перечислены справа.

110
00:07:16,351 --> 00:07:17,905
В фазе таймера

111
00:07:17,905 --> 00:07:21,550
цикл событий обрабатывает все, что запускается

112
00:07:21,550 --> 00:07:25,770
функцией setTimeout () в JavaScript.

113
00:07:25,770 --> 00:07:29,010
Вызовы ввода-вывода выполняются,

114
00:07:29,010 --> 00:07:32,620
почти все обратные вызовы, которые возвращаются для

115
00:07:32,620 --> 00:07:36,795
выполнения после запроса ввода-вывода, будут обрабатываться очередью обратных вызовов ввода-вывода.

116
00:07:36,795 --> 00:07:41,065
Таким образом, каждый из этих этапов поддерживает свою собственную отдельную очередь,

117
00:07:41,065 --> 00:07:46,053
и цикл событий Node.js собирает запросы из каждой из этих очередей и обрабатывает их.

118
00:07:46,053 --> 00:07:52,150
, простаивает, подготовить, предназначен для внутреннего использования Node.js.

119
00:07:52,150 --> 00:07:57,910
Опрос - это то, где он извлекает новые события ввода-вывода для обработки и, возможно,

120
00:07:57,910 --> 00:08:00,313
запросы, поступающие извне.

121
00:08:00,313 --> 00:08:08,354
Фаза закрытого обратного вызова обрабатывает любые закрытия сокета, которые должны быть обработаны, и так далее.

122
00:08:08,354 --> 00:08:11,050
Теперь нам не нужно слишком беспокоиться обо

123
00:08:11,050 --> 00:08:15,430
всех этих деталях, если нам нужно действительно написать приложение Node.js.

124
00:08:15,430 --> 00:08:19,720
При необходимости, мы рассмотрим некоторые из этих деталей, как и когда

125
00:08:19,720 --> 00:08:25,030
это важно для понимания того, как работает наше приложение Node.

126
00:08:25,030 --> 00:08:27,985
Но на данный момент это дает вам представление

127
00:08:27,985 --> 00:08:31,990
о том, как обрабатывается цикл событий Node.js.

128
00:08:31,990 --> 00:08:35,830
Достаточно сказать, что этого достаточно информации для нас, чтобы

129
00:08:35,830 --> 00:08:40,590
понять приложения Node и как они работают на данный момент.

130
00:08:40,590 --> 00:08:42,895
Если вы хотите узнать более подробную информацию,

131
00:08:42,895 --> 00:08:46,810
я дал вам ссылку на подробное описание в

132
00:08:46,810 --> 00:08:53,930
документации Node.js, в котором более подробно описывается цикл событий.

133
00:08:53,930 --> 00:08:58,615
С этим быстрым пониманием Node,

134
00:08:58,615 --> 00:09:01,445
Callbacks и обработки ошибок,

135
00:09:01,445 --> 00:09:03,296
мы перейдем к упражнению,

136
00:09:03,296 --> 00:09:09,280
где мы рассмотрим, как приложение Node может писать с Callbacks,

137
00:09:09,280 --> 00:09:14,110
и как ошибки могут быть обработаны внутри приложения Node.

138
00:09:14,110 --> 00:09:18,840
Мы увидим повторное использование этого шаблона в последующих упражнениях

139
00:09:18,840 --> 00:09:21,421
и последующих уроках конкретно,

140
00:09:21,421 --> 00:09:22,960
когда мы посмотрим на Express,

141
00:09:22,960 --> 00:09:26,860
и как мы строим серверные приложения с помощью Express

142
00:09:26,860 --> 00:09:32,720
более подробно в более поздней части этого курса.