1
00:00:03,680 --> 00:00:07,140
Một cuộc thảo luận về Node Modules là

2
00:00:07,140 --> 00:00:10,310
không đầy đủ mà không nói về Callbacks và xử lý lỗi.

3
00:00:10,310 --> 00:00:14,820
callbacks là gì và tại sao họ cần thiết để

4
00:00:14,820 --> 00:00:17,250
hỗ trợ tính toán không đồng bộ là rất

5
00:00:17,250 --> 00:00:20,610
hữu ích khi chúng tôi viết các ứng dụng Node.js?

6
00:00:20,610 --> 00:00:25,130
Xử lý lỗi được thực hiện như thế nào trong các ứng dụng Node?

7
00:00:25,130 --> 00:00:29,615
Chúng ta hãy nói ngắn gọn về những điều này trong bài giảng này.

8
00:00:29,615 --> 00:00:34,305
Trước khi chúng ta tiếp tục nói về Node Modules và Callbacks,

9
00:00:34,305 --> 00:00:40,315
chúng ta cần phải hiểu hai tính năng nổi bật về ngôn ngữ JavaScript chính nó.

10
00:00:40,315 --> 00:00:46,295
Đầu tiên và quan trọng nhất, JavaScript hỗ trợ những gì được gọi là hàm hạng nhất.

11
00:00:46,295 --> 00:00:48,430
Chúng ta có ý nghĩa gì của các chức năng hạng nhất?

12
00:00:48,430 --> 00:00:52,838
Đó là một chức năng có thể được xử lý giống như bất kỳ biến khác.

13
00:00:52,838 --> 00:00:55,620
Và do đó, các hàm có thể được truyền lại như các

14
00:00:55,620 --> 00:01:00,955
tham số bên trong các cuộc gọi hàm đến các hàm khác.

15
00:01:00,955 --> 00:01:06,630
Và điều đó về cơ bản cho phép chúng tôi gửi các chức năng như hàm callback có thể được

16
00:01:06,630 --> 00:01:14,110
gọi từ một module Node khác để có được một số công việc hoàn thành.

17
00:01:14,110 --> 00:01:20,010
Sau đó nhìn vào cách này là rất hữu ích trong việc hỗ trợ callbacks trong Node.js.

18
00:01:20,010 --> 00:01:25,107
Khía cạnh thứ hai về JavaScript là sự hỗ trợ cho Closures.

19
00:01:25,107 --> 00:01:26,835
Những gì chúng tôi có ý nghĩa của Closures?

20
00:01:26,835 --> 00:01:31,185
Đặc biệt, nếu bạn đã quen thuộc với các ngôn ngữ lập trình chức năng,

21
00:01:31,185 --> 00:01:33,325
bạn sẽ hiểu cách đóng cửa hoạt động.

22
00:01:33,325 --> 00:01:37,050
Một hàm được định nghĩa bên trong một hàm khác

23
00:01:37,050 --> 00:01:42,955
sẽ tự động truy cập vào các biến được khai báo trong hàm bên ngoài.

24
00:01:42,955 --> 00:01:46,185
Vì vậy, ngay cả khi hàm bên ngoài được thực thi hoàn tất,

25
00:01:46,185 --> 00:01:51,000
khi hàm bên trong thực thi sau này hàm bên trong vẫn sẽ có quyền truy cập vào

26
00:01:51,000 --> 00:01:56,020
các giá trị của các biến bên trong hàm bên ngoài đó.

27
00:01:56,020 --> 00:01:57,465
Và đây là một lần nữa,

28
00:01:57,465 --> 00:02:05,244
rất hiệu quả được sử dụng khi chúng ta sử dụng Callbacks trong các ứng dụng Node.

29
00:02:05,244 --> 00:02:08,790
Nếu bạn đã quen với cách viết tiêu chuẩn các ứng dụng,

30
00:02:08,790 --> 00:02:12,870
thì bạn đã quen thuộc với tính toán đồng bộ, nơi bạn

31
00:02:12,870 --> 00:02:17,918
chỉ định một tính toán như một tập hợp các bước cần thực hiện cái khác.

32
00:02:17,918 --> 00:02:21,165
Bây giờ, nếu bạn tổ chức tính toán của bạn như sau,

33
00:02:21,165 --> 00:02:27,885
như được hiển thị ở phía bên trái của slide ở đây,

34
00:02:27,885 --> 00:02:33,260
chúng tôi có tính toán một sau đó là một tính toán chạy dài,

35
00:02:33,260 --> 00:02:36,095
tiếp theo là tính toán hai, và tính toán ba.

36
00:02:36,095 --> 00:02:38,400
Vì vậy, trong sự sắp xếp này,

37
00:02:38,400 --> 00:02:41,940
chúng ta hãy giả định rằng tính toán hai là phụ

38
00:02:41,940 --> 00:02:45,250
thuộc vào tính toán chạy dài hoàn thành công việc của nó,

39
00:02:45,250 --> 00:02:48,690
sau đó nó có ý nghĩa cho tính toán hai để chờ cho đến khi

40
00:02:48,690 --> 00:02:53,430
tính toán chạy dài được hoàn thành trước khi nó được thực hiện.

41
00:02:53,430 --> 00:02:56,670
Bây giờ, chúng ta có thể có một phần khác của công việc

42
00:02:56,670 --> 00:03:00,435
được thực hiện được định nghĩa bởi tính toán ba.

43
00:03:00,435 --> 00:03:05,055
Tính toán ba có thể là trong noway phụ thuộc vào tính toán hai,

44
00:03:05,055 --> 00:03:11,092
hoặc tính toán chạy dài để hoàn thành trước khi nó được thực hiện.

45
00:03:11,092 --> 00:03:12,420
Vì vậy, trong trường hợp này,

46
00:03:12,420 --> 00:03:16,635
nếu chúng ta thực hiện đồng bộ của tính toán này,

47
00:03:16,635 --> 00:03:18,825
sau đó tính toán ba sẽ bị mắc kẹt,

48
00:03:18,825 --> 00:03:23,895
mặc dù nó không phải là cách nào phụ thuộc vào việc hoàn thành một

49
00:03:23,895 --> 00:03:25,800
trong hai tính toán hai, hoặc tính toán chạy dài.

50
00:03:25,800 --> 00:03:29,310
Vì vậy, do đó, số lượng công việc phải được thực hiện bằng cách tính toán ba,

51
00:03:29,310 --> 00:03:35,625
sẽ bị trì hoãn vì không có lý do của nó, đúng không?

52
00:03:35,625 --> 00:03:41,725
Thay vào đó bị trì hoãn vì một cái gì đó đứng trước nó trong trình tự tính toán.

53
00:03:41,725 --> 00:03:45,735
Bây giờ, tính toán không đồng bộ, chúng ta có thể sắp xếp lại công việc này

54
00:03:45,735 --> 00:03:50,265
theo cách mà tính toán một, khi nó hoàn thành,

55
00:03:50,265 --> 00:03:57,350
có thể sinh ra những tính toán chạy dài để được thực hiện sau hậu trường một cách độc lập,

56
00:03:57,350 --> 00:04:02,706
và kể từ khi tính toán hai phụ thuộc vào tính toán chạy dài để kết thúc,

57
00:04:02,706 --> 00:04:09,314
sau đó tính toán hai có thể được thực hiện khi tính toán chạy dài kết thúc.

58
00:04:09,314 --> 00:04:14,265
Bây giờ, điều này giải phóng tính toán ba để tiếp tục,

59
00:04:14,265 --> 00:04:16,820
ngay sau khi tính toán một kết thúc.

60
00:04:16,820 --> 00:04:18,585
Vì vậy, cách sắp xếp này,

61
00:04:18,585 --> 00:04:22,815
đảm bảo rằng tính toán ba sẽ kết thúc nhanh hơn nhiều so với

62
00:04:22,815 --> 00:04:28,000
bị mắc kẹt phía sau tính toán chạy dài, và tính toán hai.

63
00:04:28,000 --> 00:04:33,945
Vì vậy, cách tiếp cận này của sắp xếp lại công việc của bạn là rất hữu ích đặc biệt,

64
00:04:33,945 --> 00:04:37,650
khi bạn có một tính toán chạy dài đặc biệt,

65
00:04:37,650 --> 00:04:40,000
I/O ràng buộc tính toán để được thực hiện.

66
00:04:40,000 --> 00:04:43,174
Vì vậy, trong trường hợp này, bạn có thể đẻ ra khỏi I/O ràng buộc tính toán,

67
00:04:43,174 --> 00:04:44,700
và khi hoàn thành,

68
00:04:44,700 --> 00:04:47,580
sau đó bất cứ điều gì cần phải được thực hiện sau đó,

69
00:04:47,580 --> 00:04:51,830
có thể được gửi đến nó như một Callback.

70
00:04:51,830 --> 00:04:54,540
Vì vậy, tính toán hai sẽ được biến thành

71
00:04:54,540 --> 00:04:58,490
một Callback và sau đó đưa ra cho tính toán chạy dài.

72
00:04:58,490 --> 00:05:01,440
Vì vậy, khi điều đó hoàn thành công việc của

73
00:05:01,440 --> 00:05:07,015
nó, sau đó nó sẽ gọi lại các chức năng được bao bọc bên trong callback.

74
00:05:07,015 --> 00:05:11,020
Vì vậy, điều này được tận dụng rất hiệu quả bởi Node.js

75
00:05:11,020 --> 00:05:17,250
trong việc sắp xếp lại các tính toán trong các ứng dụng Node của chúng tôi.

76
00:05:17,250 --> 00:05:20,740
Bây giờ, điều này rất,

77
00:05:20,740 --> 00:05:25,520
rất hữu ích khi chúng ta nhìn vào cách Node.js chạy.

78
00:05:25,520 --> 00:05:26,735
Vì vậy, như chúng tôi nhận ra,

79
00:05:26,735 --> 00:05:31,830
Node.js được tổ chức thành một vòng lặp sự kiện luồng duy nhất.

80
00:05:31,830 --> 00:05:34,690
Vòng lặp sự kiện duy nhất luồng này về cơ bản,

81
00:05:34,690 --> 00:05:39,620
chọn lên yêu cầu khi họ đi vào và thực hiện nó cái khác.

82
00:05:39,620 --> 00:05:42,592
Bất cứ khi nào nó cần phải đẻ ra một yêu cầu I/O,

83
00:05:42,592 --> 00:05:44,650
yêu cầu I/O sẽ được đẻ ra,

84
00:05:44,650 --> 00:05:48,910
và bất kỳ công việc cần phải được thực hiện sau khi yêu cầu I/O được hoàn thành,

85
00:05:48,910 --> 00:05:51,330
sẽ được kèm theo bên trong một Callback.

86
00:05:51,330 --> 00:05:52,940
Vì vậy, khi yêu cầu I/O hoàn tất,

87
00:05:52,940 --> 00:05:55,660
sau đó nó sẽ đặt Callback vào hàng đợi yêu cầu,

88
00:05:55,660 --> 00:05:58,510
và Callback sẽ được xử lý sau đó,

89
00:05:58,510 --> 00:06:00,030
bởi vòng lặp sự kiện.

90
00:06:00,030 --> 00:06:02,890
Vì vậy, vòng lặp sự kiện là một vòng lặp chạy liên tục

91
00:06:02,890 --> 00:06:06,595
mà về cơ bản chọn lên yêu cầu từ hàng đợi yêu cầu,

92
00:06:06,595 --> 00:06:09,240
và sau đó dịch vụ chúng một tại một thời điểm.

93
00:06:09,240 --> 00:06:11,470
Vì vậy, khi bạn nghĩ lại về nó,

94
00:06:11,470 --> 00:06:14,093
bạn nhận ra rằng Node.js là một luồng duy nhất,

95
00:06:14,093 --> 00:06:15,340
nhưng đồng thời,

96
00:06:15,340 --> 00:06:19,645
nó có thể đạt được tốc độ nhanh hơn nhiều của hoàn thành công việc,

97
00:06:19,645 --> 00:06:24,580
chỉ đơn giản là vì việc sử dụng khôn ngoan của callbacks,

98
00:06:24,580 --> 00:06:29,680
và thực hiện không đồng bộ của I/O yêu cầu,

99
00:06:29,680 --> 00:06:32,815
như cho tập tin truy cập hoặc cơ sở dữ liệu,

100
00:06:32,815 --> 00:06:39,280
hoặc xử lý chạy dài có thể được thực hiện độc lập đằng sau hậu trường.

101
00:06:39,280 --> 00:06:43,045
Bây giờ, cách vòng lặp sự kiện Node.js xử lý tất cả điều này,

102
00:06:43,045 --> 00:06:48,410
là vòng lặp sự kiện được sắp xếp trong một chuỗi các giai đoạn.

103
00:06:48,410 --> 00:06:51,710
Vì vậy, như bạn thấy trong sơ đồ hiển thị ở đây,

104
00:06:51,710 --> 00:06:55,060
các giai đoạn bao gồm xử lý hẹn giờ,

105
00:06:55,060 --> 00:06:58,390
I/O gọi lại xử lý, sau đó bạn có nhàn rỗi, chuẩn bị,

106
00:06:58,390 --> 00:07:05,800
sau đó cuộc thăm dò nơi các yêu cầu đến cho các kết nối hoặc dữ liệu được xử lý,

107
00:07:05,800 --> 00:07:07,585
và sau đó giai đoạn kiểm tra,

108
00:07:07,585 --> 00:07:10,290
và sau đó cuối cùng, giai đoạn callbacks đóng.

109
00:07:10,290 --> 00:07:16,351
Bây giờ, một số chi tiết về những gì được thực hiện trong mỗi giai đoạn này được liệt kê ở phía bên phải.

110
00:07:16,351 --> 00:07:17,905
Trong giai đoạn hẹn giờ,

111
00:07:17,905 --> 00:07:21,550
vòng lặp sự kiện xử lý bất cứ điều gì được kích hoạt bởi

112
00:07:21,550 --> 00:07:25,770
hàm setTimeout () trong JavaScript.

113
00:07:25,770 --> 00:07:29,010
I/O callbacks được thực hiện,

114
00:07:29,010 --> 00:07:32,620
hầu như tất cả các callbacks mà trở lại để được

115
00:07:32,620 --> 00:07:36,795
thực hiện sau khi một yêu cầu I/O sẽ được xử lý bởi hàng đợi I/O callbacks.

116
00:07:36,795 --> 00:07:41,065
Vì vậy, mỗi giai đoạn duy trì riêng của mình hàng đợi riêng biệt,

117
00:07:41,065 --> 00:07:46,053
và vòng lặp sự kiện Node.js chọn lên yêu cầu từ mỗi hàng đợi, và xử lý chúng.

118
00:07:46,053 --> 00:07:52,150
Các, nhàn rỗi, chuẩn bị, có nghĩa là để sử dụng nội bộ bởi Node.js.

119
00:07:52,150 --> 00:07:57,910
Cuộc thăm dò là nơi nó lấy các sự kiện I/O mới được xử lý và có lẽ,

120
00:07:57,910 --> 00:08:00,313
các yêu cầu đến từ bên ngoài.

121
00:08:00,313 --> 00:08:08,354
Giai đoạn gọi lại đóng xử lý bất kỳ đóng cửa ổ cắm nào cần được xử lý, v.v.

122
00:08:08,354 --> 00:08:11,050
Bây giờ, chúng ta không cần phải lo lắng quá nhiều về

123
00:08:11,050 --> 00:08:15,430
tất cả các chi tiết này nếu chúng ta cần phải thực sự viết một ứng dụng Node.js.

124
00:08:15,430 --> 00:08:19,720
Khi được yêu cầu, chúng tôi sẽ xem xét một số chi tiết này như và khi nào

125
00:08:19,720 --> 00:08:25,030
nó là cần thiết để hiểu cách ứng dụng Node của chúng tôi hoạt động.

126
00:08:25,030 --> 00:08:27,985
Nhưng cho thời điểm này, điều này cung cấp cho bạn một hình ảnh lớn

127
00:08:27,985 --> 00:08:31,990
như thế nào các vòng lặp sự kiện Node.js được xử lý.

128
00:08:31,990 --> 00:08:35,830
Đủ để nói rằng đây là đủ thông tin để chúng ta

129
00:08:35,830 --> 00:08:40,590
hiểu được các ứng dụng Node và cách chúng hoạt động cho thời điểm này.

130
00:08:40,590 --> 00:08:42,895
Nếu bạn muốn biết thêm chi tiết,

131
00:08:42,895 --> 00:08:46,810
sau đó tôi đã cung cấp cho bạn một liên kết đến một mô tả chi tiết trong

132
00:08:46,810 --> 00:08:53,930
tài liệu Node.js mà giải thích về vòng lặp sự kiện chi tiết hơn.

133
00:08:53,930 --> 00:08:58,615
Với sự hiểu biết nhanh chóng về Node,

134
00:08:58,615 --> 00:09:01,445
Callbacks, và xử lý lỗi,

135
00:09:01,445 --> 00:09:03,296
chúng ta sẽ chuyển sang bài tập,

136
00:09:03,296 --> 00:09:09,280
nơi chúng ta sẽ xem xét cách một ứng dụng Node có thể viết bằng Callbacks,

137
00:09:09,280 --> 00:09:14,110
và cách xử lý lỗi bên trong ứng dụng Node.

138
00:09:14,110 --> 00:09:18,840
Chúng ta sẽ thấy việc sử dụng lặp đi lặp lại mô hình này trong các bài tập

139
00:09:18,840 --> 00:09:21,421
tiếp theo, và các bài học tiếp theo cụ thể,

140
00:09:21,421 --> 00:09:22,960
khi chúng ta nhìn vào Express,

141
00:09:22,960 --> 00:09:26,860
và cách chúng ta xây dựng các ứng dụng phía máy chủ sử dụng Express

142
00:09:26,860 --> 00:09:32,720
chi tiết hơn trong phần sau của khóa học này.