1
00:00:00,000 --> 00:00:08,350

2
00:00:08,350 --> 00:00:09,710
>> קווין שמידט: שלום לכולם.

3
00:00:09,710 --> 00:00:12,640
ברוכים הבאים לסמינר CS50
על Node.js.

4
00:00:12,640 --> 00:00:13,955
השם שלי הוא קווין.

5
00:00:13,955 --> 00:00:15,580
אני TF CS50.

6
00:00:15,580 --> 00:00:17,650
ואני כמו סוג של ממש נרגש
על הסמינר הזה.

7
00:00:17,650 --> 00:00:20,430
אני חושב Node.js הוא מאוד מגניב.

8
00:00:20,430 --> 00:00:24,200
אני מקווה שהסמינר הזה יכול לשמש
כמו, אני מניח, קרש קפיצה טובה ל

9
00:00:24,200 --> 00:00:26,380
חלק מפרויקטי הגמר שלך אם
אתה מעוניין בשימוש

10
00:00:26,380 --> 00:00:27,630
משהו כמו Node.js.

11
00:00:27,630 --> 00:00:29,770

12
00:00:29,770 --> 00:00:33,320
>> אנחנו סוג של נתחיל את הסמינר על ידי
מדבר רק על קצת

13
00:00:33,320 --> 00:00:36,970
סוג של יכולת הרחבה רקע
פרספקטיבות של Node.js, ולאחר מכן

14
00:00:36,970 --> 00:00:39,240
נעבור לכמה דוגמאות קוד.

15
00:00:39,240 --> 00:00:42,340
ויהיה לי את הקוד באתר אינטרנט,
ואתה יכול להסתכל על הקוד.

16
00:00:42,340 --> 00:00:45,475
ואחרי הסמינר, אני אטפל דיבורים
על איך אתה יכול להגדיר Node.js

17
00:00:45,475 --> 00:00:48,220
במחשב שלך.

18
00:00:48,220 --> 00:00:48,710
>> על אישור.

19
00:00:48,710 --> 00:00:49,760
אז בואו נתחיל.

20
00:00:49,760 --> 00:00:53,700
אז אני מניח שאני רק רוצה לדבר על
שרתי אינטרנט, באמת, ראשון.

21
00:00:53,700 --> 00:00:59,730
וכדי להתחיל את הדיון הזה, אני
בעצם יש תרשים שהוא מ

22
00:00:59,730 --> 00:01:04,269
ספר הלימוד המשמש לCS61, אשר
בעצם מציגה את האינטראקציה

23
00:01:04,269 --> 00:01:08,510
בין תהליך לקוח, כמו האינטרנט שלך
דפדפן או כמו הלקוח או המטרה שלך

24
00:01:08,510 --> 00:01:11,340
משהו כזה, ושרת אינטרנט.

25
00:01:11,340 --> 00:01:15,150
אז זה סוג של נראה דומה
תמונה שראית בהרצאה על

26
00:01:15,150 --> 00:01:19,270
יום רביעי שבו בעצם יש לנו כמה
תהליך כמו Google Chrome לקוח.

27
00:01:19,270 --> 00:01:22,980
>> ולאחר מכן צעד אחד הוא
לקוח שולח בקשה.

28
00:01:22,980 --> 00:01:27,510
אז זה יכול להיות משהו כמו גם בואו
לבקר, אני לא יודע, CS50.net.

29
00:01:27,510 --> 00:01:29,320
אז אנו מנפיקים את הבקשה.

30
00:01:29,320 --> 00:01:34,280
והאם מישהו זוכר את שמו של
הפרוטוקול המפרט איך זה

31
00:01:34,280 --> 00:01:35,610
בקשה צריכה להיות בנויה?

32
00:01:35,610 --> 00:01:36,382
כן.

33
00:01:36,382 --> 00:01:37,650
>> קהל: [לא ברור].

34
00:01:37,650 --> 00:01:38,150
>> קווין שמידט: בדיוק.

35
00:01:38,150 --> 00:01:40,100
אז זה כמו HTTP, נכון?

36
00:01:40,100 --> 00:01:44,720
אז בעצם מפרט כיצד
בקשה שבעצם צריכה להיות מונחת

37
00:01:44,720 --> 00:01:47,450
החוצה, כי בסופו של היום,
בקשה שבאמת רק הוא אוהבת

38
00:01:47,450 --> 00:01:50,240
מחרוזת שבעצם
אומר שאני רוצה את זה.

39
00:01:50,240 --> 00:01:53,580
והמפרט
בשביל זה הוא הפרוטוקול HTTP.

40
00:01:53,580 --> 00:01:55,270
אז זה כמו פרוטוקול.

41
00:01:55,270 --> 00:01:57,920
>> אז השרת מקבל
בקשה ש.

42
00:01:57,920 --> 00:02:01,610
אז החבר 'ה יש לי מותקן בשרת אינטרנט
במכשיר CS50.

43
00:02:01,610 --> 00:02:02,460
זה אפצ'י.

44
00:02:02,460 --> 00:02:06,230
וזה שבוע שבו אתה עובד על בעיה
להגדיר שבע, אתה בעצם עובד

45
00:02:06,230 --> 00:02:08,160
עם זה שרת האינטרנט.

46
00:02:08,160 --> 00:02:12,380
אז השרת מקבל את הבקשה, ו
אז זה חייב לגרד את סוג שלה

47
00:02:12,380 --> 00:02:15,090
ראש ואומר כמו גם מה
אני עושה עם זה?

48
00:02:15,090 --> 00:02:20,060
>> אז על סמך מה יחליט לעשות, ולאחר מכן
זה ייתכן כי יצטרך לפנות איזה

49
00:02:20,060 --> 00:02:20,730
של משאבים.

50
00:02:20,730 --> 00:02:23,700
ומשאבים שיכולים להיות
הרבה דברים שונים.

51
00:02:23,700 --> 00:02:26,810
עבור אחד, זה יכול להיות רק
כמו קובץ HTML סטטי.

52
00:02:26,810 --> 00:02:29,820
אז זה יכול להיות רק כמו
HTML שהוא כמו ל

53
00:02:29,820 --> 00:02:31,100
האתר האישי שלך.

54
00:02:31,100 --> 00:02:35,360
זה יכול להיות קובץ סטטי כמו תמונה
או כמו בסרט שיש לך.

55
00:02:35,360 --> 00:02:37,660
זה אפילו יכול להיות לדבר
לסוג מסוים של מסד נתונים

56
00:02:37,660 --> 00:02:39,530
כמו מסד נתונים MySQL.

57
00:02:39,530 --> 00:02:43,910
אז זה לא תמיד צריך לתקשר
עם משאבים, אבל ב

58
00:02:43,910 --> 00:02:45,700
מקרים מסוימים, זה יכול.

59
00:02:45,700 --> 00:02:47,800
>> אז מה זה הולך לעשות
אחרי זה הוא שזה הולך

60
00:02:47,800 --> 00:02:49,430
לשלוח בחזרה את התגובה.

61
00:02:49,430 --> 00:02:53,130
והתשובה לכך היא
גם צוין על ידי HTTP.

62
00:02:53,130 --> 00:02:54,830
אז הלקוח יכול לקבל אותו.

63
00:02:54,830 --> 00:02:56,740
זה יכול לקרוע אותו לגזרים ולעבד אותו.

64
00:02:56,740 --> 00:03:00,900
ואז אתה מקבל דף אינטרנט
כמו גוגל או CS50.net או

65
00:03:00,900 --> 00:03:02,240
כל מה שאתה הלך.

66
00:03:02,240 --> 00:03:03,100
בסדר?

67
00:03:03,100 --> 00:03:06,080
>> אז זו האינטראקציה הבסיסית ש
אנחנו הולכים להיות התמודדות עם.

68
00:03:06,080 --> 00:03:08,770
ואנחנו הולכים להיות פחות או יותר
התמקדות בחלק זה של

69
00:03:08,770 --> 00:03:10,640
אינטראקציה, השרת.

70
00:03:10,640 --> 00:03:10,990
על אישור.

71
00:03:10,990 --> 00:03:12,210
מגניב.

72
00:03:12,210 --> 00:03:15,500
למישהו יש שאלות עד כה?

73
00:03:15,500 --> 00:03:17,720
על אישור.

74
00:03:17,720 --> 00:03:22,430
>> אז כמו שאמרנו, שרת האינטרנט מקבל
בקשת HTTP זה ולאחר מכן מוציאה את זה

75
00:03:22,430 --> 00:03:24,760
תגובת HTTP.

76
00:03:24,760 --> 00:03:29,100
וכמו שדיברנו בעבר,
שרת אינטרנט של מכשיר CS50 הוא אפצ'י.

77
00:03:29,100 --> 00:03:32,490
לכן, כאשר אתם עובדים על P להגדיר שבע,
אתה הולך לעבוד עם

78
00:03:32,490 --> 00:03:34,120
שרת האינטרנט Apache.

79
00:03:34,120 --> 00:03:37,890
אתה לעולם לא צריך באמת לעבוד
עם אפצ'י ישירות יותר מדי.

80
00:03:37,890 --> 00:03:41,920
אתה סוג של להגדיר אפצ'י קטן
כשאתה מציין את המארחים או וירטואליים

81
00:03:41,920 --> 00:03:44,970
המארחים v, ונקבל
לזה בקצת.

82
00:03:44,970 --> 00:03:50,620
>> אבל בעיקרון, שרת האינטרנט Apache
להגדיר לעבוד עם סוג PHP

83
00:03:50,620 --> 00:03:51,730
של מחוץ לקופסה.

84
00:03:51,730 --> 00:03:56,170
אז מה באמת קורה הוא כשאתה הולך
לאחד מאתרי האינטרנט שלך כמו, למשל,

85
00:03:56,170 --> 00:04:00,360
index.php המקומי מארח קו נטוי או משהו כזה,
הוא הדפדפן שלך שולח כי

86
00:04:00,360 --> 00:04:04,330
בקשה, ולאחר מכן האפצ'י יושב
יש ודמויות לעשות עם זה.

87
00:04:04,330 --> 00:04:08,840
והפעולה היא לבצע
קוד שבindex.php ו

88
00:04:08,840 --> 00:04:11,330
לאחר מכן לשלוח אותו בחזרה.

89
00:04:11,330 --> 00:04:15,640
אז יש את זה.

90
00:04:15,640 --> 00:04:16,980
אז אנחנו סוג של דיברו על זה.

91
00:04:16,980 --> 00:04:21,990
אז זה רק יכול לשרת קובץ סטטי
או להריץ כמה קוד PHP ולאחר מכן נושא

92
00:04:21,990 --> 00:04:23,510
התגובה.

93
00:04:23,510 --> 00:04:27,670
>> אז שאלה נפוצה שיכול לבוא
למעלה הוא גם, איך אנחנו באמת להתמודד

94
00:04:27,670 --> 00:04:31,750
עם בעל מספר משתמשים
באותו הזמן?

95
00:04:31,750 --> 00:04:36,930
אז דמיין אם היית כותב אינטרנט
שרת, אם היה לך שרת אינטרנט ש

96
00:04:36,930 --> 00:04:39,900
אתה מנסה לכתוב במשהו
כמו C או משהו כזה,

97
00:04:39,900 --> 00:04:45,150
בעצם אתה יכול לחשוב על איך יש
יכול להיות איזשהו קוד ש

98
00:04:45,150 --> 00:04:49,330
אקבל את הבקשה, אבל אז
יש לו לעשות את כל העבודה הזו עליו.

99
00:04:49,330 --> 00:04:53,060
זה יכול להיות, למשל, פנה
מסד נתונים או משהו כזה.

100
00:04:53,060 --> 00:04:53,300
נכון?

101
00:04:53,300 --> 00:04:56,010
ואז זה יהיה לעשות את זה סוג
של עיבוד ולאחר מכן

102
00:04:56,010 --> 00:04:57,060
נשלח בחזרה התגובה.

103
00:04:57,060 --> 00:04:58,950
אז זה כמו גבוה
סקירה ברמה.

104
00:04:58,950 --> 00:05:04,210
>> אבל זה לא ברור מייד איך אתה
יכול לעשות את זה, כך ששני אנשים או

105
00:05:04,210 --> 00:05:09,040
אפילו 1,000 בני אדם יכולים לעבוד איתך
שרת אינטרנט באותו הזמן.

106
00:05:09,040 --> 00:05:14,880
אז הפתרון שהאפצ'י משתמש
נקרא אשכולות או תהליכים.

107
00:05:14,880 --> 00:05:16,770
אז אתה אולי שמעת על
תנאים אלה בעבר.

108
00:05:16,770 --> 00:05:22,190
זה בסדר אם יש לך שלא, אבל פשוט חושב
על חוטים או תהליכים כדרכים ל

109
00:05:22,190 --> 00:05:26,290
מערכת הפעלה או תכנית משתמש או
משהו כזה או שרת אינטרנט

110
00:05:26,290 --> 00:05:28,810
לביצוע מספר רב של סוג של
דברים בבת אחת.

111
00:05:28,810 --> 00:05:31,760
אז אתה אולי שמעת את המונח
כמו חוטים של הוצאה להורג.

112
00:05:31,760 --> 00:05:34,140
אז זה כמו סוג של אתה
סוג של ריבוי משימות.

113
00:05:34,140 --> 00:05:37,710
>> ואם ראו בתיבה שלך
מחשב נייד, או משהו כזה,

114
00:05:37,710 --> 00:05:43,040
ריבוי הליבות, מה שאתה יכול לעשות הוא שאתה יכול
להפעיל שני אשכולות שונים על שונה

115
00:05:43,040 --> 00:05:46,700
חלקים של המעבד, כך שהם יכולים
בעצם יקרה באותו הזמן.

116
00:05:46,700 --> 00:05:48,100
אז זה ממש חזק.

117
00:05:48,100 --> 00:05:52,270
וזה סוג של האפצ'י
פתרון לבעיה זו.

118
00:05:52,270 --> 00:05:57,900
>> אז יש סוג של כמו כל נושאים
עם גישה זו אף?

119
00:05:57,900 --> 00:05:59,870
אז אני מניח שאני סוג של כתבתי אותם שם.

120
00:05:59,870 --> 00:06:03,440
אבל שניהם סוג של
משתמש הרבה זיכרון.

121
00:06:03,440 --> 00:06:07,490
זה יקר מאוד כדי ליצור
חוט או תהליך.

122
00:06:07,490 --> 00:06:11,750
>> וחלק מהסיבה הוא שפשוט
כמו כשאתה מפעיל תכנית C

123
00:06:11,750 --> 00:06:15,090
כמו העיקרי שלך ולאחר מכן ששיחות
פונקציה אחרת, שיש לו

124
00:06:15,090 --> 00:06:16,520
סוג כלשהו של ערימה.

125
00:06:16,520 --> 00:06:19,910
אז אשכולות גם דורשים לגמרי
ערימה נפרדת אשר

126
00:06:19,910 --> 00:06:21,220
יכול להיות די גדול.

127
00:06:21,220 --> 00:06:25,170
ואם אתה יכול לדמיין שיש טונות של
משתמשים באתר שלך, האם יש לך

128
00:06:25,170 --> 00:06:26,280
הרבה נושאים שונים.

129
00:06:26,280 --> 00:06:28,230
זה הרבה ערימות כדי
לנהל ולתחזק.

130
00:06:28,230 --> 00:06:31,280
אז זה צריכת זיכרון גדולה.

131
00:06:31,280 --> 00:06:35,650
>> ואז, גם, נניח שיש לך רק
מעבד אחד, או נניח שיש לך

132
00:06:35,650 --> 00:06:38,460
יותר ממה שיש לך אשכולות
אלה multicores.

133
00:06:38,460 --> 00:06:38,730
נכון?

134
00:06:38,730 --> 00:06:43,280
אז בואו נגיד שהיה לך 10 אשכולות
והיה לך רק חמישה מעבדים.

135
00:06:43,280 --> 00:06:46,260
אתה סוג של לעשות את הדבר הזה שבו
אתה עובר בין הזרם

136
00:06:46,260 --> 00:06:49,090
אחד שפועל בגלל שאתה
לא יכול להפעיל את כל 10 בבת אחת.

137
00:06:49,090 --> 00:06:50,980
וזה נקרא מתג הקשר.

138
00:06:50,980 --> 00:06:54,260
ויש לו טווח שבעצם כמה
הקשרים שונים, אבל בואו רק

139
00:06:54,260 --> 00:06:56,620
לחשוב על זה כמיתוג
בין שני נושאים.

140
00:06:56,620 --> 00:06:59,730
זה יכול להיות די יקר בגלל
בעצם מה שאתה צריך לעשות זה אתה

141
00:06:59,730 --> 00:07:03,340
צריך להפסיק את מה שאתה עושה, לשמור את
מצב שחוט הריצה, ו

142
00:07:03,340 --> 00:07:05,440
לאחר מכן לעבור למקום אחר.

143
00:07:05,440 --> 00:07:09,420
>> אז האם כל סוג של לראות את
מוטיבציה של מה אשכולות ו

144
00:07:09,420 --> 00:07:12,030
תהליכים יכולים להיות קצת מגושמים?

145
00:07:12,030 --> 00:07:13,840
והאם יש לך שאלה?

146
00:07:13,840 --> 00:07:14,376
על אישור.

147
00:07:14,376 --> 00:07:15,070
מגניב.

148
00:07:15,070 --> 00:07:18,090
למישהו יש שאלות?

149
00:07:18,090 --> 00:07:19,620
על אישור.

150
00:07:19,620 --> 00:07:26,720
>> אז אם אנחנו לוקחים צעד אחורה לרגע,
יש כמו סוג של

151
00:07:26,720 --> 00:07:30,350
תצפית שאנו יכולים לעשות על
הרבה של יישומי אינטרנט.

152
00:07:30,350 --> 00:07:34,810
וזה באמת כל כך הרבה מהם
למעשה לא עושה את זה הרבה יותר שימושי

153
00:07:34,810 --> 00:07:37,140
עבודה פנימית של חוט.

154
00:07:37,140 --> 00:07:41,170
אז יש מישהו שנפתחו על
P להגדיר שבע בכלל?

155
00:07:41,170 --> 00:07:45,650
אז אתה רוצה אולי לתאר
כמה החלקים?

156
00:07:45,650 --> 00:07:47,850
האם עבד בעת כניסה
או משהו כזה?

157
00:07:47,850 --> 00:07:49,330
>> קהל: לא.

158
00:07:49,330 --> 00:07:49,780
>> קווין שמידט: אישור.

159
00:07:49,780 --> 00:07:50,150
אין דבר.

160
00:07:50,150 --> 00:07:50,900
סליחה.

161
00:07:50,900 --> 00:07:55,790
אבל בעיקרון, בערכת P, אתה
הולך להיות עושה הרבה סוג של

162
00:07:55,790 --> 00:07:59,760
שאילתות למסד נתונים כדי לקבל קצת
מידע ממסד נתונים זה.

163
00:07:59,760 --> 00:08:03,330
ומה הקוד שלך הולך לעשות,
מה זה תהליך האפצ'י או

164
00:08:03,330 --> 00:08:06,030
שחוט האפצ'י הוא הולך לעשות
בזמן זה יש ליצור קשר עם

165
00:08:06,030 --> 00:08:08,990
מסד הנתונים הוא שזה סוג של הולך להיות
יושב שם וזה הולך להיות

166
00:08:08,990 --> 00:08:12,130
מחכה למסד הנתונים כדי לענות.

167
00:08:12,130 --> 00:08:16,290
>> עכשיו שאולי לא נשמע כמו שגדול
להתמודד משום שמסד הנתונים הוא עליך

168
00:08:16,290 --> 00:08:18,240
מכשיר CS50, נכון?

169
00:08:18,240 --> 00:08:22,930
אבל יש סוג כלשהו של רשת
חביון שם כי החברה האינטרנט

170
00:08:22,930 --> 00:08:26,830
שרת יש להוציא בקשה משלו כדי
מסד הנתונים כדי לתקשר עם

171
00:08:26,830 --> 00:08:29,520
מסד הנתונים ולאחר מכן לקבל את זה
מידע בחזרה.

172
00:08:29,520 --> 00:08:33,190
אז עכשיו זה כמו גם חכה לי, אני
הולך לקבל משהו מ

173
00:08:33,190 --> 00:08:35,770
מסד הנתונים ולאחר מכן יש
הרבה מחכה קורה.

174
00:08:35,770 --> 00:08:36,870
האם זה הגיוני?

175
00:08:36,870 --> 00:08:38,580
>> ולכמה דברים שזה לא כל כך רע.

176
00:08:38,580 --> 00:08:41,950
אם זה פשוט חייב, למשל,
זיכרון גישה, שלא כמו

177
00:08:41,950 --> 00:08:44,100
חביון I / O הנורא.

178
00:08:44,100 --> 00:08:47,110
וכאשר אני אומר, אני / מיסות O, מה אני
מתייחס לזה כמו כל סוג של כמו

179
00:08:47,110 --> 00:08:48,290
קלט פלט.

180
00:08:48,290 --> 00:08:52,950
אבל כדי לגשת לקבצים בדיסק, כמו
אם אני רוצה לשרת את HTML סטטי

181
00:08:52,950 --> 00:08:57,850
קובץ שהיה באתר שלי או
משהו כזה, אני די צריך

182
00:08:57,850 --> 00:09:02,310
לעצור לרגע, לקרוא קובץ ש
מהדיסק, ולאחר מכן ב

183
00:09:02,310 --> 00:09:04,400
תהליך שאני מחכה.

184
00:09:04,400 --> 00:09:06,700
אני לא עושה את העבודה מועילה.

185
00:09:06,700 --> 00:09:11,270
>> זה לא נכון מכל דבר, אבל זה
הוא נפוץ ביישומים כמו סט P

186
00:09:11,270 --> 00:09:13,960
שבע והרבה יישומים
שאתה לא

187
00:09:13,960 --> 00:09:15,440
בעצם עושה הרבה חשיבה.

188
00:09:15,440 --> 00:09:19,090
וכשאני אומר חשיבה, אני מתכוון
כמו עבודה חישובית.

189
00:09:19,090 --> 00:09:23,270
עבודה אז חישובית יכולה להיות משהו
כמו, נניח, שאתה רוצה

190
00:09:23,270 --> 00:09:26,590
לכתוב שרת אינטרנט שפשוט מחושב
מספר פיבונאצ'י המי יודע כמה.

191
00:09:26,590 --> 00:09:29,300
זה לא נשמע כמו במיוחד
שרת אינטרנט של כיף.

192
00:09:29,300 --> 00:09:34,220
כמו שלא הייתי מצפה שאתר יהיה
פייסבוק הבא, אבל זה חלק

193
00:09:34,220 --> 00:09:35,610
סוג של עבודה חישובית.

194
00:09:35,610 --> 00:09:39,570
>> ואתה יכול לדמיין את זה עם החלפה
איזה מעניין אחרים

195
00:09:39,570 --> 00:09:43,070
עבודה חישובית.

196
00:09:43,070 --> 00:09:46,050
בואו נגיד שאתה כותב משהו
שחשב את דרגות

197
00:09:46,050 --> 00:09:49,170
הפרדה בין שני אנשים
או משהו כזה.

198
00:09:49,170 --> 00:09:51,860
כך שאינו כרוך סוג כלשהו
חישוב, נכון?

199
00:09:51,860 --> 00:09:56,630
וגם אז, לעשות כדי שעדיין יש לך
לעשות הרבה ההמתנה לאולי

200
00:09:56,630 --> 00:09:59,550
אתה צריך שאילתת מסד נתונים להסתכל
עד שזה חברים עם מי או

201
00:09:59,550 --> 00:10:00,600
משהו כזה.

202
00:10:00,600 --> 00:10:03,510
אז יש סוג כזה של רעיון
עבודה של חישובית.

203
00:10:03,510 --> 00:10:05,260
האם זה הגיוני?

204
00:10:05,260 --> 00:10:08,258
האם יש למישהו שאלות?

205
00:10:08,258 --> 00:10:11,960
>> אה, ואני מניח ששמתי את שרתי צ'אט יש
בגלל שרתי צ'אט הם סוג של

206
00:10:11,960 --> 00:10:13,240
עוד דוגמא טובה לכך.

207
00:10:13,240 --> 00:10:15,250
שרת צ'אט אין
לעשות הרבה חשיבה.

208
00:10:15,250 --> 00:10:18,350
זה פשוט צריך לחכות לאנשים
לשלוח הודעות ולאחר מכן כאשר

209
00:10:18,350 --> 00:10:19,800
הם, לשלוח אותם.

210
00:10:19,800 --> 00:10:21,050
בסדר?

211
00:10:21,050 --> 00:10:23,410

212
00:10:23,410 --> 00:10:28,180
>> אז רק כדי לסכם שוב, Apache ו
שרתי אינטרנט דומים כמו שמזלג

213
00:10:28,180 --> 00:10:31,470
הרבה נושאים ותהליכים אשר
יכול להיות סוג של הבזבוז.

214
00:10:31,470 --> 00:10:37,530
אז אני מניח שהשאלה שעלולה לבוא
שמאנחנו צריכים

215
00:10:37,530 --> 00:10:39,610
נושאים מרובים ותהליכים?

216
00:10:39,610 --> 00:10:41,890
מה אם רק היו לנו אחד?

217
00:10:41,890 --> 00:10:45,710
>> אז בואו סוג של לצייר תמונה
ממה שזה ייראה.

218
00:10:45,710 --> 00:10:47,810
אז בואו להשתמש רק באחד חוטים.

219
00:10:47,810 --> 00:10:48,660
בסדר?

220
00:10:48,660 --> 00:10:52,790
אז רק לדמיין את זה עם חוט אחד.

221
00:10:52,790 --> 00:10:56,600
>> בואו נניח שאנו לא ממש עושים
כל כך הרבה שימושי - וכשאני אומר

222
00:10:56,600 --> 00:10:59,450
שימושי, אני מתכוון לעבודה חישובית -

223
00:10:59,450 --> 00:11:01,130
בנושאים מרובים אלו בעבר.

224
00:11:01,130 --> 00:11:04,180
אז בואו סוג של לאחד
הכל לחוט אחד.

225
00:11:04,180 --> 00:11:07,780
אז מה אם היו לנו חוט אחד מסוג זה
רק מסתובב בלולאה ו

226
00:11:07,780 --> 00:11:10,880
כל הזמן בדיקות עשו משהו
חדשים לקרות.

227
00:11:10,880 --> 00:11:15,130
כך למשל, קרה משהו חדש
יכול להיות יש לי משהו בחזרה מ

228
00:11:15,130 --> 00:11:19,310
בסיס הנתונים, או שמישהו שלח
שלי בקשת HTTP חדשה.

229
00:11:19,310 --> 00:11:22,290
אז אלה הם סוג של אירועים
לזה לקרות, נכון?

230
00:11:22,290 --> 00:11:26,130
>> ואז מה אני יכול לעשות בעת חדשה אלה
לדברים לקרות הוא באותו אשכול זה

231
00:11:26,130 --> 00:11:30,120
ביצוע, חוט אחד של
הוצאה לפועל, אני יכול לקרוא קצת קוד ש

232
00:11:30,120 --> 00:11:32,410
יטפל דבר מסוים הזה.

233
00:11:32,410 --> 00:11:36,640
כך למשל, אם יש לי משהו בחזרה
ממסד הנתונים, אני יכול לרוץ שלי

234
00:11:36,640 --> 00:11:40,960
חלק חישובית קטן ממנו כי
למעשה רק מכין את הדבר

235
00:11:40,960 --> 00:11:42,620
לשלוח בחזרה למשתמש.

236
00:11:42,620 --> 00:11:46,710
אז עושה את זה סוג של הגיוני?

237
00:11:46,710 --> 00:11:49,940
>> אבל מה הם באמת
השלכות של זה?

238
00:11:49,940 --> 00:11:50,660
נכון?

239
00:11:50,660 --> 00:11:53,730
מכיוון שאנחנו כתבתי
הרבה קוד ש--

240
00:11:53,730 --> 00:11:58,330
ואני רק הולך לקפוץ קדימה
בשקופיות, אם זה בסדר.

241
00:11:58,330 --> 00:12:00,930
אז אם לא אכפת לך, אני רק
הולך לקחת צעד אחורה.

242
00:12:00,930 --> 00:12:03,410
אז זה סוג של דבר הוא
בשם לולאת אירוע.

243
00:12:03,410 --> 00:12:04,070
בסדר?

244
00:12:04,070 --> 00:12:07,240
וזה סוג של היסוד
רעיון מאחורי Node.js.

245
00:12:07,240 --> 00:12:11,240
>> אז מה Node.js הוא באמת עושה כאינטרנט
השרת הוא שיש חוט אחד

246
00:12:11,240 --> 00:12:14,850
כי הוא בעצם מסתובב בלולאה
כמו סוג ואילו אחד מתחת

247
00:12:14,850 --> 00:12:18,510
מכסה המנוע של Node.js זה כל הזמן
בדיקה, האם אנו מקבלים דברים חדשים?

248
00:12:18,510 --> 00:12:22,720
ואז הוא יתמודד מפעילים
שאתה מגדיר.

249
00:12:22,720 --> 00:12:26,720
אבל שאלה טובה לשאול היא,
איך אנחנו יכולים לגרום לזה לקרות

250
00:12:26,720 --> 00:12:28,090
עם דברים קיימים?

251
00:12:28,090 --> 00:12:32,440
>> אז שמתי את שורת קוד C כאן כי
בעצם נראה כאילו זה פתיחה

252
00:12:32,440 --> 00:12:33,060
להגיש, נכון?

253
00:12:33,060 --> 00:12:36,090
אני היא יצאתי רק עם אלבום.

254
00:12:36,090 --> 00:12:39,600
אז הייתי צריך לפתוח אותה בקובץ חדש.

255
00:12:39,600 --> 00:12:43,810
לכן דרך קוד C שלנו להפעלה -

256
00:12:43,810 --> 00:12:47,890
ואני מניח שהסיבה שבחרתי קבצים הייתה
בגלל זה הוא סוג של המידה

257
00:12:47,890 --> 00:12:52,000
עבודת I / O שעשינו ב-C ב
מובן שיש פלט קלט.

258
00:12:52,000 --> 00:12:55,070
אז אנחנו קוראים את הקוד הזה כי
עושה F זה פתוח.

259
00:12:55,070 --> 00:12:59,370
ולאחר מכן בשורה הבאה שלנו
תכנית, עכשיו אנחנו יכולים לעבוד עם f.

260
00:12:59,370 --> 00:13:02,710
>> אז זו תהיה דוגמא למשהו
זה כמו סינכרוני או

261
00:13:02,710 --> 00:13:06,850
חסימה משום שבשורה ראשונה
שם אנחנו מחכים עד ש

262
00:13:06,850 --> 00:13:08,110
לקבל את הקובץ פתוח.

263
00:13:08,110 --> 00:13:12,260
אז בשורה השנייה, אנחנו יודעים שאנחנו
יכול לעבוד עם F, אבל זה אומר ש

264
00:13:12,260 --> 00:13:16,240
שהשורה שנייה לא באמת יכולה לרוץ
עד השורה הראשונה נעשה.

265
00:13:16,240 --> 00:13:17,760
האם זה הגיוני?

266
00:13:17,760 --> 00:13:20,890
>> אז זה יהיה רע לשים
במטפל באירועים.

267
00:13:20,890 --> 00:13:23,920
והסיבה לכך היא כי
סוג זה של מחכה, נכון?

268
00:13:23,920 --> 00:13:26,500
אז זה יחזור אלינו בחזרה
לאותו הדבר.

269
00:13:26,500 --> 00:13:29,470
ועכשיו אנחנו אפילו לא צריכים
יתרון של אשכולות מרובים או

270
00:13:29,470 --> 00:13:32,390
תהליכים בגלל שיש לנו
חוט אחד בNode.js.

271
00:13:32,390 --> 00:13:35,496
האם זה הגיוני לכולם?

272
00:13:35,496 --> 00:13:35,990
>> קהל: חכה.

273
00:13:35,990 --> 00:13:36,980
אז מה התחליף?

274
00:13:36,980 --> 00:13:37,840
>> קווין שמידט: אה, אז כן.

275
00:13:37,840 --> 00:13:39,560
אז אני הולך להגיע ל
ההחלפה.

276
00:13:39,560 --> 00:13:40,430
על אישור.

277
00:13:40,430 --> 00:13:42,960
אז מה אם היו לנו משהו
שנראה כמו זה?

278
00:13:42,960 --> 00:13:45,730
אז מה אם עכשיו אני בעריכה
ו לפתוח קצת?

279
00:13:45,730 --> 00:13:48,370
אז אני עובר באותו
שני טיעונים כמו קודם.

280
00:13:48,370 --> 00:13:52,610
אני עדיין אוהב את השיר החדש
שהיא יצאה איתו.

281
00:13:52,610 --> 00:13:57,260
אבל אני עובר דבר שלישי ש
נקרא משתנה זה קוד.

282
00:13:57,260 --> 00:14:02,280
>> אבל מה הוא בעצם קוד
בהקשר הזה?

283
00:14:02,280 --> 00:14:05,360
האם זה כמו משתנה C רגילה?

284
00:14:05,360 --> 00:14:06,740
זה פונקציה, נכון?

285
00:14:06,740 --> 00:14:09,450
וזה עשוי להיות קצת מוזר כי
אני בעצם כמו עכשיו עובר

286
00:14:09,450 --> 00:14:12,320
פונקציה לפונקציה אחרת.

287
00:14:12,320 --> 00:14:14,400
>> אז כמה דברים שחשוב לציין בעניין זה.

288
00:14:14,400 --> 00:14:17,145
אחד, אני לא ממש קורא
פונקצית הקוד.

289
00:14:17,145 --> 00:14:20,650
אז אתה לא רואה את קוד עם
paren שמאל, סוגריים הנכונים.

290
00:14:20,650 --> 00:14:23,010
אני רק עובר בקוד.

291
00:14:23,010 --> 00:14:26,990
ובC, מה זה בעצם לעשות
הוא נותן לי מצביע שלבפועל

292
00:14:26,990 --> 00:14:29,740
קוד, ואז זה יכול להפעיל אותו.

293
00:14:29,740 --> 00:14:33,350
אבל רק לחשוב על זה כמו שאתה נמצא
עובר את הקוד לפעול בעת

294
00:14:33,350 --> 00:14:35,150
הקובץ שנפתח.

295
00:14:35,150 --> 00:14:41,430
>> אבל מה שזה אומר זה שעכשיו
שאר התכנית שלי שיכול לעשות

296
00:14:41,430 --> 00:14:47,050
דברים אחרים, יכולים להמשיך לעשות אחרים
דברים בזמן שאנחנו, לא ממש לחכות, אבל

297
00:14:47,050 --> 00:14:50,890
פשוט יש בחלק האחורי של הראש שלנו, כי
כאשר קובץ שהפתוח, ריצה ש

298
00:14:50,890 --> 00:14:52,130
קוד בחלק העליון.

299
00:14:52,130 --> 00:14:53,390
האם זה הגיוני?

300
00:14:53,390 --> 00:14:58,060
>> ועכשיו הרעיון מאחורי Node.js הוא כי
הקוד בדברים לעשות עם f

301
00:14:58,060 --> 00:15:04,590
חלק צריך להיות די קצר ופשוט
וברור ולא ממש להיות

302
00:15:04,590 --> 00:15:06,160
מאוד אינטנסיבי המחשוב.

303
00:15:06,160 --> 00:15:09,390
זה אולי צריך לפתוח קובץ אחר, אבל
שצריך להיות גם די מהר

304
00:15:09,390 --> 00:15:14,710
כי זה רק צריך לומר לעשות f אחר
לפתוח ולאחר מכן קורא לקוד אחר זה.

305
00:15:14,710 --> 00:15:19,100
>> אז רק כדי להיות ברור לחלוטין, ו
פתיחה שעושה את שיר Katy Perry החדש

306
00:15:19,100 --> 00:15:23,060
mp3 לעשות, זה הולך די
הרבה לחזור באופן מיידי.

307
00:15:23,060 --> 00:15:27,820
ואז אנחנו יכולים רק להמשיך לעשות
דברים אחרים, כי כל מה שהחברה ו

308
00:15:27,820 --> 00:15:33,410
שיחה פתוחה אין הוא אומר לי בעצם
קוד פתוח ו בסיסי לפתוח קובץ זה

309
00:15:33,410 --> 00:15:36,020
וכשתסיים פתיחה זה
קובץ או כאשר אתה מקבל אותו בחזרה,

310
00:15:36,020 --> 00:15:37,480
לאחר מכן להפעיל את הקוד הזה.

311
00:15:37,480 --> 00:15:39,540
אבל זה לא ממש להפעיל קוד זה.

312
00:15:39,540 --> 00:15:41,815
והיה לך שאלה?

313
00:15:41,815 --> 00:15:46,180
>> קהל: אתה נראה לרמוז כמה
פעמים כי הוספת המחשוב

314
00:15:46,180 --> 00:15:50,545
קוד אינטנסיבי סוג של לשבור את
מערכת מונעת [לא ברור].

315
00:15:50,545 --> 00:15:51,795
[לא ברור]?

316
00:15:51,795 --> 00:15:54,450

317
00:15:54,450 --> 00:15:55,290
>> קווין שמידט: זו שאלה גדולה.

318
00:15:55,290 --> 00:15:59,280
אז יש לי בעצם דוגמא לאופן
אתה יכול לשלב את המחשוב

319
00:15:59,280 --> 00:16:01,090
קוד אינטנסיבי בקצת.

320
00:16:01,090 --> 00:16:03,620
לכן, כאשר אנחנו מגיעים לדוגמאות הקוד,
אני אהיה בטוח כדי למשוך את זה.

321
00:16:03,620 --> 00:16:04,700
האם זה בסדר?

322
00:16:04,700 --> 00:16:05,950
תודה.

323
00:16:05,950 --> 00:16:07,690

324
00:16:07,690 --> 00:16:08,750
>> מה השם שלך?

325
00:16:08,750 --> 00:16:10,620
>> קהל: אהרון.

326
00:16:10,620 --> 00:16:14,830
>> קווין שמידט: אהרון מעלה מאוד
נקודה טובה, וזה שאם היה לי

327
00:16:14,830 --> 00:16:18,560
קצת קוד אינטנסיבי המחשוב ב
הדברים לעשות עם חלק F, שאר

328
00:16:18,560 --> 00:16:22,880
התכנית שלי לא יכולה לרוץ ולא יכולה להקשיב
לבקשות או כל דבר חדשים עד שכל

329
00:16:22,880 --> 00:16:24,270
דברים שהוא סיים.

330
00:16:24,270 --> 00:16:27,390
אז אם אני כותב קוד צומת באופן כללי
אלא אם אנחנו עושים משהו כמו שאני הולך

331
00:16:27,390 --> 00:16:33,060
להציע מאוחר יותר, כאשר אנו מסתכלים על
דוגמאות קוד, אני חייב להיות בטוח כי

332
00:16:33,060 --> 00:16:36,060
הקוד שלי לא לקשור את
אירוע לולאה זו.

333
00:16:36,060 --> 00:16:38,120
האם זה הגיוני?

334
00:16:38,120 --> 00:16:38,350
על אישור.

335
00:16:38,350 --> 00:16:40,040
מגניב.

336
00:16:40,040 --> 00:16:47,090
>> אז Node.js מציע מסגרת זו
אתה יכול לבנות את אירוע אלה מונעים

337
00:16:47,090 --> 00:16:48,210
שרתים עם.

338
00:16:48,210 --> 00:16:53,460
אז יש לו סוג של אסינכרוני אלה
ללא חסימת קלט / פלט ספריות, ואילו

339
00:16:53,460 --> 00:16:56,800
ספריות C סטנדרטיות שאנחנו כבר
עבודה עם, כמו אם אתה רק

340
00:16:56,800 --> 00:16:59,500
להשתמש בם באותו אופן שיש לנו
כבר משתמש בהם עם F פותח ו

341
00:16:59,500 --> 00:17:03,000
דברים, אלה חוסמים בגלל
אתה בעצם צריך לחכות

342
00:17:03,000 --> 00:17:04,470
הקובץ שייפתח.

343
00:17:04,470 --> 00:17:09,290
>> אבל Node.js נותן לך את זה וזה
בעצם מתחבר לV8 של גוגל

344
00:17:09,290 --> 00:17:14,030
JavaScript מנוע המהווה את הסיבה
כי הכרום הוא כל כך מהר, בעיבוד

345
00:17:14,030 --> 00:17:17,040
JavaScript כי זה
יש מנוע V8 הזה.

346
00:17:17,040 --> 00:17:22,460
אז אני יודע שזה נשמע כמו אחד מאותם
דבר כנסי מפתחי WWDC

347
00:17:22,460 --> 00:17:25,390
שבו הם פשוט זורקים את חבורה של
דברים מספר מכתב למעבדים

348
00:17:25,390 --> 00:17:26,910
ואומר את זה כל כך מגניב.

349
00:17:26,910 --> 00:17:34,200
אבל זה מגניב שהם עשו
כי JavaScript זה -

350
00:17:34,200 --> 00:17:37,010
או אולי אם אתה לא מכיר
JavaScript עדיין בגלל שלא היו לנו

351
00:17:37,010 --> 00:17:38,180
ההרצאות על זה -

352
00:17:38,180 --> 00:17:40,770
אבל JavaScript היא לפרש
שפה.

353
00:17:40,770 --> 00:17:41,970
>> וזו נקודה חשובה יותר מדי.

354
00:17:41,970 --> 00:17:45,790
לכן חשוב לאתר האינטרנט שלנו
שרתים להיות מהירים, נכון?

355
00:17:45,790 --> 00:17:49,970
ואם היינו פשוט רצנו JavaScript
קוד שהתפרש רק עם

356
00:17:49,970 --> 00:17:52,130
כל פרשן ישן זה יכול להיות איטי.

357
00:17:52,130 --> 00:17:55,980
יתרונות אז צומת מהצורך זה
פרשן V8 סופר מהיר.

358
00:17:55,980 --> 00:17:59,580
ואני לא יודע אם הם שמו את זה
בגלל סטירת V8 במצח

359
00:17:59,580 --> 00:18:01,110
דבר, אבל בסדר.

360
00:18:01,110 --> 00:18:07,070
>> אז הכנתי כמה דוגמאות
בכתובת זו.

361
00:18:07,070 --> 00:18:10,490
לאחר הסמינר, אני סוג של הולך
לדבר על איך אתה יכול לקבל סט צומת

362
00:18:10,490 --> 00:18:13,570
למעלה, אך לעת עתה, אני פשוט סוג של רצון
ללכת דרך כמה דוגמאות קוד.

363
00:18:13,570 --> 00:18:17,250
כך שאם אתה רוצה לבצע יחד, כל
קוד המקור זמין שם.

364
00:18:17,250 --> 00:18:18,720
בסדר?

365
00:18:18,720 --> 00:18:22,280
>> אז אני אשאיר את כתובת אתר זו
עד לקצת.

366
00:18:22,280 --> 00:18:24,440
ואז אני פשוט הולך
לעבור למסוף.

367
00:18:24,440 --> 00:18:29,670

368
00:18:29,670 --> 00:18:34,400
האם כולם טוב עם כתובת אתר זו?

369
00:18:34,400 --> 00:18:37,990
אז אני הולך לעבור
למסוף שלי כאן.

370
00:18:37,990 --> 00:18:42,030
>> אז הנה הקוד ש
יש לי להיום.

371
00:18:42,030 --> 00:18:43,960
למה שלא נתחיל עם
simpler.js להגיש?

372
00:18:43,960 --> 00:18:49,110

373
00:18:49,110 --> 00:18:52,100
הדבר השני הוא שכל זה
קוד הולך להיות כתוב ב

374
00:18:52,100 --> 00:18:56,660
JavaScript שבו אתה יכול או
לא יכול להיות מוכר.

375
00:18:56,660 --> 00:19:00,170
אני מניח שכמה דברים הוא שהרבה
של קוד JavaScript הוא הסוג של

376
00:19:00,170 --> 00:19:04,000
תחביר ומבנה דומה מאוד
C, ולכן סוג של אתה יכול להרים את זה כמו

377
00:19:04,000 --> 00:19:05,020
אתה הולך יחד.

378
00:19:05,020 --> 00:19:08,750
אני כבר ניסיתי לכתוב הרבה
קוד מתחיל לכך באופן זה

379
00:19:08,750 --> 00:19:11,230
דומה ל-C, כך שזה
קצת יותר קריא.

380
00:19:11,230 --> 00:19:15,980
אבל ככל שנתקדם, אני אהיה
מפגין כמה נוסף

381
00:19:15,980 --> 00:19:18,980
תכונות של JavaScript ש
הם די מגניב.

382
00:19:18,980 --> 00:19:21,510
>> אבל בואו נסתכל על תכנית לדוגמה זו.

383
00:19:21,510 --> 00:19:24,820
אני מניח שכל מה שהוא מנותק שם.

384
00:19:24,820 --> 00:19:28,500
אני רק הולך לתקן אמיתי ש
מהר אם זה בסדר או לא.

385
00:19:28,500 --> 00:19:31,400
אני לא יודע מה זה הולך לעשות.

386
00:19:31,400 --> 00:19:34,660
האם זה קצת יותר טוב?

387
00:19:34,660 --> 00:19:36,510
אתה יכול לראות את var וכאלה?

388
00:19:36,510 --> 00:19:39,320
על אישור.

389
00:19:39,320 --> 00:19:44,120
>> אז השורה הראשונה היא כמו JavaScript
גרסה של משתנה

390
00:19:44,120 --> 00:19:44,800
הכרזה.

391
00:19:44,800 --> 00:19:49,870
אז רק כדי להדגיש את מה שהיית עושה את זה
נראה כמו בג אז זה בדיוק כמו

392
00:19:49,870 --> 00:19:52,620
מדדי אומר שווה שלושה
או משהו כזה.

393
00:19:52,620 --> 00:19:55,740
אז לא לציין את הסוג.

394
00:19:55,740 --> 00:20:00,780
JavaScript אכן יש סוגים, אבל זה
הקלדה מאוד דינמי בטבע, ולכן

395
00:20:00,780 --> 00:20:02,580
לא ספק כל סוג שהוא מהסוג עליו.

396
00:20:02,580 --> 00:20:03,670
אז זה פשוט יש var.

397
00:20:03,670 --> 00:20:05,320
זה כמו משתנה.

398
00:20:05,320 --> 00:20:05,920
בסדר?

399
00:20:05,920 --> 00:20:08,340
>> ואני מתקשר HTTP משתנה זה.

400
00:20:08,340 --> 00:20:12,480
ועל צד ימין שלי, יש לי
ביטוי שאני רוצה לשים בפרוטוקול HTTP.

401
00:20:12,480 --> 00:20:14,960
וזה אומר דורש HTTP.

402
00:20:14,960 --> 00:20:18,500
אז זה די דומה לכולל.

403
00:20:18,500 --> 00:20:22,940
זה קצת יותר כמו חזק מאשר
כולל, במובן זה כולל

404
00:20:22,940 --> 00:20:26,100
היה להעתיק ולהדביק רק את הכותרת
להגיש לאבות טיפוס לפונקציות או

405
00:20:26,100 --> 00:20:27,930
מה עם הגדרות הסוג.

406
00:20:27,930 --> 00:20:30,590
אבל דורש הוא בעצם הולך
כדי לגרום לנו הקוד.

407
00:20:30,590 --> 00:20:33,280
>> אז אתה יכול לחשוב על זה כעל
יבוא קצת קוד.

408
00:20:33,280 --> 00:20:37,960
אז באיזשהו מקום במודול Node.js
מערכת או כל דבר אחר, יש להם את כל זה

409
00:20:37,960 --> 00:20:40,790
קוד שרת HTTP אז אני פשוט
להביא אותו לשלי

410
00:20:40,790 --> 00:20:43,130
שימוש אישי בתכנית זו.

411
00:20:43,130 --> 00:20:44,260
בסדר?

412
00:20:44,260 --> 00:20:46,930
>> אז יש לי את התפקיד הזה
שאני כתבתי.

413
00:20:46,930 --> 00:20:50,330
ושים לב שאני לא צריך לציין
סוג ההחזרה או הסוג של

414
00:20:50,330 --> 00:20:51,140
טיעונים שוב.

415
00:20:51,140 --> 00:20:54,440
אז סוג של הקלדה רופפת ב
זה סוג של תחושה.

416
00:20:54,440 --> 00:20:57,290
שני טיעונים שזה לוקח ב,
הבקשה ותגובה.

417
00:20:57,290 --> 00:21:02,080
אז זה מושגית כמו סוג של
מוכר מהתמונה שהיו לנו

418
00:21:02,080 --> 00:21:05,280
על המסך לפני כי
אנחנו מקבלים בקשה זו שאנו

419
00:21:05,280 --> 00:21:06,410
יש לי מהמשתמש.

420
00:21:06,410 --> 00:21:09,170
ואז יש לנו בתגובה כי
אנחנו יכולים לכתוב דברים.

421
00:21:09,170 --> 00:21:15,060
>> אז השורה הראשונה של עושה
res.writeHead 200 ואז זה

422
00:21:15,060 --> 00:21:17,070
טקסט רגיל לסוג התוכן.

423
00:21:17,070 --> 00:21:19,300
אז בואו זה חתיכה בנפרד קצת.

424
00:21:19,300 --> 00:21:22,340
אז בואו פשוט להתמקד בres.write
לקטן.

425
00:21:22,340 --> 00:21:28,420
אז הכתיבה היא בעצם, ולכתוב את הראש,
הם רק דרכים לכתוב את הסוג של

426
00:21:28,420 --> 00:21:29,960
דברים לתגובה.

427
00:21:29,960 --> 00:21:30,770
בסדר?

428
00:21:30,770 --> 00:21:36,230
אז לכתוב את הראש, אם מישהו זוכר
מהרצאת HTTP, לעשות לך חבר 'ה

429
00:21:36,230 --> 00:21:39,940
זוכר את הכותרות ב
העליון של הדבר HTTP?

430
00:21:39,940 --> 00:21:43,580
אז למה אני לא פשוט הדגמה
כותרות ממש מהר.

431
00:21:43,580 --> 00:21:44,640
האם זה יהיה מועיל?

432
00:21:44,640 --> 00:21:45,500
או שאנחנו צריכים פשוט סוג של -

433
00:21:45,500 --> 00:21:46,070
על אישור.

434
00:21:46,070 --> 00:21:46,740
בטח.

435
00:21:46,740 --> 00:21:52,340
>> לכן, כאשר הדפדפן שלך הולך ל-google.com
או משהו כזה,

436
00:21:52,340 --> 00:21:54,250
אין למעשה קצת יותר -

437
00:21:54,250 --> 00:21:55,380
זה כמו סוד -

438
00:21:55,380 --> 00:21:58,340
יש כמו קצת יותר מידע
שמגיע דרך הצינור מסתם

439
00:21:58,340 --> 00:22:00,180
חיפוש וכל דבר הקטן.

440
00:22:00,180 --> 00:22:03,550
אז כדי להראות לך את זה, אני הולך
כדי להשתמש בתוכנה בשם קורל.

441
00:22:03,550 --> 00:22:04,260
בסדר?

442
00:22:04,260 --> 00:22:08,020
אז זה משהו שאתה יכול לרוץ ב
הקו שלך Mac OSX הפקודה או ב

443
00:22:08,020 --> 00:22:09,830
מכשיר או כל דבר אחר.

444
00:22:09,830 --> 00:22:17,050
ולכן אם אני סלסול HTTP google.com,
אני הולך לראות את ה-HTML.

445
00:22:17,050 --> 00:22:21,230
וזה, בהגינות, רק
HTML שסוג של אומר לך

446
00:22:21,230 --> 00:22:24,695
להפנות לwww אם הדפדפן שלך לא
באופן אוטומטי להתמודד עם

447
00:22:24,695 --> 00:22:27,110
ניתוב מחדש.

448
00:22:27,110 --> 00:22:33,390
>> אז זה רק ה-HTML, אבל אני הולך
להוסיף לסלסול מקף זה אני דגל.

449
00:22:33,390 --> 00:22:33,600
בסדר?

450
00:22:33,600 --> 00:22:35,600
וזה הולך להראות
לי הכותרות.

451
00:22:35,600 --> 00:22:40,640
אז זה גם מידע שמגיע
דרך כאשר אני מקבל את התגובה הזאת.

452
00:22:40,640 --> 00:22:41,260
בסדר?

453
00:22:41,260 --> 00:22:45,320
>> אז בראש, אתה רואה את זה
HTTP 301 להעביר באופן קבוע.

454
00:22:45,320 --> 00:22:49,470
וזה סוג של חשוב, כי
זה מתייחס לקוד המצב.

455
00:22:49,470 --> 00:22:53,750
אז 301 כאן הוא קוד המצב,
שהוא בעצם רק מספר שלם

456
00:22:53,750 --> 00:22:57,750
שאומר לדפדפן או מי שזה
קורא את זה, אם אתה מעמידים פנים ש

457
00:22:57,750 --> 00:23:01,460
אתה דפדפן ואתה רואה את זה,
בעצם עכשיו, אם אתה מסתכל

458
00:23:01,460 --> 00:23:04,960
ושאתה רואה 301, אתה יודע שיש לי
לעשות משהו מיוחד המבוסס על

459
00:23:04,960 --> 00:23:08,810
301, או משהו מיוחד קרה
המבוסס על 301.

460
00:23:08,810 --> 00:23:12,640
אז זה אומר שעבר באופן קבוע.

461
00:23:12,640 --> 00:23:17,700
>> ואז, בעצם, יש לנו
חבורה של זוגות ערך מפתח.

462
00:23:17,700 --> 00:23:22,100
אז אנחנו מקבלים את המיקום
הוא www.google.com.

463
00:23:22,100 --> 00:23:25,190
ואז כל סוג של דברים אחרים זה,
אבל בעצם, מהו המיקום

464
00:23:25,190 --> 00:23:29,662
אמרה היא המיקום החדש
הוא בwww.google.com.

465
00:23:29,662 --> 00:23:33,800
אז עכשיו אם אתה רוצה ללכת ל-google.com, תוכל
סוג של לראות את סוג הדפדפן של מצמוץ

466
00:23:33,800 --> 00:23:38,770
לשנייה ולאחר מכן להפנות אותך
זכות חזרה לwww.google.com.

467
00:23:38,770 --> 00:23:41,840
אז התשובות יכולות להכיל
כותרות אלה.

468
00:23:41,840 --> 00:23:43,330
>> וכמה דברים כדי להצביע.

469
00:23:43,330 --> 00:23:46,890
אז בואו נגיד שהיינו מוצלח באמת
בביקור בדף אינטרנט.

470
00:23:46,890 --> 00:23:49,040
אז תן לי ללכת -

471
00:23:49,040 --> 00:23:51,080
מה אתר טוב?

472
00:23:51,080 --> 00:23:53,285
אני רע בחשיבה של טוב
אתרים במקום.

473
00:23:53,285 --> 00:23:53,640
>> קהל: ויקיפדיה.

474
00:23:53,640 --> 00:23:54,160
>> קווין שמידט: אישור.

475
00:23:54,160 --> 00:23:56,040
בואו נעשה את ויקיפדיה.

476
00:23:56,040 --> 00:23:58,680
אז הנה אני התרגשתי.

477
00:23:58,680 --> 00:23:59,240
אה רגע.

478
00:23:59,240 --> 00:24:00,160
הייתי?

479
00:24:00,160 --> 00:24:00,890
כן, הייתי.

480
00:24:00,890 --> 00:24:01,100
על אישור.

481
00:24:01,100 --> 00:24:03,005
אז יש לי לעשות www.

482
00:24:03,005 --> 00:24:06,006
אז אני הולך לעשות www.

483
00:24:06,006 --> 00:24:09,680
וכפי שאתם יכולים לראות, הנה כל HTML
שהדפדפן היה תהליך

484
00:24:09,680 --> 00:24:10,910
לויקיפדיה.

485
00:24:10,910 --> 00:24:14,055
>> אבל אם אני אמשיך גלילה עד כאן,
מה אני אראה בחלק העליון -

486
00:24:14,055 --> 00:24:17,800
וואו, יש הרבה
HTML בוויקיפדיה -

487
00:24:17,800 --> 00:24:22,550
אבל מה שאני יכול לראות בחלק העליון כאן הוא
קוד שבניגוד לזו 200 מעמד

488
00:24:22,550 --> 00:24:24,570
301 שראיתי קודם לכן.

489
00:24:24,570 --> 00:24:27,100
ושים לב שיש לו נחמד
אישור ידידותי לצד זה.

490
00:24:27,100 --> 00:24:29,470
אז זה כמו קוד מצב הטוב.

491
00:24:29,470 --> 00:24:31,160
>> האם זה מספר 200 נראה מוכר?

492
00:24:31,160 --> 00:24:34,120

493
00:24:34,120 --> 00:24:39,880
כן, כי כשעשיתי simpler.js,
כתבתי 200 שם.

494
00:24:39,880 --> 00:24:43,290
אז זה בעצם אומר לספר
דפדפן או מי שמנסה להגיע ל

495
00:24:43,290 --> 00:24:45,440
זה שהם היו מצליחים.

496
00:24:45,440 --> 00:24:49,040
או סוג כזה שלנו כמו
היו מוצלחים מדי.

497
00:24:49,040 --> 00:24:54,320
>> ויש תחביר מיוחד מסוג זה
ב-Javascript להכרזה

498
00:24:54,320 --> 00:24:59,870
המפה של מקשים אלה כמו סוג התוכן
והערכים הללו כמו טקסט רגיל.

499
00:24:59,870 --> 00:25:03,780
אז אם אתה מסתכל על התגובה שאנחנו
חזרתי מויקיפדיה בעבר, -

500
00:25:03,780 --> 00:25:06,200
אני הולך לנסות כדי לגלול
עד קצת יותר מהר -

501
00:25:06,200 --> 00:25:09,900
יש לך את המפתחות האלה כמו שרת
והערכים הללו האפצ'י.

502
00:25:09,900 --> 00:25:12,120
אז יש לך את מפתחות וערכים.

503
00:25:12,120 --> 00:25:15,930
ואתה יכול לציין זאת ב
צומת מה לשלוח בחזרה.

504
00:25:15,930 --> 00:25:19,380
>> אז זה בעצם סוג של, בכמה
דרכים, ובמובנים מסוימים זה לא

505
00:25:19,380 --> 00:25:23,170
באמת, אבל זה ברמה מעט נמוכה יותר
מקוד PHP שאתה יכול להיות

506
00:25:23,170 --> 00:25:26,980
כתיבה עבור P להגדיר שבע בגלל PHP ו
אפצ'י סוג של לטפל בכמה

507
00:25:26,980 --> 00:25:28,150
הדברים האלה בשבילך.

508
00:25:28,150 --> 00:25:32,520
ב-PHP, אתה יכול לעקוף את ברירת המחדל
התנהגות על ידי כתיבת הכותרות שלך.

509
00:25:32,520 --> 00:25:35,520
אבל לצורך זה, אנחנו מקבלים
כדי לכתוב את הכותרות שלנו.

510
00:25:35,520 --> 00:25:38,210

511
00:25:38,210 --> 00:25:41,105
>> אז האם קו שהגיוני
כולם, בקו הראש לכתוב?

512
00:25:41,105 --> 00:25:41,380
על אישור.

513
00:25:41,380 --> 00:25:42,280
מדהים.

514
00:25:42,280 --> 00:25:45,870
>> אז מה שאני עושה זה לסיים את התגובה
על ידי אמירת שלום עולם.

515
00:25:45,870 --> 00:25:47,040
על אישור.

516
00:25:47,040 --> 00:25:49,920
אבל זה רק פונקציה
נקרא מטפל בקשה.

517
00:25:49,920 --> 00:25:53,510
אז עכשיו אני באמת צריך לעשות סוג של
משהו עם פונקציה זו, נכון?

518
00:25:53,510 --> 00:25:59,170
>> אז הנה מה שאני עושה הוא שיש זה
קו שבו עושה שווים שרת var

519
00:25:59,170 --> 00:26:03,530
HTTP.create שרת, ולאחר מכן אני
לעבור במטפל הבקשה.

520
00:26:03,530 --> 00:26:06,080
אז זה סוג של הצומת
דרך של יצירת שרת.

521
00:26:06,080 --> 00:26:08,790
ושים לב שאני מעביר
במטפל הבקשה.

522
00:26:08,790 --> 00:26:12,290
אז זה אומר לי createServer
פונקציה שאני רוצה שתעשה אותי

523
00:26:12,290 --> 00:26:16,270
שרת, וכאשר השרת שמקבל
תגובה, אני צריך שקורא לזה

524
00:26:16,270 --> 00:26:18,680
לבקש פונקצית מטפל.

525
00:26:18,680 --> 00:26:18,990
בסדר?

526
00:26:18,990 --> 00:26:22,290
>> אז קו שפחות או יותר
מסיים מייד.

527
00:26:22,290 --> 00:26:28,780
אז שורת שרת var נעשית ימין
אחרי שאתה עושה את זה די הרבה.

528
00:26:28,780 --> 00:26:31,770
אני מתכוון, זה חייב להגדיר כמה פנימי
מדינה יודעת שהיית צריך

529
00:26:31,770 --> 00:26:35,400
קורא לזה פונקצית מטפל בקשה, אבל
זה לא הולך לשבת שם ו

530
00:26:35,400 --> 00:26:37,730
יש לומר למשתמש שנשלח
שלי בקשה עדיין?

531
00:26:37,730 --> 00:26:39,270
יש למשתמש שלח לי בקשה עדיין?

532
00:26:39,270 --> 00:26:40,780
אז זה לא לחסום.

533
00:26:40,780 --> 00:26:41,650
בסדר?

534
00:26:41,650 --> 00:26:46,120
>> אז מה זה יעשה הוא זה בעצם
החברה מאחסן את מצביע לקוד הזה,

535
00:26:46,120 --> 00:26:49,670
פונקציה זו בקשת מטפל, ולאחר מכן
יהיה להפעיל קוד שכאשר מישהו

536
00:26:49,670 --> 00:26:52,170
גורם בקשה.

537
00:26:52,170 --> 00:26:54,120
ואז אנחנו עושים server.listen.

538
00:26:54,120 --> 00:26:56,950

539
00:26:56,950 --> 00:26:59,960
>> 1337 שם הוא די שרירותיים.

540
00:26:59,960 --> 00:27:02,285
לא היה לי סיבה מיוחדת
לקטיף המספר הזה.

541
00:27:02,285 --> 00:27:03,860
זה היה אקראי לחלוטין.

542
00:27:03,860 --> 00:27:07,010
אבל זה רק מציין את הנמל.

543
00:27:07,010 --> 00:27:10,640
אז רוב שרתי האינטרנט אתה תראה שהם
להשתמש ביציאה 80 כי זה סוג

544
00:27:10,640 --> 00:27:11,810
כמו האמנה.

545
00:27:11,810 --> 00:27:16,170
אז אם אני הולך למשהו כמו,
אני לא יודע, Wikipedia.org,

546
00:27:16,170 --> 00:27:17,700
ושמתי את מעי גס 8 -

547
00:27:17,700 --> 00:27:18,610
וואו, אתה לא יכול לראות את זה.

548
00:27:18,610 --> 00:27:19,370
אני מצטער.

549
00:27:19,370 --> 00:27:21,820
אבל אם אני עושה את ויקיפדיה -

550
00:27:21,820 --> 00:27:24,810
אני כותב את זה כאן רק כדי ש
זה ברור שעל המצלמה.

551
00:27:24,810 --> 00:27:29,150
אבל אם אני לוקח את זה לדפדפן עם
מעי גס 80, המציין ללכת

552
00:27:29,150 --> 00:27:31,430
Wikipedia.org בנמל 80.

553
00:27:31,430 --> 00:27:36,200
אז זה כמו איך יש לו את ארצות הברית
יציאות מרובות כמו שבו אתה יכול לשלוח

554
00:27:36,200 --> 00:27:37,440
דברים לסוג של.

555
00:27:37,440 --> 00:27:40,730
אז זה כמו ללכת לזה בפרט
מקום על שרת זה.

556
00:27:40,730 --> 00:27:40,990
על אישור.

557
00:27:40,990 --> 00:27:45,730
>> אז אני פשוט בחרתי 1337.

558
00:27:45,730 --> 00:27:47,910
יש מגוון של מספרים שלם
כי אתה יכול לבחור.

559
00:27:47,910 --> 00:27:50,390
זה לא היה מיוחד לחלוטין.

560
00:27:50,390 --> 00:27:54,560
>> אבל מה שאני הולך לעשות עכשיו
הוא אני הולך לרוץ צומת.

561
00:27:54,560 --> 00:27:59,730
תנו לי למעשה להיכנס כי בני זוג
קווים למטה, כך שאתה יכול לראות את זה.

562
00:27:59,730 --> 00:28:03,130
אני הולך לעשות את הצומת, ואני
הולך לרוץ simpler.js.

563
00:28:03,130 --> 00:28:06,880
ונדבר על איך להגיע
צומת הוקמה בקצת.

564
00:28:06,880 --> 00:28:09,350
אבל עכשיו זה פשוט רץ בשרת.

565
00:28:09,350 --> 00:28:14,360
>> אז דבר אחד שאנחנו יכולים לנסות שאולי לא
להיות שמרגש הוא בעצם שאנחנו יכולים

566
00:28:14,360 --> 00:28:16,300
אנסה לגשת אליו בסלסול.

567
00:28:16,300 --> 00:28:20,680
אז אני יכול לעשות את קורל, ושלי
מכונה היא מארח מקומי.

568
00:28:20,680 --> 00:28:24,600
תוכל גם לראות את זה בכתב
כמו לפעמים זה.

569
00:28:24,600 --> 00:28:29,810
מארח ו127.0.0.1 מקומיים הם סוג
כמו המחשב הביתי שלך.

570
00:28:29,810 --> 00:28:33,180
אז זה כמו לדבר
המחשב שלך.

571
00:28:33,180 --> 00:28:33,760
על אישור.

572
00:28:33,760 --> 00:28:36,030
>> ולאחר מכן אני יכול לומר 1337.

573
00:28:36,030 --> 00:28:39,630
אז אם אני מפעיל את הקו הזה של קוד,
זה אומר שלום עולם.

574
00:28:39,630 --> 00:28:44,050
ואם אני רוצה לראות את הדברים האלה, כי
טקסט של סוג התוכן היה רגיל או

575
00:28:44,050 --> 00:28:46,560
מה, אני יכול אפילו לשים את זה כאן.

576
00:28:46,560 --> 00:28:48,810
ושים לב שזה אומר על אישור.

577
00:28:48,810 --> 00:28:50,810
ויש לי טקסט רגיל.

578
00:28:50,810 --> 00:28:53,140
ויש גם את סוג של כל זה אחר
דברים שהצומת תוסיף ב

579
00:28:53,140 --> 00:28:54,440
שם בשבילי.

580
00:28:54,440 --> 00:28:55,700
זה לא סופר חשוב.

581
00:28:55,700 --> 00:28:58,230
>> אני מתכוון, יש כמה סוג של טכני
היבטים של בכי הם סוג

582
00:28:58,230 --> 00:29:02,280
מגניב לדבר עליו, אבל רק כדי להראות
לך, יש לי גם את הכח

583
00:29:02,280 --> 00:29:03,070
לשנות תנאים אלו בסביבה.

584
00:29:03,070 --> 00:29:06,280
אז רק אני יכול להוסיף חבורה
דברים כאלה.

585
00:29:06,280 --> 00:29:11,780
ואז עכשיו, אם אני מסתכל בי
פלט, זה יהיה זה.

586
00:29:11,780 --> 00:29:19,740
אז הכותרות הללו אומר דברים מסוימים
לדפדפנים ודברים כאלה.

587
00:29:19,740 --> 00:29:23,040
>> וכותרות בעצם יכולות להגיד דפדפן
כיצד להגיב למשהו.

588
00:29:23,040 --> 00:29:26,280
אם אי פעם שמעו על עוגיות לפני,
או אם אי פעם היה מתעצבן

589
00:29:26,280 --> 00:29:29,330
על ידי דף אינטרנט הגדרת עוגיות,
או מופעל בלוק או עוגייה

590
00:29:29,330 --> 00:29:30,320
משהו כזה.

591
00:29:30,320 --> 00:29:33,040
למעשה אתה יכול להגדיר עוגיות
בכותרות אלה.

592
00:29:33,040 --> 00:29:36,990
אז הם אומרים לי דפדפן כיצד
התנהגות במקרים מסוימים.

593
00:29:36,990 --> 00:29:37,750
על אישור.

594
00:29:37,750 --> 00:29:40,310
>> אז זה היה simpler.js.

595
00:29:40,310 --> 00:29:42,780
האם יש למישהו שאלות
באותו קובץ קוד המקור?

596
00:29:42,780 --> 00:29:45,420

597
00:29:45,420 --> 00:29:45,610
על אישור.

598
00:29:45,610 --> 00:29:46,490
מגניב.

599
00:29:46,490 --> 00:29:50,780
>> אז בואו להסיר את r מזה
ומסתכל simple.js.

600
00:29:50,780 --> 00:29:53,010
אז זה פחות או יותר
אותה תכנית.

601
00:29:53,010 --> 00:29:56,030
אני רק כתבתי את זה קצת אחר
כי רציתי למיין של גולת כותרת

602
00:29:56,030 --> 00:29:57,850
כמה תכונות של JavaScript.

603
00:29:57,850 --> 00:30:03,880
>> אז שם לב שמטפל הבקשה
פונקציה נעלמה לגמרי.

604
00:30:03,880 --> 00:30:05,800
אה כן, האם יש לך שאלה?

605
00:30:05,800 --> 00:30:08,200
>> קהל: כן, הטיעונים
כי הם עברו לזה

606
00:30:08,200 --> 00:30:10,120
פונקציה, מה הם?

607
00:30:10,120 --> 00:30:12,050
>> קווין שמידט: אז אלה הם
JavaScript אובייקטים.

608
00:30:12,050 --> 00:30:15,230
בתיעוד Node.js, זה
בעצם אומר מה הן שיטות

609
00:30:15,230 --> 00:30:15,910
זמין עליהם.

610
00:30:15,910 --> 00:30:19,602
אנחנו פשוט צריכים הגישה ל
שיטה זו נקראת כתיבת ראש והסוף

611
00:30:19,602 --> 00:30:20,730
ודברים כאלה.

612
00:30:20,730 --> 00:30:22,590
אבל יש חבורה שלמה
עוד שיטות.

613
00:30:22,590 --> 00:30:27,670
>> ולמשל, כאחד מהם
בפרט על rec, אתה יכול לעשות

614
00:30:27,670 --> 00:30:34,540
משהו כמו rec.method אשר יהיה
להגיד לך אם זה HTTP או לקבל

615
00:30:34,540 --> 00:30:36,780
הודעה HTTP בקשות ו
דברים כאלה.

616
00:30:36,780 --> 00:30:39,100
אז יש כל מיני שונים
מאפיינים, אבל הם שניהם

617
00:30:39,100 --> 00:30:42,560
JavaScript אובייקטים, ורק להם
פונקציות המצורפות אליהם, כי אתה

618
00:30:42,560 --> 00:30:43,850
יכול לכתוב דברים.

619
00:30:43,850 --> 00:30:45,520
בסדר?

620
00:30:45,520 --> 00:30:49,030
>> אז שם לב שמטפל הבקשה
הוא נעלם לחלוטין.

621
00:30:49,030 --> 00:30:52,650
אבל הקוד שיש לי בבקשת
מטפל הוא עדיין שם.

622
00:30:52,650 --> 00:30:56,520
עדיין יש לי res.writeHead זה
ועדיין יש לי res.end זה.

623
00:30:56,520 --> 00:31:00,270
ומה זה הוא דוגמא ב
JavaScript היא הרעיון הזה של

624
00:31:00,270 --> 00:31:01,460
פונקציה אנונימית.

625
00:31:01,460 --> 00:31:04,180
ואנונימי הוא כמו שם הולם
לזה כי זה עושה ממש לא

626
00:31:04,180 --> 00:31:05,180
יש לו שם.

627
00:31:05,180 --> 00:31:07,900
אין בקשת פונקציה
מטפל שם.

628
00:31:07,900 --> 00:31:10,110
>> אין לו שם, אבל זה עדיין
הוא לוקח ויכוח.

629
00:31:10,110 --> 00:31:12,250
אז יש לי עוד rec ומיל.

630
00:31:12,250 --> 00:31:16,180
ועדיין יש לי את הקוד.

631
00:31:16,180 --> 00:31:18,930
זה בסדר גמור
קוד JavaScript.

632
00:31:18,930 --> 00:31:22,540
אז אני יכול להכריז על פונקציה ללא
באופן מפורש לתת לו שם.

633
00:31:22,540 --> 00:31:24,250
זה קצת מבלבל בהתחלה.

634
00:31:24,250 --> 00:31:26,230
יש כמה דברים שימושיים כמו
שאתה יכול לעשות עם

635
00:31:26,230 --> 00:31:28,450
פונקציות אנונימיות אלה.

636
00:31:28,450 --> 00:31:32,100
האם יש למישהו שאלות על זה,
או שזה בסדר רק כדי, לעת עתה,

637
00:31:32,100 --> 00:31:34,130
סוג של פשוט לקבל את העובדה שזה
יעשה את אותו הדבר?

638
00:31:34,130 --> 00:31:36,700

639
00:31:36,700 --> 00:31:37,125
כן?

640
00:31:37,125 --> 00:31:38,680
>> קהל: האם פונקציות הראשונות
בכיתה ב-JavaScript?

641
00:31:38,680 --> 00:31:41,020
>> קווין שמידט: הם ראשון
בכיתה ב-JavaScript.

642
00:31:41,020 --> 00:31:45,490
ורק יודע שמושגים אלה
עובר בפונקציה אנונימית כמו

643
00:31:45,490 --> 00:31:49,600
זה חלים על JavaScript שאתה
יכול לכתוב בפרויקט הגמר שלך ל

644
00:31:49,600 --> 00:31:51,260
דפדפן האינטרנט מדי.

645
00:31:51,260 --> 00:31:56,700
כך למשל, בJavaScript ב
הדפדפן שלך, זה גם קצת אירוע

646
00:31:56,700 --> 00:32:00,680
מונע במובן זה מה שאתה
יש לי הוא כאשר המשתמש לוחץ על זה

647
00:32:00,680 --> 00:32:02,640
כפתור, אני רוצה לך להפעיל את הקוד הזה.

648
00:32:02,640 --> 00:32:07,070
>> אז זה אותו הסוג של רעיונות של
בצד לקוח, כאשר בלחיצת עכבר או שהם

649
00:32:07,070 --> 00:32:09,870
במעבר עכבר על תמונה מסוימת עליך
דף האינטרנט, להריץ את הקוד הזה.

650
00:32:09,870 --> 00:32:11,350
זה יכול לחול על שרתים.

651
00:32:11,350 --> 00:32:16,380
אז זה כמו סוג של מרגש
הסיבה JavaScript היא באמת

652
00:32:16,380 --> 00:32:19,810
אנשים מתאימים או שחושבים שזה
שפה מתאימה מסוג זה

653
00:32:19,810 --> 00:32:22,530
שרת נהג אירוע כי יש לך
פונקציות אנונימיות אלה.

654
00:32:22,530 --> 00:32:26,150
יש לך את כל הרעיון של
קוד אסינכרוני זה.

655
00:32:26,150 --> 00:32:27,060
על אישור.

656
00:32:27,060 --> 00:32:30,360
למישהו יש שאלות?

657
00:32:30,360 --> 00:32:30,470
>> על אישור.

658
00:32:30,470 --> 00:32:33,440
אז זה היה simple.js.

659
00:32:33,440 --> 00:32:38,070
אז בואו נסתכל על עוד אחד
או עוד כמה.

660
00:32:38,070 --> 00:32:42,040
אז זה sleep.js.

661
00:32:42,040 --> 00:32:47,160
אז האם מישהו מכיר
שנת פונקצית C?

662
00:32:47,160 --> 00:32:50,936
מאולי אחד מההרצאות הקודמות
או משהו כזה?

663
00:32:50,936 --> 00:32:54,650
>> אז בעצם אתה יכול לעבור באני חושב
מספר שניות, או אם אתה משתמש ב-U

664
00:32:54,650 --> 00:32:57,080
לישון מספר אלפיות השניה
או ננו שניות.

665
00:32:57,080 --> 00:33:00,450
ובעצם התכנית תהיה פשוט להפסיק
פועל במשך פרק זמן זה.

666
00:33:00,450 --> 00:33:01,280
נכון?

667
00:33:01,280 --> 00:33:06,970
ואז זה יהיה סופו של דבר יתעורר ו
אז זה פשוט ממשיך לרוץ

668
00:33:06,970 --> 00:33:08,340
את התכנית.

669
00:33:08,340 --> 00:33:12,740
>> אז שרת זה סוג של נותן
הרושם של שינה.

670
00:33:12,740 --> 00:33:17,580
אז שם לב שיש לנו את אותו
res.writeHead 200 עם הכותרת כמו

671
00:33:17,580 --> 00:33:22,130
בעבר, אבל אז אנחנו קוראים את זה
פונקציה שנקראת פסק זמן שנקבע.

672
00:33:22,130 --> 00:33:26,170
פסק זמן להגדיר זמין גם ב
דפדפן האינטרנט שלך ב-Google Chrome

673
00:33:26,170 --> 00:33:28,000
או ספארי או משהו כזה.

674
00:33:28,000 --> 00:33:31,720
ובעצם מה שהוא עושה כאן
הוא זה לוקח בפונקציה.

675
00:33:31,720 --> 00:33:33,360
שימו לב, שוב, שזה
פונקציה אנונימית.

676
00:33:33,360 --> 00:33:36,310
אז זה די מגניב בגלל שאנחנו
באמצעות פונקציה אנונימית בתוך

677
00:33:36,310 --> 00:33:38,950
פונקציה אנונימית אשר
יכול להיות קצת מוזר.

678
00:33:38,950 --> 00:33:42,270
>> אבל זה לוקח פונקציה ש, שהוא
בעצם אומר - והדרך זו

679
00:33:42,270 --> 00:33:47,430
עבודות היא ב5,000 אלפיות שנייה, אני רוצה
לך לבצע פונקציה שבי

680
00:33:47,430 --> 00:33:50,830
רק מסיימת את התגובה וכותבת היי.

681
00:33:50,830 --> 00:33:56,730
אז זה נותן את הרושם של כאילו
ישן, אבל בדרך זו למעשה

682
00:33:56,730 --> 00:33:59,780
עובד הוא שאנחנו נרוץ דרך
קו זה מהר מאוד.

683
00:33:59,780 --> 00:34:01,190
אנחנו רק כותבים משהו.

684
00:34:01,190 --> 00:34:03,780
ואז גם להפעיל באמצעות
קו זה מהר מאוד.

685
00:34:03,780 --> 00:34:08,620
אז אנחנו לא ממש הולכים
לחכות חמש שניות.

686
00:34:08,620 --> 00:34:11,370
אנחנו רק הולכים לרוץ
קוד זה באופן מיידי.

687
00:34:11,370 --> 00:34:14,219
>> ויש גם, שוב, זה קצת
אירוע לולאה שעכשיו יש את הדבר הזה

688
00:34:14,219 --> 00:34:17,570
אוגרים שבעצם הוא רק
כל הזמן מסתובב במעגל

689
00:34:17,570 --> 00:34:21,620
ומסתכל על השעון באחת
חוט ואומר, יש לו חמש שניות

690
00:34:21,620 --> 00:34:22,360
עבר עדיין?

691
00:34:22,360 --> 00:34:26,409
ואז כשהוא רואה ששני
היד עברה כמו חמש שניות או

692
00:34:26,409 --> 00:34:29,190
מה, אז הוא מתעורר ואומר,
הו, מה אני צריך לעשות?

693
00:34:29,190 --> 00:34:30,350
אוי אני חייב לרוץ את הקוד הזה.

694
00:34:30,350 --> 00:34:33,110
ואז זה הולך
להפעיל res.end היי.

695
00:34:33,110 --> 00:34:35,360
>> אז שוב, אנחנו לא מחכים כאן.

696
00:34:35,360 --> 00:34:38,590
אז זה לא שהקוד הזה בתוך
פונקציה זו הולכת לקחת חמש

697
00:34:38,590 --> 00:34:39,900
שניות לרוץ.

698
00:34:39,900 --> 00:34:43,090
קוד זה יפעל פחות או יותר
באופן מיידי, לפחות ביחס ל

699
00:34:43,090 --> 00:34:46,139
שניות חמש שאנחנו מדברים
עליו קודם לכן בעבר.

700
00:34:46,139 --> 00:34:52,100
>> אז רק כדי להראות את זה בפעולה,
אני יכול לעשות Node.sleep.js.

701
00:34:52,100 --> 00:34:55,159
ועשה לי בלגן משהו?

702
00:34:55,159 --> 00:34:56,310
אולי.

703
00:34:56,310 --> 00:34:57,410
סליחה.

704
00:34:57,410 --> 00:34:59,530
בואו נראה מה אנחנו יכולים לעשות כדי לתקן את זה.

705
00:34:59,530 --> 00:35:10,830

706
00:35:10,830 --> 00:35:12,080
על אישור.

707
00:35:12,080 --> 00:35:15,460

708
00:35:15,460 --> 00:35:17,464
אז בהחלט להשתמש Node.js.

709
00:35:17,464 --> 00:35:19,440
אני רק צוחק.

710
00:35:19,440 --> 00:35:19,570
על אישור.

711
00:35:19,570 --> 00:35:20,820
רק אחד לשנייה.

712
00:35:20,820 --> 00:35:27,380

713
00:35:27,380 --> 00:35:27,900
על אישור.

714
00:35:27,900 --> 00:35:29,130
אני יודע מה זה.

715
00:35:29,130 --> 00:35:34,440
>> אז הבעיה היא שבכרטיסייה אחרת שלי
כאן, אני רץ כבר בצומת

716
00:35:34,440 --> 00:35:36,590
שאותה כתובת, 1337.

717
00:35:36,590 --> 00:35:43,370
אז שגיאה שזה זרק, אם אנחנו מסתכלים
על זה ממש מקרוב, היא בכתובת

718
00:35:43,370 --> 00:35:45,180
להשתמש, EADDRINUSE.

719
00:35:45,180 --> 00:35:47,970
אז כבר הייתי משתמש 1337 כאן.

720
00:35:47,970 --> 00:35:52,210
אז אם אני סוגר את זה, ואז אני עכשיו
אנסה להפעיל את זה, אני מקווה, את כל מה

721
00:35:52,210 --> 00:35:53,210
יהיה בסדר.

722
00:35:53,210 --> 00:35:53,440
על אישור.

723
00:35:53,440 --> 00:35:57,020
אז אתה רק יכול להיות סוג דבר אחד
של ההקשבה ביציאה ובעונה אחת.

724
00:35:57,020 --> 00:35:59,660
פתרון נוסף היה בשבילי
רק כדי לערוך את התוכנית ולהפוך את

725
00:35:59,660 --> 00:36:02,370
זה יהיה כמו 1338 או משהו
ככה.

726
00:36:02,370 --> 00:36:04,100
>> אבל עכשיו שינה פועלת.

727
00:36:04,100 --> 00:36:06,400
אז בואו באמת לנסות את זה ב
דפדפן זה זמן כי זה

728
00:36:06,400 --> 00:36:09,080
מרגש קצת לראות
זה במסוף.

729
00:36:09,080 --> 00:36:13,560
אז רק אני הולך ללכת לזה
127 כתובת שוב ב1337.

730
00:36:13,560 --> 00:36:14,850
ואם אתה יכול לראות את זה -

731
00:36:14,850 --> 00:36:18,050
אני לא יודע אם אתה יכול - אבל שלי
הדפדפן של נטילת מאוד, מאוד ארוך

732
00:36:18,050 --> 00:36:20,600
זמן לטעון או כמו חמש שניות.

733
00:36:20,600 --> 00:36:23,460
>> ואז אחרי זה, זה סוף סוף
סיימתי את התגובה.

734
00:36:23,460 --> 00:36:29,070
ואתה לא יכול לראות את זה כי הדבר
הוא עבר על פני קטן, אבל אם אני עושה

735
00:36:29,070 --> 00:36:32,500
קצת יותר קטן זה, אתה
אפשר לראות את זה, אומר היי.

736
00:36:32,500 --> 00:36:35,130
אז יש לי את היי, אבל
לאחר חמש שניות.

737
00:36:35,130 --> 00:36:38,510
וזה יכול להיות קצת נקי יותר לראות
זה כאן במסוף, ולכן אני

738
00:36:38,510 --> 00:36:40,980
הולך לעשות -

739
00:36:40,980 --> 00:36:43,540
בואו נעשה כאן -

740
00:36:43,540 --> 00:36:48,370
בואו נעשה את סלסול הכתובת ש
שוב עם 1337.

741
00:36:48,370 --> 00:36:50,820
ואני פשוט סוג של צריך לשבת
כאן במשך חמש שניות.

742
00:36:50,820 --> 00:36:53,760
אבל שם לב שהשרת
יכול לקבל את התגובות חדשות.

743
00:36:53,760 --> 00:36:54,940
אז זה מדפיס היי.

744
00:36:54,940 --> 00:36:58,720
>> וכדי הדגמה זו, בעצם מה
אני יכול לעשות בכרטיסייה אחרת זה -

745
00:36:58,720 --> 00:37:02,640
אז בואו נאמרתי שאני עושה את זה בכרטיסייה אחרת,
אני הולך לעשות את קורל ואת אותו

746
00:37:02,640 --> 00:37:03,780
דבר שוב.

747
00:37:03,780 --> 00:37:06,600
ואני הולך לנסות לבעוט אלה
החבר 'ה יורד באותו הזמן.

748
00:37:06,600 --> 00:37:08,260
אז אני הולך לעשות את זה, ואני
הולך להתחרות כאן ואני

749
00:37:08,260 --> 00:37:09,650
הולך לעשות את זה שוב.

750
00:37:09,650 --> 00:37:14,030
>> ובואו נעשיתי את זה, כך שאתה
יכול לראות את שניהם.

751
00:37:14,030 --> 00:37:20,250
כי אחד מודפס היי וכי אחד
מודפס היי כל הדרך ב--

752
00:37:20,250 --> 00:37:22,550
בואו נעשה ניסוי זה שוב.

753
00:37:22,550 --> 00:37:25,100
בעצם, בואו נשתמש בזה
טריק, אם זה בסדר.

754
00:37:25,100 --> 00:37:30,520
>> אז אני הולך להשתמש דבר שפגז
מאפשר לי בעצם להפעיל שני עותקים

755
00:37:30,520 --> 00:37:32,630
של תכנית זו במקביל.

756
00:37:32,630 --> 00:37:36,070
אז זה יהיה להפעיל את התכנית הראשונה ו
התכנית השנייה במקביל.

757
00:37:36,070 --> 00:37:39,060
אז עכשיו אם אני לוחץ על Enter, זה הולך
כדי להפוך את הבקשה שפחות או יותר

758
00:37:39,060 --> 00:37:40,570
באופן מיידי באותו הזמן.

759
00:37:40,570 --> 00:37:42,620
אז בואו אתן לזה צ'אנס.

760
00:37:42,620 --> 00:37:44,950
>> אז עכשיו שם לב לזה, אומר שני תהליכים.

761
00:37:44,950 --> 00:37:50,630
ואם אתם סקרנים, ש27,000
מספר הוא בעצם את תהליך זיהוי.

762
00:37:50,630 --> 00:37:52,940
ואז שם לב, שהם מודפסים
היי באותו הזמן.

763
00:37:52,940 --> 00:37:56,820
זה לא היה כמו שהיינו צריך לחכות חמש
שניות לאחד ואז אחרי זה,

764
00:37:56,820 --> 00:37:59,640
חמש שניות לאחר מכן לקבל את השנייה.

765
00:37:59,640 --> 00:38:03,300
אז זה סוג של, במובנים מסוימים, זה
לא ממש ראיות, אבל זה

766
00:38:03,300 --> 00:38:07,390
ראיות אינטואיטיבי שזה לא רק
כמו מחכה חמש שניות וחסימה

767
00:38:07,390 --> 00:38:08,960
כל החוט.

768
00:38:08,960 --> 00:38:10,720
אישור מגניב.

769
00:38:10,720 --> 00:38:17,850
>> אז אהרון שאל שאלה מוקדם יותר באותו
היה, אז מה אם אנחנו עושים משהו -

770
00:38:17,850 --> 00:38:18,735
כן?

771
00:38:18,735 --> 00:38:19,051
>> קהל: חכה.

772
00:38:19,051 --> 00:38:21,585
איך זה שונה מ
חיץ printf, אם כי?

773
00:38:21,585 --> 00:38:23,010
האם זה לא באופן אוטומטי לעשות את זה?

774
00:38:23,010 --> 00:38:25,390
למה אנחנו צריכים לדאוג בקשר לזה?

775
00:38:25,390 --> 00:38:26,555
>> קווין שמידט: אה, הייתה לך
אומרת שעוד פעם אחת?

776
00:38:26,555 --> 00:38:29,510
>> קהל: האם לא אוהב את חיץ printf
לעשות את אותו הדבר בדיוק?

777
00:38:29,510 --> 00:38:31,280
>> קווין שמידט: חיץ printf?

778
00:38:31,280 --> 00:38:32,753
>> קהל: כן.

779
00:38:32,753 --> 00:38:33,244
על אישור.

780
00:38:33,244 --> 00:38:40,609
לא היה באחד מהחידונים הם היו
מדבר על כך שאם אתה ימני printf

781
00:38:40,609 --> 00:38:42,899
משהו ואז יש לו להשהות אחד
שני, ואז יש לך את זה לולאה עשר

782
00:38:42,899 --> 00:38:46,530
פעמים, זה יחכה עשר שניות ו
אז printf הכל ביחד?

783
00:38:46,530 --> 00:38:47,460
>> קווין שמידט: אה, אוקיי.

784
00:38:47,460 --> 00:38:49,170
>> קהל: האם זה עושה את אותו הדבר
דבר אז במקרה זה?

785
00:38:49,170 --> 00:38:52,630
>> קווין שמידט: אז השאלה הייתה
בעצם באחד מהחידונים לשעבר

786
00:38:52,630 --> 00:38:57,200
או משהו, לא הייתה שאלה ש
בעצם אם אתה אומר הדפסה ו 10

787
00:38:57,200 --> 00:39:01,490
דברים בו זמנית ולאחר מכן ישנו כמו ב
תהליך הדפסה אותם החוצה,

788
00:39:01,490 --> 00:39:04,850
בסופו של הדבר מסיבה כלשהי, זה היה
פשוט לזרוק את כל אלה על המסך.

789
00:39:04,850 --> 00:39:06,740
אז יש סוג של שתי שונים
מושגים כאן.

790
00:39:06,740 --> 00:39:10,400
>> אז אני מניח שדבר אחד הוא, כי בזה
מקרה, שאנחנו עם שתי שונים העוסקים

791
00:39:10,400 --> 00:39:13,510
סוג של אנשים שואלים את השרת
לדברים באותו הזמן.

792
00:39:13,510 --> 00:39:17,455
והסיבה לכך שהסוג של printf
מחכה כמו ושמרוקן את כל זה

793
00:39:17,455 --> 00:39:21,760
בבת אחת הוא קשור יותר
איך סוג של printf -

794
00:39:21,760 --> 00:39:25,100
כך printf הדרך הוא למעשה
מיושם הוא זה בעצם יש

795
00:39:25,100 --> 00:39:28,850
לדבר עם מערכת ההפעלה כדי לכתוב
דברים שלקונסולה.

796
00:39:28,850 --> 00:39:33,460
אז זה לא רוצה לעשות את כל זה
דברים מייד כשאתה אומר printf

797
00:39:33,460 --> 00:39:36,260
כמה מחרוזת משום שיכול
לקבל יקר אם יש לו

798
00:39:36,260 --> 00:39:37,340
לעשות את זה בכל פעם.

799
00:39:37,340 --> 00:39:41,530
>> אז אם אתה עושה printf היי, התכנית שלך
אולי לא ממש להדפיס כי

800
00:39:41,530 --> 00:39:43,040
מייד למסוף.

801
00:39:43,040 --> 00:39:46,080
זה אולי אומר, אוקיי, אני כתבתי אותו.

802
00:39:46,080 --> 00:39:49,570
ואז לחכות סוג של לך לתת
זה קצת יותר לפני למעשה

803
00:39:49,570 --> 00:39:51,380
כותב את זה לקונסולה.

804
00:39:51,380 --> 00:39:54,040
>> אז הסיבה לכך שזה היה המקרה -

805
00:39:54,040 --> 00:39:56,450
וזה סוג של בלתי קשור
לשינה -

806
00:39:56,450 --> 00:40:00,060
הוא שהשינה הייתה סוג של רק
הזריק לשם כדי להפגין

807
00:40:00,060 --> 00:40:02,480
עובדה שזה לא לכתוב
זה באופן סינכרוני.

808
00:40:02,480 --> 00:40:06,210
אבל הסיבה לכך היא פשוט
ביצועים, כך שאתה לא צריך

809
00:40:06,210 --> 00:40:08,920
ליצור קשרים שרבים
מערכת ההפעלה.

810
00:40:08,920 --> 00:40:12,300
>> אבל כאן, מה שאנחנו באמת מנסים לעשות
עם הדבר ישן הזה הוא רק להראות

811
00:40:12,300 --> 00:40:17,730
כי כאשר יש לנו שני אנשים לבקר
האתר הזה, זה לא הולך לשים

812
00:40:17,730 --> 00:40:22,310
אותם בשורה שבה הוא הולך להגיד
אני חייב לעזור לך, ואז כשאני

813
00:40:22,310 --> 00:40:25,350
לחלוטין סיים לעזור לך אחרי אלה
חמש שניות, ואז אני הולך

814
00:40:25,350 --> 00:40:26,750
לעבור על האדם הבא.

815
00:40:26,750 --> 00:40:29,515
אז את בקשתו של האדם הראשון לא
לקשור את אירוע לולאה

816
00:40:29,515 --> 00:40:31,610
אם זה נשמע הגיוני.

817
00:40:31,610 --> 00:40:34,980
>> אבל כאן היא למעשה דוגמא
של משהו שיקשור

818
00:40:34,980 --> 00:40:36,090
את אירוע הלולאה.

819
00:40:36,090 --> 00:40:39,130
אז הנה פונקציה נורא
לחשב את פיבונאצ'י המי יודע כמה.

820
00:40:39,130 --> 00:40:43,510
זה ממש גרוע הדרך שתוכל
לחשב את מספר פיבונאצ'י המי יודע כמה.

821
00:40:43,510 --> 00:40:48,480
וזה בעצם רק כדי להכיר
איפה זה בא,

822
00:40:48,480 --> 00:40:49,330
אין למעשה -

823
00:40:49,330 --> 00:40:53,230
אני מתכוון, אתה יכול לנסות ללכת למצוא אותו - אבל
יש כמו בלוג ארוך מאוד

824
00:40:53,230 --> 00:40:54,130
לפרסם שמישהו כתב.

825
00:40:54,130 --> 00:40:55,660
זה כמו אחד מהדברים Reddit אלה.

826
00:40:55,660 --> 00:40:59,650
אבל מישהו מתח ביקורת Node.js, ו
הם השתמשו בזה כדוגמא.

827
00:40:59,650 --> 00:41:03,700
אז אני רוצה סוג של רק להראות לך שני
נקודות מבט שונים, רק כדי לקבל

828
00:41:03,700 --> 00:41:07,320
הבנה כללית של המושגים
מאחורי שני הדברים האלה.

829
00:41:07,320 --> 00:41:13,050
>> אבל זו נבחרה כפשוט נורא,
המחשוב יעיל להחריד

830
00:41:13,050 --> 00:41:15,940
דרך אינטנסיבית כדי לחשב את
מספר פיבונאצ'י המי יודע כמה.

831
00:41:15,940 --> 00:41:21,180
אז רק כהערה צדדית, למה הוא
זה נורא כמו בדרך זו?

832
00:41:21,180 --> 00:41:23,210
כן?

833
00:41:23,210 --> 00:41:25,130
>> קהל: תגיד שאתה מתחיל
עם 1,000.

834
00:41:25,130 --> 00:41:27,050
1,000 מתפצל ל999 ו998.

835
00:41:27,050 --> 00:41:28,970
כל אחד מזה מתפצל לשני דברים.

836
00:41:28,970 --> 00:41:30,890
כל אחד מזה מתפצל לשני דברים.

837
00:41:30,890 --> 00:41:31,355
>> קווין שמידט: נכון.

838
00:41:31,355 --> 00:41:32,400
>> קהל: כל הדרך למטה.

839
00:41:32,400 --> 00:41:32,840
>> קווין שמידט: בדיוק.

840
00:41:32,840 --> 00:41:37,330
אז רק כדי לחזור למצלמה, אם אני
קוראים לבלף על כמו 1,000 או משהו

841
00:41:37,330 --> 00:41:41,810
ככה, זה ברור שלא פחות מ
או שווה לאחד אז אני הולך ל

842
00:41:41,810 --> 00:41:46,040
תלך למקרה אחר זה, ולאחר מכן אני הולך
לקרוא לבלף 999 תוספת לבלף 998.

843
00:41:46,040 --> 00:41:50,290
ואז פחות או יותר את כל זה
עבודה שלבלף 999 עושים היא

844
00:41:50,290 --> 00:41:52,950
סוג של ברמה זו.

845
00:41:52,950 --> 00:41:55,620
אם אתה יורד, זה אפילו יותר מיותר
יותר מזה, אבל אם אתה רק

846
00:41:55,620 --> 00:42:01,390
חושב לבלף מחשוב 998 מקבל
שלנו די קרוב לבלף 999.

847
00:42:01,390 --> 00:42:05,860
אז אנחנו באמת צריכים להיות קצת יותר
חכם על איך אנחנו סוג של שימוש חוזר

848
00:42:05,860 --> 00:42:07,580
האלה, אבל אנחנו לא שימוש חוזר
את הדברים האלה בכלל.

849
00:42:07,580 --> 00:42:11,860
אז אתה יכול לדמיין את זה ענק,
עץ ענק שפשוט נורא.

850
00:42:11,860 --> 00:42:12,940
>> אבל בכל מקרה, על אישור.

851
00:42:12,940 --> 00:42:14,040
אז זה היה לבלף.

852
00:42:14,040 --> 00:42:15,530
זה פשוט לוקח זמן כדי לרוץ.

853
00:42:15,530 --> 00:42:16,510
כן?

854
00:42:16,510 --> 00:42:17,760
>> קהל: [לא ברור].

855
00:42:17,760 --> 00:42:20,430

856
00:42:20,430 --> 00:42:22,481
>> קווין שמידט: אה, הייתה לך
לחזור על השאלה?

857
00:42:22,481 --> 00:42:23,731
>> קהל: [לא ברור].

858
00:42:23,731 --> 00:42:30,840

859
00:42:30,840 --> 00:42:33,990
>> קווין שמידט: אה, אז זה רק קוד
זה הולך להיות סוג של על

860
00:42:33,990 --> 00:42:34,850
בצד שרת.

861
00:42:34,850 --> 00:42:38,100
אז זה לא הולך ניתן למצוא
בדפדפן או משהו כזה.

862
00:42:38,100 --> 00:42:42,160
זה בעצם מה שיש לנו הוא שכאשר
המשתמש כאן פחות או יותר עושה

863
00:42:42,160 --> 00:42:45,300
בקשתם שוב, כאשר אנו סוג של
להגיש בקשה, אנחנו הולכים לקרוא

864
00:42:45,300 --> 00:42:47,040
פונקציה זו בצד השרת.

865
00:42:47,040 --> 00:42:50,480
ואז מקבלים את התוצאה בחזרה
מקריאה לפונקציה זו.

866
00:42:50,480 --> 00:42:52,460
ואז אנחנו פשוט להדפיס
אותה למשתמש.

867
00:42:52,460 --> 00:42:54,580
כך שהמשתמש לא ממש להתמודד
עם פונקציה זו יותר מדי.

868
00:42:54,580 --> 00:42:57,270
>> הייתה שהשאלה?

869
00:42:57,270 --> 00:42:58,470
האם זה הגיוני?

870
00:42:58,470 --> 00:42:58,810
על אישור.

871
00:42:58,810 --> 00:43:00,930
מגניב.

872
00:43:00,930 --> 00:43:04,240
>> אז שוב, אנחנו עושים את כל זה res.writeHead
דבר שבו אנחנו להדפיס

873
00:43:04,240 --> 00:43:05,150
הכותרת.

874
00:43:05,150 --> 00:43:09,730
ואז אני בסופו התגובה על ידי עושה
מספר הקסם הוא לבלף 45.

875
00:43:09,730 --> 00:43:12,100
אז בואו פשוט להפעיל את השרת הזה.

876
00:43:12,100 --> 00:43:15,190
אז אני הולך לעשות fib.js. צומת

877
00:43:15,190 --> 00:43:17,340
אז עכשיו השרת לבלף שלי פועל.

878
00:43:17,340 --> 00:43:21,790
>> ואז הנה, אני הולך
לעשות אחד מאלה.

879
00:43:21,790 --> 00:43:22,200
בסדר?

880
00:43:22,200 --> 00:43:24,960
אז רק אני הולך לומר, סלסול.

881
00:43:24,960 --> 00:43:32,226
אז זה הולך לקחת קצת זמן, אבל
אני מקווה שבקרוב זה יהיה סופו ו

882
00:43:32,226 --> 00:43:35,660
הוא ידפיס 45th כי
פיבונאצ'י מספר.

883
00:43:35,660 --> 00:43:36,910
>> קהל: [לא ברור].

884
00:43:36,910 --> 00:43:40,720

885
00:43:40,720 --> 00:43:42,050
>> קווין שמידט: זה צריך
להספיק די בקרוב.

886
00:43:42,050 --> 00:43:43,780
כך זה צריך להימשך חמש עד שש שניות.

887
00:43:43,780 --> 00:43:48,570
אני לא יודע זה רק סופר להיות V8
מהר, אבל בכל מקרה, זו היא

888
00:43:48,570 --> 00:43:52,700
דוגמא קצרה מאוד ובכוונה
לא אלגנטי של לא טריוויאלית

889
00:43:52,700 --> 00:43:54,200
חישוב.

890
00:43:54,200 --> 00:43:56,700
אז אחרי כמה זמן, זה לקבל את זה.

891
00:43:56,700 --> 00:44:02,130
>> אבל עכשיו, מה אם אני עושה את זה אותו סוג של
ניסוי כמו בעבר שבו אני עושה

892
00:44:02,130 --> 00:44:04,010
שתי בקשות באותו הזמן?

893
00:44:04,010 --> 00:44:06,990
אז הנה אני הולך קורל על
כתובת זו, ואני הולך

894
00:44:06,990 --> 00:44:08,260
לעשות עוד סלסול.

895
00:44:08,260 --> 00:44:12,070
וזכור, כשעשינו את זה בשביל
לישון שרת, כאשר אנו בעצם לא היינו לו

896
00:44:12,070 --> 00:44:15,320
לאחר חמש שניות, הם די
הרבה שניהם חזרו תקין

897
00:44:15,320 --> 00:44:16,380
בערך באותו הזמן.

898
00:44:16,380 --> 00:44:18,650
אז זה לא היה במיוחד קשור.

899
00:44:18,650 --> 00:44:20,290
>> אבל בואו ננסה את זה עכשיו.

900
00:44:20,290 --> 00:44:22,370
אוקיי, אז יש לנו שני התהליכים שלנו.

901
00:44:22,370 --> 00:44:24,210
זכור אלה מזהי התהליך.

902
00:44:24,210 --> 00:44:25,900
זה הולך להיות קצת
מביך בזמן שאנחנו הדוכן.

903
00:44:25,900 --> 00:44:31,340

904
00:44:31,340 --> 00:44:35,360
אז בואו פשוט להישאר כאן ולחכות.

905
00:44:35,360 --> 00:44:37,090
>> אז אחד מהם צריך לבוא
חזרה אחרי כמו -

906
00:44:37,090 --> 00:44:39,190
אוקיי, אז אחת חזר.

907
00:44:39,190 --> 00:44:43,570
אבל אז למה לא עשה את השני
אחד חזר עדיין?

908
00:44:43,570 --> 00:44:44,389
כן?

909
00:44:44,389 --> 00:44:49,280
>> קהל: השרת לא יכול לעשות כלום
בזמן שהוא החישוב שמספר גדול.

910
00:44:49,280 --> 00:44:51,620
>> קווין שמידט: נכון.

911
00:44:51,620 --> 00:44:55,395
אז התגובה הייתה פשוט כי השרת
באמת לא יכול לעשות כלום בזמן

912
00:44:55,395 --> 00:44:57,460
זה חישוב שפיבונאצ'י.

913
00:44:57,460 --> 00:44:59,360
אז עכשיו יש לי רק שני הדברים שלי בחזרה.

914
00:44:59,360 --> 00:45:03,210
אבל אני מניח שרק לחשוב על הקוד
קצת יותר, איך זה עובד

915
00:45:03,210 --> 00:45:05,030
והכל.

916
00:45:05,030 --> 00:45:11,750
>> אז פונקציה זו כאן את הקוד ש
כבר אמר לי שרת זה לרוץ כאשר הוא

917
00:45:11,750 --> 00:45:14,100
מקבל בקשה נכנסת חדשה.

918
00:45:14,100 --> 00:45:17,940
אז זה פשוט הולך לרוץ דרך זה
קוד כולו, ולאחר מכן זה הולך ללכת

919
00:45:17,940 --> 00:45:21,120
לגבות לאירוע הלולאה ולאחר מכן להמשיך
בדיקה לאירועים חדשים.

920
00:45:21,120 --> 00:45:23,670
אז בעצם מה שקורים
הוא השרת הוא

921
00:45:23,670 --> 00:45:25,080
האזנה לדברים חדשים.

922
00:45:25,080 --> 00:45:28,070
האדם הראשון שואל על מה הוא 45.

923
00:45:28,070 --> 00:45:30,490
אנו מפעילים את הקוד הזה כדי לחשב את זה.

924
00:45:30,490 --> 00:45:33,420
קוד זה לוקח בערך חמש
לשש שניות לרוץ.

925
00:45:33,420 --> 00:45:36,990
אחר כך אנחנו חוזרים לאירוע הלולאה
ולבדוק בקשות חדשות.

926
00:45:36,990 --> 00:45:42,700
>> אז זו דוגמא לאופן, אם אתם
יש דברים שהם מחשוב שנקרא

927
00:45:42,700 --> 00:45:48,140
מחויב, או להשתמש הרבה חישובית,
לא כוח, אבל כמוהם

928
00:45:48,140 --> 00:45:50,260
המחשוב עתיר -

929
00:45:50,260 --> 00:45:54,080
אני מניח שדבר אחד להגיד על זה
שפונקציה זו עושה לגמרי,

930
00:45:54,080 --> 00:45:56,310
על פי רוב, די
ממש עבודה מועילה.

931
00:45:56,310 --> 00:45:59,970
כל הזמן שהתקשרות ש
הפונקציה רצה, זה היה די

932
00:45:59,970 --> 00:46:03,670
הרבה מבלה את רוב זמנה רק
מספר פיבונאצ'י המי יודע כמה מחשוב.

933
00:46:03,670 --> 00:46:05,930
>> אבל היה לנו רק חוט אחד
כדי להתמודד איתו.

934
00:46:05,930 --> 00:46:10,270
במודל האפצ'י, כאשר שני אנשים
הגיש את הבקשה כדי לקבל לבלף 45, אנחנו

935
00:46:10,270 --> 00:46:11,610
היו לו שני נושאים שונים.

936
00:46:11,610 --> 00:46:15,060
ולאחר מכן העבודה של מערכת ההפעלה
הייתה, או ברמת המשתמש

937
00:46:15,060 --> 00:46:18,660
קוד שמנהל את האשכולות, היה כבר
היה לחתוך את זה על

938
00:46:18,660 --> 00:46:23,060
מעבד, או אפילו אם היה לך מעבדים מרובים,
להפיץ אותם באופן שווה על פני המעבדים

939
00:46:23,060 --> 00:46:26,130
כך ששניהם היו לסיים
בערך באותו הזמן.

940
00:46:26,130 --> 00:46:31,120
>> אז רק כדי להראות לך איך אנחנו יכולים למיין של -
ואת זה הוא לא מושלם סך הכל

941
00:46:31,120 --> 00:46:34,280
פתרון, אבל סוג של איך אנחנו יכולים
להפוך לחזור לכאן ולעשות

942
00:46:34,280 --> 00:46:35,880
קצת יותר טוב.

943
00:46:35,880 --> 00:46:41,540
אז מה יש לי כאן הוא תכנית בשם
לבלף ג וזה בעצם משתמש

944
00:46:41,540 --> 00:46:45,690
עוד אחד מהמודולים של הצומת נקראת
מודול תהליך הילד.

945
00:46:45,690 --> 00:46:49,210
אז צירפתי כי בסוג העליון
כמו שהייתי עושה קילו כולל

946
00:46:49,210 --> 00:46:51,230
process.h ילד או משהו.

947
00:46:51,230 --> 00:46:56,210
עכשיו יש לי גישה למשתנה CP זה
שבו יש את כל הפונקציונליות שלי.

948
00:46:56,210 --> 00:47:01,810
>> אז עכשיו מה שאני עושה בתגובה הזאת
מטפל הוא אני מפעיל תכנית זו

949
00:47:01,810 --> 00:47:04,100
נקודה לקצץ לבלף 45.

950
00:47:04,100 --> 00:47:06,820
אז מה שעשיתי - ואני רק הולך
כדי לצאת מתכנית זו עבור

951
00:47:06,820 --> 00:47:07,620
קצת -

952
00:47:07,620 --> 00:47:11,060
הוא כתבתי תכנית C כי
בעצם מחשב את

953
00:47:11,060 --> 00:47:12,630
מספר פיבונאצ'י המי יודע כמה.

954
00:47:12,630 --> 00:47:15,960
אז הנה רק תכנית שכתבתי
ב-C, שמחשב את זה.

955
00:47:15,960 --> 00:47:19,040
אני יכול לאסוף את זה, ואני יכול לרוץ
זה בשורת הפקודה.

956
00:47:19,040 --> 00:47:22,150
וזה הולך לחשב את
מספר 45th פיבונאצ'י.

957
00:47:22,150 --> 00:47:24,510
>> אז שם לב לזה פשוט לוקח
פחות או יותר כל עוד.

958
00:47:24,510 --> 00:47:28,240
אני כנראה היה יכול להשתמש במקף 03 ל
לייעל את זה או משהו כזה,

959
00:47:28,240 --> 00:47:31,050
אבל אני פשוט לא אהבתי רגיל
הגדרות מהדר.

960
00:47:31,050 --> 00:47:33,260
והיא מדפיסה אותו החוצה.

961
00:47:33,260 --> 00:47:36,830
>> אבל עכשיו, מה אני עושה סוג של?

962
00:47:36,830 --> 00:47:39,800
אה סליחה, קובץ הלא נכון.

963
00:47:39,800 --> 00:47:42,800
אז אני עושה את אותם דברים, עם
הכותרת כמו קודם.

964
00:47:42,800 --> 00:47:45,780
ואז אני עושה cp.exec זה.

965
00:47:45,780 --> 00:47:49,460
אז מה זה הולך לעשות הוא זה
הולך להפעיל את התכנית.

966
00:47:49,460 --> 00:47:51,960
אבל הדרך שזה עובד היא כי
זה לא הולך לחכות

967
00:47:51,960 --> 00:47:53,400
תכנית שכדי לסיים.

968
00:47:53,400 --> 00:47:56,000
זה פשוט בעצם אומר
ביצוע תכנית זו.

969
00:47:56,000 --> 00:47:58,700
אז בעצם להקליד את זה לתוך
פקודת סוג הפקודה של.

970
00:47:58,700 --> 00:48:02,350
>> ואז, כשתסיים עם
אותו, להפעיל פונקציה זו.

971
00:48:02,350 --> 00:48:04,800
אז עכשיו אנחנו סוג של לקבל את זה
דבר כולו משוחזר של

972
00:48:04,800 --> 00:48:06,750
כמו שאנחנו לא מחכים.

973
00:48:06,750 --> 00:48:08,530
האם זה סוג של הגיוני?

974
00:48:08,530 --> 00:48:08,990
כן?

975
00:48:08,990 --> 00:48:11,060
>> קהל: [לא ברור]?

976
00:48:11,060 --> 00:48:13,610
>> קווין שמידט: אז זה יהיה ממש
לפתוח תהליך חדש לעשות את זה.

977
00:48:13,610 --> 00:48:19,310
אז זה הוא למעשה, במובנים מסוימים,
רע, לא סופר רע, אבל זה

978
00:48:19,310 --> 00:48:22,990
חשוב להגיד שזה סוג של
חוזר ל, מצד אחד, האפצ'י

979
00:48:22,990 --> 00:48:26,450
מודל שבו אנחנו עושים את הנושאים ותהליכים
לכל בקשה או

980
00:48:26,450 --> 00:48:29,280
תהליכים לכל בקשה.

981
00:48:29,280 --> 00:48:32,090
אז זה סוג של אנלוגי
למה האפצ'י עושה.

982
00:48:32,090 --> 00:48:35,110
במקרים מסוימים, זה יהיה פשוט להשתמש חדש
חוט, שהוא קצת יותר אור

983
00:48:35,110 --> 00:48:39,040
משקל מאשר תהליך, אבל האפצ'י יכול
בסופו של שופכי תהליך חדש

984
00:48:39,040 --> 00:48:43,370
שהוא סוג של מה שאנחנו עושים כאן
במשתמע על ידי עושה לבלף לוכסן נקודת 45.

985
00:48:43,370 --> 00:48:48,690
>> ואז במקרה כזה, אנחנו סוג של להיגרם
אותו הוצאות של תהליכים.

986
00:48:48,690 --> 00:48:50,710
אז זה רק דבר אחד שאתה יכול לעשות.

987
00:48:50,710 --> 00:48:52,600
אבל רק כדי להראות סוג זה של ריצה.

988
00:48:52,600 --> 00:48:57,120
והדיבור הזה הוא פשוט באמת שמטרתה
הצגת סוג של תוכניות אלה, כמו

989
00:48:57,120 --> 00:49:00,710
דרך להראות נקודות מבט שונות על
כיצד לעצב שרתים כאלה.

990
00:49:00,710 --> 00:49:08,300
אז זה פועל, ואז עכשיו אם אני עושה
זה שוב, יש לי שתי תעודות זהות של תהליך.

991
00:49:08,300 --> 00:49:10,320
>> בואו רק לדבר על
דברים כדי להצביע.

992
00:49:10,320 --> 00:49:11,980
אז שם לב שהם באופן הדרגתי.

993
00:49:11,980 --> 00:49:12,700
זה מגניב.

994
00:49:12,700 --> 00:49:15,140
כי זה היה 27,122 לפני.

995
00:49:15,140 --> 00:49:18,580
אבל שימו לב עכשיו, הם חזרו
בערך באותו הזמן.

996
00:49:18,580 --> 00:49:23,960
>> ועכשיו, שאלה טובה לשאול על
מדוע היה כי המקרה הוא, שתפקידם

997
00:49:23,960 --> 00:49:27,590
היה זה עכשיו כדי לעשות סוג של הדברים האלה
סוג של משחק הוגן עם כל

998
00:49:27,590 --> 00:49:31,350
, שני מקרים אלה אחרים של
לבלף לוכסן נקודת 45 שרצתי

999
00:49:31,350 --> 00:49:32,880
או שרץ צומת?

1000
00:49:32,880 --> 00:49:36,940
מי סוג של עושה את זה הוגן ששניהם
לקבל מאוזנת סוג של זמן ריצה?

1001
00:49:36,940 --> 00:49:42,900

1002
00:49:42,900 --> 00:49:44,220
>> קהל: [לא ברור].

1003
00:49:44,220 --> 00:49:44,620
>> קווין שמידט: כן.

1004
00:49:44,620 --> 00:49:49,740
אז בעצם, כשאני עושה לבלף לוכסן נקודה
45 או משהו כזה, עכשיו זה

1005
00:49:49,740 --> 00:49:53,750
סוג של עד מערכת ההפעלה כדי
להתמודד עם הריצה של תוכניות אלה.

1006
00:49:53,750 --> 00:49:56,920
ועכשיו הוא יכול לתזמן אותם
על מעבדים שונים או שזה

1007
00:49:56,920 --> 00:49:58,330
ניתן לתזמן אותם.

1008
00:49:58,330 --> 00:50:01,870
זה יכול לחתוך את הזמן שאחד
מעבד מקבל את זה או שהם מקבלים

1009
00:50:01,870 --> 00:50:03,330
לרוץ על מעבד אחד.

1010
00:50:03,330 --> 00:50:05,620
אז זה הרעיון שעומד מאחורי זה.

1011
00:50:05,620 --> 00:50:07,220
האם זה הגיוני לכולם?

1012
00:50:07,220 --> 00:50:10,950
אז עכשיו הצומת היא לא ממש שיחקה
חלק בחלוקת משימות אלה.

1013
00:50:10,950 --> 00:50:12,200
על אישור.

1014
00:50:12,200 --> 00:50:14,050

1015
00:50:14,050 --> 00:50:17,840
>> אז זה כמעט זה לדוגמאות.

1016
00:50:17,840 --> 00:50:23,370
רק רציתי להראות עוד דבר אחד
כי הרבה זה עד כה

1017
00:50:23,370 --> 00:50:27,350
לא לגמרי סופר מעשי
במקרים מסוימים.

1018
00:50:27,350 --> 00:50:30,970
אני יכול לדמיין את מגיע הביתה אחרי זה
לדבר ומשהו ואומר כמו,

1019
00:50:30,970 --> 00:50:35,710
גם אני סוג של יצאתי מהשיחה כי
אני יכול לעשות שרת פיבונצ'י

1020
00:50:35,710 --> 00:50:37,360
פרויקט הגמר שלי.

1021
00:50:37,360 --> 00:50:40,770
אז הנה רק סוג של דוגמא אחת יותר
שאני מקווה שיהיה -

1022
00:50:40,770 --> 00:50:44,620
אולי לא, אבל אולי - קצת יותר
סוג של רלוונטי לפרויקטי גמר ו

1023
00:50:44,620 --> 00:50:46,440
חושב קדימה לדברים כאלה.

1024
00:50:46,440 --> 00:50:48,870
>> אז זה chat.js.

1025
00:50:48,870 --> 00:50:52,290
אז זה סוג של רוצה קצת מדגם
קוד בצד שרת שאתה יכול להשתמש בו כדי

1026
00:50:52,290 --> 00:50:55,700
להקים שרת צ'אט קטן כמו
אתה יכול לראות על

1027
00:50:55,700 --> 00:50:56,630
פייסבוק צ'אט או משהו כזה.

1028
00:50:56,630 --> 00:50:59,990
אז אני לא אומר שזה כמו פייסבוק
צ'אט, אבל זה סוג של

1029
00:50:59,990 --> 00:51:06,230
כמו טוב - אולי לא טוב, אבל אולי
נקודה לשיחה מתחילה - טובה

1030
00:51:06,230 --> 00:51:08,560
שרת עבור האתר שלך
לפרויקט גמר.

1031
00:51:08,560 --> 00:51:11,040
אז בואו נסתכל על מה שהוא עושה.

1032
00:51:11,040 --> 00:51:15,500
>> אז אנחנו מקבלים את הדבר המיוחד הזה
בחלק העליון, זה var SIO

1033
00:51:15,500 --> 00:51:17,050
שווה דורש Socket.IO.

1034
00:51:17,050 --> 00:51:20,280
אז זה עוד דבר שהיא עושה לא
באו בעצם יחד עם

1035
00:51:20,280 --> 00:51:22,300
צומת אבל אתה יכול להתקין אותו.

1036
00:51:22,300 --> 00:51:23,480
זה מודול צומת.

1037
00:51:23,480 --> 00:51:25,670
אז זה בדיוק כמו כמה
סיומת לצומת.

1038
00:51:25,670 --> 00:51:29,220
>> SocketIO הוא ממש ממש
די מגניב.

1039
00:51:29,220 --> 00:51:32,550
זה הפשטה שבעצם מה
היא עושה הוא שזה מאפשר לך

1040
00:51:32,550 --> 00:51:35,770
יש הזרם הזה של תקשורת
בין אינטרנט

1041
00:51:35,770 --> 00:51:39,430
דפדפן ושרת אינטרנט.

1042
00:51:39,430 --> 00:51:45,250
אז ברוב המקרים עד כה, שהיינו לנו
שני אלה מהירים מאוד אחד או שתיים

1043
00:51:45,250 --> 00:51:48,790
תקשורת שנייה בין אינטרנט
דפדפן לבין שרת האינטרנט.

1044
00:51:48,790 --> 00:51:53,310
אז זה בעצם ללכת ל-google.com, גט
הדברים, לשלוח אותו בחזרה, ולאחר מכן

1045
00:51:53,310 --> 00:51:53,770
אנחנו נעשו.

1046
00:51:53,770 --> 00:51:56,560
אנחנו אף פעם לא מדברים שוב עד
משתמש מקליד במשהו אחר.

1047
00:51:56,560 --> 00:52:01,090
>> אבל מה Socket.IO וסוג דומה של
דברים - וSocketIO הוא למעשה אחד

1048
00:52:01,090 --> 00:52:03,940
מהדברים שהבנויים על כ
WebSocket שהוא סוג של זמין

1049
00:52:03,940 --> 00:52:06,440
כחלק מHTML5 -

1050
00:52:06,440 --> 00:52:09,620
המאפשר לך יש את זה
דיאלוג מתמשך.

1051
00:52:09,620 --> 00:52:13,990
וזה מאוד שימושי בשרת צ'אט
סוג של דבר כי זה

1052
00:52:13,990 --> 00:52:17,390
כמו סוג של דיאלוג מתמשך ב
מובנים מסוימים, כי אם אתה משוחח

1053
00:52:17,390 --> 00:52:21,540
עם מישהו, עכשיו אתה יכול פשוט לשלוח
הודעה במורד הצינור, ולאחר מכן

1054
00:52:21,540 --> 00:52:23,940
שרת יכול לשלוח הודעה למטה
צינור לאדם האחר שאתה

1055
00:52:23,940 --> 00:52:24,520
משוחח עם.

1056
00:52:24,520 --> 00:52:26,903
ואז אתה יכול לקבל את זה
להחליף ככה.

1057
00:52:26,903 --> 00:52:30,590

1058
00:52:30,590 --> 00:52:32,850
>> אז זה סוג של מה
SocketIO הוא טוב.

1059
00:52:32,850 --> 00:52:38,400
הסיבה שSocketIO משתמש WebSockets
כדבר אחד הוא שב

1060
00:52:38,400 --> 00:52:43,980
בנוסף לWebSockets פשוט ישן,
זה גם עושה כמה טריקים כדי בעצם

1061
00:52:43,980 --> 00:52:45,610
להפוך את הדפדפן שלה תואם.

1062
00:52:45,610 --> 00:52:50,040
אז דפדפנים כמו Internet Explorer
למרבה הצער אינו תומך WebSockets

1063
00:52:50,040 --> 00:52:50,810
היישר מהקופסה.

1064
00:52:50,810 --> 00:52:55,290
אז הוא משתמש בסוג כלשהו של מגניב מסודר אחר
דברים עם Adobe Flash כדי לאפשר

1065
00:52:55,290 --> 00:52:57,170
שיהיה לך תמיכת דפדפנים.

1066
00:52:57,170 --> 00:52:58,800
אז זה באמת שימושי.

1067
00:52:58,800 --> 00:53:02,440
>> ובעצם, אני יודע שאני סוג של
פועל על זמן כאן, אבל CS50

1068
00:53:02,440 --> 00:53:08,490
דיון, האם אי פעם ראה משהו
כאילו, אני לא יודע, ריק הוא כך וכך

1069
00:53:08,490 --> 00:53:11,030
מענה להודעה או משהו זה
ככה, תכונה ש?

1070
00:53:11,030 --> 00:53:12,250
זה SocketIO.

1071
00:53:12,250 --> 00:53:15,580
לכן, כאשר מישהו מתחיל להקליד
תיבה לדון לעשות תשובה או

1072
00:53:15,580 --> 00:53:20,040
משהו, הדפדפן שלך אינו מה
קרא בSocketIO פולט איזה

1073
00:53:20,040 --> 00:53:22,660
אירוע שאומר למישהו זה
מענה להודעה זו.

1074
00:53:22,660 --> 00:53:26,110
>> ואז השרת אומר, אוקיי,
מה אני צריך לעשות?

1075
00:53:26,110 --> 00:53:29,270
ובכן עכשיו אני חייב לספר לי אלה החבר 'ה אחר
שנמצאים על CS50 דיון מחפש

1076
00:53:29,270 --> 00:53:31,170
בפוסט הזה שמישהו משיב.

1077
00:53:31,170 --> 00:53:34,190
אז זה סוג של מה הוא SocketIO
טוב ל, בהמשך מסוג זה

1078
00:53:34,190 --> 00:53:35,930
זרם של דיאלוג.

1079
00:53:35,930 --> 00:53:37,250
על אישור.

1080
00:53:37,250 --> 00:53:40,060
>> אז מה יש לי כאן - ואנחנו רק
הולך להתעלם ממערך קשרים

1081
00:53:40,060 --> 00:53:41,390
לקצת -

1082
00:53:41,390 --> 00:53:43,080
מה שאני עושה הוא שאני עוד אשמע.

1083
00:53:43,080 --> 00:53:46,880
אז זה בדיוק כמו בSocket.IO הוא
אומר בואו להאזין ביציאה זו.

1084
00:53:46,880 --> 00:53:50,060
ואז אני עושה את זה בחיבור.

1085
00:53:50,060 --> 00:53:53,360
אז זה רק בעצם Socket IO של
הדרך שלי לומר, כאשר אנו מקבלים

1086
00:53:53,360 --> 00:53:55,840
חיבור, אני רוצה אותך
כדי להפעיל את הקוד הזה.

1087
00:53:55,840 --> 00:53:59,870
>> ושים לב שבמקום שיש rec
ומיל עבר לשם יש לי שקע.

1088
00:53:59,870 --> 00:54:03,260
ורעיון Socket זו הוא בעצם זו
דבר שאתה יכול לכתוב ולקרוא

1089
00:54:03,260 --> 00:54:05,750
מזה יש למשתמש של
הודעות אולי.

1090
00:54:05,750 --> 00:54:10,700
וההודעות שאתה שולח
יכול לעבור Socket זה.

1091
00:54:10,700 --> 00:54:12,140
האם זה הגיוני?

1092
00:54:12,140 --> 00:54:14,490
אז זה דבר מתמשך זו.

1093
00:54:14,490 --> 00:54:17,820
>> אז מה שאני עושה זה אני קורא Socket.emit.

1094
00:54:17,820 --> 00:54:20,330
ופולטים לוקח די
הרבה שני טיעונים.

1095
00:54:20,330 --> 00:54:24,100
הטענה הראשונה היא מחרוזת
רק מייצג את הסוג של

1096
00:54:24,100 --> 00:54:25,270
דבר שאתה פולטת.

1097
00:54:25,270 --> 00:54:28,120
אז למקרה זה, יש לי שימוש
הודעה זו המחרוזת חדשה.

1098
00:54:28,120 --> 00:54:32,670
וזה רק אומר שבעצם
הסוג של הדבר הזה, מה אני

1099
00:54:32,670 --> 00:54:34,750
שליחה, היא הודעה חדשה.

1100
00:54:34,750 --> 00:54:38,460
כך שתוכל להאזין לסוגים מסוימים
כמו הודעה או מה שלא חדשים

1101
00:54:38,460 --> 00:54:39,960
על ידי שימוש בנקודה על.

1102
00:54:39,960 --> 00:54:44,570
>> אז חיבור למשתמש נשלחו לשם, אם
אתה מסתכל בו אנחנו קוראים לנקודה על,

1103
00:54:44,570 --> 00:54:48,150
אלה הם מחרוזות אחרות המייצגות
סוגי הודעות משתמש.

1104
00:54:48,150 --> 00:54:52,060
אז זה בעצם שאתה יכול להיות לפלוט זה
אחד מהסוגים אלה הודעה, ו

1105
00:54:52,060 --> 00:54:55,520
אז לעשות משהו בתגובה ל
אחד מסוגים אלה הודעה

1106
00:54:55,520 --> 00:54:57,640
>> אז אני פולטת הודעה חדשה.

1107
00:54:57,640 --> 00:55:00,540
אנחנו הולכים להתעלם connections.push
לשנייה אחת.

1108
00:55:00,540 --> 00:55:03,360
אבל אז אני אומר, משתמש Socket.on נשלח.

1109
00:55:03,360 --> 00:55:07,540
אז עכשיו זה סוג של כמו כאשר
משתמש שולח לי הודעה, אני רוצה

1110
00:55:07,540 --> 00:55:09,240
לך להפעיל את הקוד הזה.

1111
00:55:09,240 --> 00:55:12,080
ושים לב כי פונקציה אנונימית
הוא לוקח במשתנה זה

1112
00:55:12,080 --> 00:55:16,300
קרא נתונים אשר בעצם הולך
כדי שההודעה של המשתמש.

1113
00:55:16,300 --> 00:55:20,700
>> סוג אז עכשיו בואו לדבר על
מערך חיבורים.

1114
00:55:20,700 --> 00:55:24,590
אז זה מיועד ללקוח צ'אט
שבו בעצם כל סוג של ב

1115
00:55:24,590 --> 00:55:25,950
אותו חדר הצ'אט.

1116
00:55:25,950 --> 00:55:29,640
אז בעצם, מה שאנחנו צריכים לשמור על
סביב איזה מערך שבעצם

1117
00:55:29,640 --> 00:55:33,170
מייצג את כל האנשים מפטפטים ב
מבחינות מסוימות, אם זה נשמע הגיוני.

1118
00:55:33,170 --> 00:55:33,340
נכון?

1119
00:55:33,340 --> 00:55:37,190
כי אנחנו צריכים לדעת שחבר 'ה האלה
כל כך אנחנו יכולים לשלוח להם ההודעות

1120
00:55:37,190 --> 00:55:39,140
שאנשים אחרים שולחים לנו.

1121
00:55:39,140 --> 00:55:44,440
>> אז מה הקוד הזה עושה הוא כאשר משתמש
שולח מסר - זה הסוג של

1122
00:55:44,440 --> 00:55:45,300
האירוע -

1123
00:55:45,300 --> 00:55:47,120
אנחנו הולכים להפעיל את הקוד הזה.

1124
00:55:47,120 --> 00:55:51,240
ומה שאנחנו עושים הוא שאנחנו מריצים דרך זה
מערך שיש לנו בשם חיבורים.

1125
00:55:51,240 --> 00:55:54,390
ופחות או יותר לכל חיבור
פרט אחד שהוא שלנו, זה

1126
00:55:54,390 --> 00:55:59,520
מה הקוד הזה אומר, אנו שולחים חדשים
הודעה עם שהודעה המצורפת

1127
00:55:59,520 --> 00:56:01,210
מידע.

1128
00:56:01,210 --> 00:56:04,880
>> אז אם אתה שם לב לכאן, מה שעשיתי כש
המשתמש בעצם עושה חדש

1129
00:56:04,880 --> 00:56:08,560
חיבור הוא אני הוספתי עם
שיטת JavaScript.push, זה

1130
00:56:08,560 --> 00:56:12,100
בעצם רק אומר כמו להוסיף
Socket שכערך לתוך

1131
00:56:12,100 --> 00:56:13,900
מערך הקשרים שלנו.

1132
00:56:13,900 --> 00:56:20,560
אז עכשיו כאשר קוד זה פועל, זה יהיה
לשלוח דברים מסוימים אלה

1133
00:56:20,560 --> 00:56:22,020
חיבורים.

1134
00:56:22,020 --> 00:56:26,980
אז זו יכולה להיות נקודת התחלה טובה
להכנת שרת צ'אט

1135
00:56:26,980 --> 00:56:28,250
או משהו דומה.

1136
00:56:28,250 --> 00:56:33,315
>> ואת הסוג של דבר מגניב הוא ש
קוד שאתה רואה כאן, כמו וב

1137
00:56:33,315 --> 00:56:36,390
לפלוט ודברים כאלה הוא זהים
סוג של קוד JavaScript שהיית

1138
00:56:36,390 --> 00:56:39,260
לכתוב בדפדפן כדי אינטראקציה
עם השרת.

1139
00:56:39,260 --> 00:56:42,480
אז בגלל זה SocketIO הוא סוג של
מסודר ושימושי בדרך זו.

1140
00:56:42,480 --> 00:56:45,680

1141
00:56:45,680 --> 00:56:49,250
>> אה, ורק דבר אחד יותר מהיר אמיתי.

1142
00:56:49,250 --> 00:56:55,970
היה פרויקט גמר CS50 בשנה שעברה
כי בעצם מיושם צ'אט

1143
00:56:55,970 --> 00:56:57,840
שרת בNode.js.

1144
00:56:57,840 --> 00:57:01,350
אני חושב שזה Harvardchats.org
אבל אני לא -

1145
00:57:01,350 --> 00:57:02,940
על אישור.

1146
00:57:02,940 --> 00:57:06,190
אני לא בטוח מה היא כתובת האתר, אבל
אני יכול לשלוח את זה אחר כך.

1147
00:57:06,190 --> 00:57:09,260
אבל זה די מגניב מה
אתה יכול לעשות עם Node.js.

1148
00:57:09,260 --> 00:57:14,680
>> אז אני מקווה, באופן כללי, יש לך חבר 'ה
תחושה של מה Node.js שימושי טובה

1149
00:57:14,680 --> 00:57:17,870
ולאיך אולי אפשר להחיל
לפרויקט הגמר שלך.

1150
00:57:17,870 --> 00:57:21,050
אני יהיה לשלוח עוד קצת
משאבים יחד עם זה.

1151
00:57:21,050 --> 00:57:23,170
ותודה לך שבאת.

1152
00:57:23,170 --> 00:57:23,610
תודה.

1153
00:57:23,610 --> 00:57:27,168
>> [מחיאות כפות]