1
00:00:00,000 --> 00:00:12,610

2
00:00:12,610 --> 00:00:12,900
>> דוד י מלאן: בסדר.

3
00:00:12,900 --> 00:00:16,790
אז ברוכים הבאים לראשונים אי פעם
נתיחה שלאחר המוות CS50 לחידון.

4
00:00:16,790 --> 00:00:18,340
אנחנו חשבנו שנחנוך
מסורת זו שנה.

5
00:00:18,340 --> 00:00:20,960
וזו תהיה הזדמנות
ללכת דרך

6
00:00:20,960 --> 00:00:22,220
פתרונות לחידון.

7
00:00:22,220 --> 00:00:26,160
ואנחנו להאיץ או להאט מבוססים
בעניינם של אלה כאן.

8
00:00:26,160 --> 00:00:29,730
>> אז אתה כנראה כאן בגלל שאתה
מתעניייין איך אתה יכול להיות או

9
00:00:29,730 --> 00:00:31,170
צריך לענות כמה
הבעיות הללו.

10
00:00:31,170 --> 00:00:33,300
אז למה אנחנו לא נסתכל
בסעיף זה קודם?

11
00:00:33,300 --> 00:00:34,450
כך מקבל מחרוזות.

12
00:00:34,450 --> 00:00:37,600
זה נתן לך שלוש גרסאות שונות
של תכנית שהייתה, בסופו,

13
00:00:37,600 --> 00:00:39,650
אמור לקבל מחרוזת ממשתמש.

14
00:00:39,650 --> 00:00:42,530
אם זה עשה את זה היה
השאיר בך כדי לקבוע.

15
00:00:42,530 --> 00:00:45,150
>> ושאלנו בשאלה 0,
נניח שגרסה 1 היא

16
00:00:45,150 --> 00:00:46,400
לוקט והוצא להורג.

17
00:00:46,400 --> 00:00:48,860
מדוע עלולה התכנית segfault?

18
00:00:48,860 --> 00:00:51,150
במבט הראשון, כל הצעה
מדוע?

19
00:00:51,150 --> 00:00:54,012

20
00:00:54,012 --> 00:00:54,489
כן.

21
00:00:54,489 --> 00:00:59,260
>> קהל: אז אני זוכר שראיתי את זה ב
דוגמא קודמת של הסתכלות

22
00:00:59,260 --> 00:01:05,506
char * s ולראות את הסריקה של ים ו
רואה כי זה מצביע, איך

23
00:01:05,506 --> 00:01:07,971
עשית את זה ישפיע על מה שסרקת ב?

24
00:01:07,971 --> 00:01:10,940
האם זה זה או את הכתובת של ים?

25
00:01:10,940 --> 00:01:11,180
>> דוד י מלאן: אישור.

26
00:01:11,180 --> 00:01:11,480
טוב.

27
00:01:11,480 --> 00:01:14,830
אז סופו של דבר, המקור לכל בעיה
הולך ככל הנראה כדי להפחית

28
00:01:14,830 --> 00:01:16,210
כדי שזה משתנה.

29
00:01:16,210 --> 00:01:17,280
וזה אכן משתנה.

30
00:01:17,280 --> 00:01:19,900
סוג הנתונים של משתנה שהוא
char *, מה שאומר שזה הולך

31
00:01:19,900 --> 00:01:22,570
מכיל את הכתובת של אופי.

32
00:01:22,570 --> 00:01:23,850
וכאן טמונה תובנה.

33
00:01:23,850 --> 00:01:28,330
זה הולך להכיל את הכתובת של
תו או, באופן כללי יותר,

34
00:01:28,330 --> 00:01:32,110
כתובת של התו הראשון ב
בלוק שלם של דמויות.

35
00:01:32,110 --> 00:01:36,680
>> אבל לתפוס את זה כי זה סריקה, מטרה ב
חיים, הוא נתון כתובת ונתנו

36
00:01:36,680 --> 00:01:40,960
קוד עיצוב, כמו% s, לקרוא
מחרוזת לנתח של

37
00:01:40,960 --> 00:01:42,330
זיכרון בכתובת הזאת.

38
00:01:42,330 --> 00:01:46,040
אבל בגלל שאין סימן שוויון לפני
פסיק שעל הראשון

39
00:01:46,040 --> 00:01:49,310
שורת קוד, כי אנחנו לא ממש
להקצות כל זיכרון עם

40
00:01:49,310 --> 00:01:53,020
malloc, כי זה לא ממש
להקצות מערך של כמה גודל, כל

41
00:01:53,020 --> 00:01:57,620
אתה עושה קורא למשתמש של
קלט מקלדת לכמה מלא

42
00:01:57,620 --> 00:02:00,490
ערך אשפה, אשר
הוא בים כברירת מחדל.

43
00:02:00,490 --> 00:02:04,480
אז הסיכויים שאתה הולך segfault אם
הכתובת שאינה פשוט כל כך יקרו

44
00:02:04,480 --> 00:02:08,009
להיות ערך שאתה יכול,
למעשה, לכתוב.

45
00:02:08,009 --> 00:02:10,889
כל כך רע שלא להקצות
הזיכרון שלך שם.

46
00:02:10,889 --> 00:02:13,150
>> אז בשאלה 1, שאלנו,
נניח שגרסה 2 היא

47
00:02:13,150 --> 00:02:14,230
לוקט והוצא להורג.

48
00:02:14,230 --> 00:02:15,900
מדוע עלולה תכנית זו segfault?

49
00:02:15,900 --> 00:02:17,990
אז זה אחד הוא פחות מרכבה.

50
00:02:17,990 --> 00:02:21,470
ויש באמת רק אחד
דרך ברורה שבו אתה יכול

51
00:02:21,470 --> 00:02:22,810
לעורר segfault כאן.

52
00:02:22,810 --> 00:02:23,730
וזה נושאיות.

53
00:02:23,730 --> 00:02:28,180
בכל פעם שאנחנו משתמשים בג בזיכרון, מה
אתה יכול לעשות כדי לגרום לsegfault

54
00:02:28,180 --> 00:02:30,718
עם גרסה 2?

55
00:02:30,718 --> 00:02:35,560
>> קהל: אם אתה משתמש בקלט שב
מחרוזת זה זמן רב יותר מאשר 49

56
00:02:35,560 --> 00:02:35,975
תווים.

57
00:02:35,975 --> 00:02:37,260
>> דוד י מלאן: בדיוק.

58
00:02:37,260 --> 00:02:41,420
בכל פעם שאתה רואה משהו באורך קבוע
כאשר מדובר במערך,

59
00:02:41,420 --> 00:02:44,650
מכ"ם צריך ללכת כי זה יכול להיות
בעייתי אם אתה לא בודק

60
00:02:44,650 --> 00:02:45,810
גבולות של מערך.

61
00:02:45,810 --> 00:02:46,650
וזו הבעיה כאן.

62
00:02:46,650 --> 00:02:47,910
אנחנו עדיין באמצעות scanf.

63
00:02:47,910 --> 00:02:52,200
אנחנו עדיין משתמשים ב% s, מה שאומר שינסה
לקרוא מחרוזת מהמשתמש.

64
00:02:52,200 --> 00:02:56,300
זה הולך לקרוא לתוך ים, אשר,
בשלב זה, הוא ביעילות

65
00:02:56,300 --> 00:02:58,570
כתובת של נתח של זיכרון
או שזה שווה ערך.

66
00:02:58,570 --> 00:03:02,080
זה שמו של מערך
תווים של זיכרון.

67
00:03:02,080 --> 00:03:07,610
>> אבל בדיוק את זה, אם אתה קורא את מחרוזת
זה זמן רב יותר מאשר 49 תווים, 49

68
00:03:07,610 --> 00:03:10,440
כי אתה צריך מקום לקו הנטוי
0, אתה הולך לעלות על גדותיו

69
00:03:10,440 --> 00:03:11,390
מאגר זה.

70
00:03:11,390 --> 00:03:16,410
ואתה עלול לקבל מזל להיות מסוגלים
לכתוב אופי 51st, 52nd, 53rd.

71
00:03:16,410 --> 00:03:18,560
אבל בשלב מסוים, מערכת ההפעלה
הוא הולך להגיד, לא.

72
00:03:18,560 --> 00:03:21,270
זה בהחלט לא זיכרון
מותר לך לגעת.

73
00:03:21,270 --> 00:03:23,380
והתכנית הולכת segfault.

74
00:03:23,380 --> 00:03:26,650
>> אז הנה, היוריסטיות צריך להיות כל
זמן שיש לך באורך קבוע, יש לך

75
00:03:26,650 --> 00:03:30,150
כדי לוודא שאתה בודק את האורך
של מה שזה לא אתה מנסה

76
00:03:30,150 --> 00:03:31,090
לקרוא לזה.

77
00:03:31,090 --> 00:03:35,110
>> קהל: אז כדי לפתור את זה, אתה יכול
יש לו הצהרת בדיקה בפועל

78
00:03:35,110 --> 00:03:37,140
הוא גדול יותר באורך
יותר או קטן יותר?

79
00:03:37,140 --> 00:03:37,730
>> דוד י מלאן: בהחלט.

80
00:03:37,730 --> 00:03:41,706
פשוט יש לך מצב
שאומר, אם -

81
00:03:41,706 --> 00:03:46,080
או ליתר דיוק, אתה לא בהכרח יודע
מראש כמה תווים

82
00:03:46,080 --> 00:03:49,060
משתמש הוא הולך להקליד, כי
יש לך ביצה ותרנגולת.

83
00:03:49,060 --> 00:03:51,860
לא, עד שקראת אותו עם scanf
אתה יכול להבין כמה זמן זה.

84
00:03:51,860 --> 00:03:54,500
אבל בשלב זה, זה כבר מאוחר מדי,
משום שאתה כבר לקרוא אותו לתוך

85
00:03:54,500 --> 00:03:55,710
כמה בלוק של זיכרון.

86
00:03:55,710 --> 00:03:59,590
אז כמו בצד, נמנע ספריית CS50
הנושא הזה לגמרי, זוכר

87
00:03:59,590 --> 00:04:01,060
באמצעות fgetc.

88
00:04:01,060 --> 00:04:05,390
והוא קורא תו אחד בכל פעם,
יחד, בידיעה toeing עצה שאתה

89
00:04:05,390 --> 00:04:08,060
לא יכול לעלות על גדות דמות אם
אתה קורא אחד בכל פעם.

90
00:04:08,060 --> 00:04:11,580
>> המלכוד הוא בהחזרת getstring הוא
שיש לנו לכל הזמן מחדש את גודל

91
00:04:11,580 --> 00:04:13,590
נתח זה של זיכרון, אשר
רק כאב.

92
00:04:13,590 --> 00:04:15,310
זה הרבה שורות
קוד כדי לעשות את זה.

93
00:04:15,310 --> 00:04:18,779
אז גישה אחרת תהיה
בעצם להשתמש בן דוד, ולכן

94
00:04:18,779 --> 00:04:19,790
לדבר, של scanf.

95
00:04:19,790 --> 00:04:22,820
ישנן גרסאות של הרבה מאלה
פונקציות שלמעשה לבדוק את

96
00:04:22,820 --> 00:04:25,870
אורך של כמה תווים
אתה יכול לקרוא באופן מקסימאלי.

97
00:04:25,870 --> 00:04:29,430
ואתה יכול לפרט, לא קורא
יותר מ 50 תווים.

98
00:04:29,430 --> 00:04:34,110
כך שיהיה גישה אחרת אבל
פחות אדיב של תשומות גדולות יותר.

99
00:04:34,110 --> 00:04:37,040
>> אז שאלה של 2 שואל, נניח שגרסה כי
3 נערך והוצאו להורג.

100
00:04:37,040 --> 00:04:39,960
מדוע ייתכן שתכנית segfault?

101
00:04:39,960 --> 00:04:42,650
אז זה בעצם אותו הדבר
תענה, למרות שזה

102
00:04:42,650 --> 00:04:43,590
נראה קצת להשתכלל.

103
00:04:43,590 --> 00:04:46,440
אנחנו משתמשים malloc, שמרגיש כמו
אנחנו נותנים את עצמנו יותר אפשרויות.

104
00:04:46,440 --> 00:04:48,030
ואז אנחנו משחררים כי
זיכרון בסוף.

105
00:04:48,030 --> 00:04:49,580
זה עדיין רק 50 בתים של זיכרון.

106
00:04:49,580 --> 00:04:53,620
אז אנחנו אולי עדיין מנסים לקרוא
ב51, 52, 1,000 בתים.

107
00:04:53,620 --> 00:04:55,830
זה הולך לsegfault
בדיוק מאותה הסיבה.

108
00:04:55,830 --> 00:04:57,530
>> אבל יש סיבה נוספת.

109
00:04:57,530 --> 00:05:03,890
מה עוד יכל malloc תמורה מלבד
הכתובת של נתח של זיכרון?

110
00:05:03,890 --> 00:05:04,920
זה יכול להחזיר null.

111
00:05:04,920 --> 00:05:07,560
וכי אנחנו לא בודקים
כך, אנו יכולים לעשות משהו

112
00:05:07,560 --> 00:05:11,350
טיפשי מסיבה אחרת, והיא ש
אנחנו אולי אומרים scanf, לקרוא

113
00:05:11,350 --> 00:05:16,050
הקלט של המשתמש מהמקלדת
ל0 מיקום, null AKA.

114
00:05:16,050 --> 00:05:18,890
וגם את זה, בהחלט
לעורר segfault.

115
00:05:18,890 --> 00:05:21,590
אז למטרה של החידון, הייתי עושה זאת
קיבל אחד מאלו כ

116
00:05:21,590 --> 00:05:22,740
סיבה חוקית.

117
00:05:22,740 --> 00:05:23,420
אחד מהם הוא זהה.

118
00:05:23,420 --> 00:05:25,720
אחד הוא קצת יותר מורכב.

119
00:05:25,720 --> 00:05:28,975
>> לבסוף, ביחס לתכנית של
שימוש בזיכרון, איך גרסה 2 ו

120
00:05:28,975 --> 00:05:30,350
גרסה 3 שונה?

121
00:05:30,350 --> 00:05:35,070
אז בשביל מה זה שווה, ראינו
אינסופית האספקה ​​אפשרית

122
00:05:35,070 --> 00:05:35,770
תשובות לזה.

123
00:05:35,770 --> 00:05:39,300
ובין תשובותיהם של אנשים, מה שהיינו
מקווה, אבל אנחנו קיבלנו אחרים

124
00:05:39,300 --> 00:05:42,250
דברים, היה אזכור כלשהו של
עובדה שהגרסה 2 היא באמצעות

125
00:05:42,250 --> 00:05:44,560
הערימה מה שנקרא.

126
00:05:44,560 --> 00:05:46,710
גרסה 3 היא שימוש בערימה.

127
00:05:46,710 --> 00:05:50,060
ופונקציונלי, זה לא ממש
לעשות את כל שהרבה הבדל.

128
00:05:50,060 --> 00:05:54,040
בסופו של היום, אנחנו עדיין
פשוט מקבל 50 בתים של זיכרון.

129
00:05:54,040 --> 00:05:56,640
>> אבל זה היה אחד מהתשובות אפשרי
שאנחנו מסתכלים.

130
00:05:56,640 --> 00:05:59,730
אבל תראה, כפי שאתה מקבל חידונים שלך
חזרה מTFS, שעשינו

131
00:05:59,730 --> 00:06:04,330
קיבל דיונים אחרים שלהם
כמו גם שימושים שונים של זיכרון.

132
00:06:04,330 --> 00:06:08,600
אבל מחסנית והערימה הייתה
תשובה קלה ללכת עם.

133
00:06:08,600 --> 00:06:11,150
כל שאלה?

134
00:06:11,150 --> 00:06:12,400
אני נותן לך רוב.

135
00:06:12,400 --> 00:06:18,360

136
00:06:18,360 --> 00:06:20,210
>> ROB אודן: אז בעיה 4.

137
00:06:20,210 --> 00:06:21,985
זהו אחד שבו אתה צריך למלא
במספר הבתים שמתוך כל

138
00:06:21,985 --> 00:06:23,460
אלה סוגים שונים בשימוש.

139
00:06:23,460 --> 00:06:24,830
דבר אז קודם כל שאנחנו רואים.

140
00:06:24,830 --> 00:06:27,930
תניח ארכיטקטורה 32 סיביות,
כמו מכשיר CS50 זה.

141
00:06:27,930 --> 00:06:33,530
אז אחד הדברים הבסיסיים על
ארכיטקטורות 32 סיביות, שאומר לנו

142
00:06:33,530 --> 00:06:37,490
בדיוק עד כמה גדול מצביע הולך
להיות באדריכלות.

143
00:06:37,490 --> 00:06:43,020
>> אז באופן מיידי, אנחנו יודעים שכל מצביע
הסוג הוא 32 סיביות או 4 בתים.

144
00:06:43,020 --> 00:06:46,010
אז מסתכל על טבלה זו,
* צומת הוא סוג מצביע.

145
00:06:46,010 --> 00:06:47,250
זה הולך להיות 4 בתים.

146
00:06:47,250 --> 00:06:51,640
* צומת struct, זה פשוטו כמשמעו
זהה לכוכב צומת.

147
00:06:51,640 --> 00:06:53,590
וכך זה הולך להיות 4 בתים.

148
00:06:53,590 --> 00:06:58,270
מחרוזת, כך שזה לא נראה כמו
מצביע עדיין, אבל typedef,

149
00:06:58,270 --> 00:07:01,590
מחרוזת היא פשוט * char, אשר
הוא סוג מצביע.

150
00:07:01,590 --> 00:07:03,550
אז זה הולך להיות 4 בתים.

151
00:07:03,550 --> 00:07:06,150
>> אז שלושה אלה הם כל 4 הבתים.

152
00:07:06,150 --> 00:07:09,350
עכשיו, צומת ותלמיד הם
קצת יותר מסובך.

153
00:07:09,350 --> 00:07:15,160
אז מסתכלים על צומת וסטודנט, אנו רואים
צומת כשלמה ומצביע.

154
00:07:15,160 --> 00:07:18,050
ותלמיד הוא שני מצביעים
בתוכו.

155
00:07:18,050 --> 00:07:23,340
אז לפחות במקרה שלנו כאן, הדרך
שאנחנו בסופו של חישוב הגודל של

156
00:07:23,340 --> 00:07:27,020
struct זה רק להוסיף את הכל
זה בתוך struct.

157
00:07:27,020 --> 00:07:30,690
>> אז לצומת, יש לנו מספר שלם,
אשר הוא 4 בתים.

158
00:07:30,690 --> 00:07:32,830
יש לנו מצביע, שהוא 4 בתים.

159
00:07:32,830 --> 00:07:35,820
וכך צומת אחד לא הולכת
לקחת את 8 בתים.

160
00:07:35,820 --> 00:07:39,490
ובאופן דומה לסטודנט, יש לנו
מצביע זה 4 בתים ועוד

161
00:07:39,490 --> 00:07:40,770
מצביע זה 4 בתים.

162
00:07:40,770 --> 00:07:43,180
אז זה הולך בסופו של
דבר להיות 8 בתים.

163
00:07:43,180 --> 00:07:45,480
אז צומת ותלמיד הם 8 בתים.

164
00:07:45,480 --> 00:07:48,950
ושלושה אלה הם כל 4 הבתים.

165
00:07:48,950 --> 00:07:50,240
שאלות על זה?

166
00:07:50,240 --> 00:07:54,640

167
00:07:54,640 --> 00:07:54,990
כן.

168
00:07:54,990 --> 00:07:58,413
>> קהל: האם זה היה 64 סיביות
אדריכלות, היית כי

169
00:07:58,413 --> 00:07:59,880
תכפיל את כולם?

170
00:07:59,880 --> 00:08:01,790
>> ROB אודן: זה לא היית
תכפיל את כולם.

171
00:08:01,790 --> 00:08:05,830
אז ארכיטקטורת 64 קצת, זה, שוב,
שינויים שדבר בסיסי ש

172
00:08:05,830 --> 00:08:08,910
המצביע הוא החברה 64 סיביות.

173
00:08:08,910 --> 00:08:09,290
כן.

174
00:08:09,290 --> 00:08:10,930
אז מצביע הוא 8 בתים.

175
00:08:10,930 --> 00:08:15,420
אז אלה שהיו 4 בתים
הולכים להיות 8 בתים.

176
00:08:15,420 --> 00:08:18,617
תלמיד, שהיה שני מצביעים,
טוב, עכשיו זה הולך

177
00:08:18,617 --> 00:08:19,800
יהיה 8 בתים, 8 בתים.

178
00:08:19,800 --> 00:08:21,980
זה הולך להפוך את 16 בתים.

179
00:08:21,980 --> 00:08:25,710
>> אבל צומת היא עדיין 4 בתים.

180
00:08:25,710 --> 00:08:27,800
אז מצביע זה הולך
להיות 8 בתים.

181
00:08:27,800 --> 00:08:28,930
זה הוא 4 בתים.

182
00:08:28,930 --> 00:08:30,870
אז צומת היא רק הולכת
להיות 12 בתים.

183
00:08:30,870 --> 00:08:36,309

184
00:08:36,309 --> 00:08:39,280
יש עוד שאלות על זה?

185
00:08:39,280 --> 00:08:44,500
אז הבא בתור, אלה הם
קודי מצב HTTP.

186
00:08:44,500 --> 00:08:48,000
ואתה היית צריך לתאר את הנסיבות
תחת אשר עשויים אלה

187
00:08:48,000 --> 00:08:49,810
יוחזר לכם.

188
00:08:49,810 --> 00:08:56,730
בעיה אחת ששמעתי חלק מתלמידים
יש לי הוא שהם ניסו לעשות

189
00:08:56,730 --> 00:08:58,950
שגיאות תהיה בסופו של דבר הלקוח.

190
00:08:58,950 --> 00:09:02,320
לכן, כאשר אנחנו מנסים לעשות את הבקשה
לשרת, משהו הולך

191
00:09:02,320 --> 00:09:03,820
הלא נכון בצד שלנו.

192
00:09:03,820 --> 00:09:07,660
אבל בדרך כלל, את הקודים הללו הם
מוחזר על ידי השרת.

193
00:09:07,660 --> 00:09:11,720
אז אנחנו רוצים להבין מה קורה
בסדר או לא בסדר בשרת ש

194
00:09:11,720 --> 00:09:14,280
גורם ליוחזרו הדברים האלה.

195
00:09:14,280 --> 00:09:18,670
אז למה שאולי שרת מחזיר
קוד מצב 200?

196
00:09:18,670 --> 00:09:19,920
כל מחשבות?

197
00:09:19,920 --> 00:09:23,360

198
00:09:23,360 --> 00:09:23,730
>> כן.

199
00:09:23,730 --> 00:09:27,850
אז משהו על הצלחה
הבקשה עברה.

200
00:09:27,850 --> 00:09:30,260
והם יוכלו לחזור
כל מה שביקשת.

201
00:09:30,260 --> 00:09:32,240
אז הכל היה בסדר.

202
00:09:32,240 --> 00:09:35,662
מה לגבי 302 מצא?

203
00:09:35,662 --> 00:09:36,618
כן.

204
00:09:36,618 --> 00:09:39,008
>> קהל: השרת חיפש
עבור מה שביקשת.

205
00:09:39,008 --> 00:09:40,442
אבל זה לא הצליח למצוא אותו.

206
00:09:40,442 --> 00:09:42,850
אז יש שגיאה.

207
00:09:42,850 --> 00:09:47,720
>> ROB אודן: אז השרת היה
מחפש את מה שאתה רוצה.

208
00:09:47,720 --> 00:09:51,682
אז פשוט מחפש כאן, 302 מצאו,
זה היה יכול למצוא אותו.

209
00:09:51,682 --> 00:09:53,035
>> קהל: אני מצטער.

210
00:09:53,035 --> 00:09:54,388
נמצא אומר שהם לא מוצאים אותו.

211
00:09:54,388 --> 00:09:55,638
סליחה.

212
00:09:55,638 --> 00:09:58,120

213
00:09:58,120 --> 00:10:00,160
>> ROB אודן: אז 302 נמצא.

214
00:10:00,160 --> 00:10:02,350
השרת הוא מסוגל למצוא
מה שרצית.

215
00:10:02,350 --> 00:10:04,640
>> קהל: אבל זה לא להציג אותה?

216
00:10:04,640 --> 00:10:08,180
>> ROB אודן: ההבדל בין
זה 302 ו200 הוא שזה

217
00:10:08,180 --> 00:10:09,280
יודע מה אתה רוצה.

218
00:10:09,280 --> 00:10:12,000
אבל זה לא בדיוק שבו
שרצית לשאול.

219
00:10:12,000 --> 00:10:14,580
אז 302 היא הפניה טיפוסית.

220
00:10:14,580 --> 00:10:16,510
אז שביקשת דף.

221
00:10:16,510 --> 00:10:19,590
היא יודעת, הו, אני רוצה
כדי להחזיר לך את זה.

222
00:10:19,590 --> 00:10:21,070
אבל זה בכתובת שונה.

223
00:10:21,070 --> 00:10:23,534
אז היי, אתה באמת רוצה את זה.

224
00:10:23,534 --> 00:10:26,950
>> דוד י מלאן: זו חתיכה שאמרו
שנתנו לך החבר 'ה הפניה

225
00:10:26,950 --> 00:10:30,830
פונקציה שהשתמשה בפונקצית הכותרת
זה, בתורו, הדפיס את מיקום,

226
00:10:30,830 --> 00:10:34,110
מעי גס, ולאחר מכן את כתובת האתר שאליו
אתה רוצה לדחות את המשתמש.

227
00:10:34,110 --> 00:10:37,480
למרות שאתה לא רואה 302
באופן מפורש שיש, זה מה שPHP

228
00:10:37,480 --> 00:10:41,550
באורח פלא הייתי להכניס ככותרת
אומר בדיוק את מה שרוב אמר שיש -

229
00:10:41,550 --> 00:10:41,930
נמצא.

230
00:10:41,930 --> 00:10:43,180
אבל ללכת כאן במקום.

231
00:10:43,180 --> 00:10:45,960

232
00:10:45,960 --> 00:10:46,160
>> ROB אודן: אישור.

233
00:10:46,160 --> 00:10:47,630
אז מה לגבי 403 אסורים?

234
00:10:47,630 --> 00:10:52,240

235
00:10:52,240 --> 00:10:57,120
>> קהל: אני חושב שזה שהשרת
הוא בעצם אומר שהלקוח

236
00:10:57,120 --> 00:10:59,970
לא יכול לגשת לדף הבית.

237
00:10:59,970 --> 00:11:03,260
>> ROB אודן: אז כן.

238
00:11:03,260 --> 00:11:07,670
ובכן, התשובה הטיפוסית שהיינו
מצפה הוא משהו כמו, הקבצים

239
00:11:07,670 --> 00:11:08,920
לא chmodded כראוי.

240
00:11:08,920 --> 00:11:11,590
זה כנראה באילו נסיבות
אתה ראית אותם.

241
00:11:11,590 --> 00:11:18,920
אבל יש סיבה לכך שהלקוח
יכול להיות אשם כאן.

242
00:11:18,920 --> 00:11:20,440
אין למעשה קוד מצב אחר -

243
00:11:20,440 --> 00:11:21,210
401.

244
00:11:21,210 --> 00:11:22,820
אז אלה הם דומים מאוד.

245
00:11:22,820 --> 00:11:24,590
>> 401 הוא לא מורשה.

246
00:11:24,590 --> 00:11:26,130
ו403 אסורים.

247
00:11:26,130 --> 00:11:31,890
וכל כך בלתי המורשה באופן בלעדי
מקבל אם אתה לא מחובר למערכת

248
00:11:31,890 --> 00:11:34,520
אבל כניסה אולי זה אומרת
שהנכם מורשים.

249
00:11:34,520 --> 00:11:37,930
אבל אם אתה כבר מחובר ולך
עדיין אין להם הרשאה, ולאחר מכן

250
00:11:37,930 --> 00:11:40,140
גם אתה יכול לקבל אסור.

251
00:11:40,140 --> 00:11:45,320
אז אם אתה מחובר למערכת ואין לי
רשות, אסור גם

252
00:11:45,320 --> 00:11:47,164
משהו שאתה יכול לקבל.

253
00:11:47,164 --> 00:11:48,900
>> דוד י מלאן: ואת המנגנון שבאמצעות
שבעיות אלה הן בדרך כלל

254
00:11:48,900 --> 00:11:53,100
פתר בשרת הוא
באמצעות מה הפקודה?

255
00:11:53,100 --> 00:11:57,700
Chmod, אם זה, אכן, הרשאות
להנפיק בקובץ או ספרייה.

256
00:11:57,700 --> 00:11:59,220
>> ROB אודן: אז 404 לא נמצא.

257
00:11:59,220 --> 00:12:03,100

258
00:12:03,100 --> 00:12:03,470
כן.

259
00:12:03,470 --> 00:12:10,150
אז בניגוד ל302 שבו לא היה זה בדיוק
שבו אתה שואל, אבל היא יודעת מה

260
00:12:10,150 --> 00:12:12,710
אתה רוצה, זה, זה פשוט
אין לי מושג מה אתה רוצה.

261
00:12:12,710 --> 00:12:15,648
ואתה לא מבקש
משהו בתוקף.

262
00:12:15,648 --> 00:12:18,580

263
00:12:18,580 --> 00:12:22,310
418 אני קומקום ולאחר מכן
500 שרת פנימי.

264
00:12:22,310 --> 00:12:24,870
אז למה אתה יכול לקבל את זה?

265
00:12:24,870 --> 00:12:26,120
>> אז segfault -

266
00:12:26,120 --> 00:12:28,760

267
00:12:28,760 --> 00:12:30,640
אני באמת לא יודע לדירוג
תקן לזה.

268
00:12:30,640 --> 00:12:34,850
אבל אם קוד PHP שלך היה משהו
טעיתי בזה, בתאוריה, זה יכול

269
00:12:34,850 --> 00:12:39,650
למעשה segfault, ובמקרה זה, זה
500 שגיאת השרת הפנימי, משהו

270
00:12:39,650 --> 00:12:41,400
לא בסדר עם השרת שלך
תצורה.

271
00:12:41,400 --> 00:12:44,320
או שיש שגיאת תחביר
בקוד PHP שלך.

272
00:12:44,320 --> 00:12:46,095
או שמשהו רע קורה.

273
00:12:46,095 --> 00:12:48,320
>> דוד י מלאן: אנחנו לא רואים segfault
בין התשובות כמה של אנשים.

274
00:12:48,320 --> 00:12:49,490
מבחינה טכנית, זה יכול לקרות.

275
00:12:49,490 --> 00:12:53,820
אבל זה יהיה PHP, התכנית
נכתב על ידי אנשים אחרים, בעצם

276
00:12:53,820 --> 00:12:57,790
segfaulted, שרק אם האנשים האלה
פישלתי וכתב קוד מרכבה ב

277
00:12:57,790 --> 00:13:00,680
המתורגמן שלהם היית
PHP עצמו segfault.

278
00:13:00,680 --> 00:13:06,460
אז למרות ש500 הוא כמו segfault
ברוח, זה כמעט תמיד

279
00:13:06,460 --> 00:13:10,490
תוצאה של בעיה קובץ תצורה
עם שרת האינטרנט שלך, או כפי שאמר רוב,

280
00:13:10,490 --> 00:13:13,200
שגיאת תחביר, כמוך
לא לסגור את ציטוט.

281
00:13:13,200 --> 00:13:16,180
או שאתה איבדת את פסיק במקום כלשהו.

282
00:13:16,180 --> 00:13:23,677
>> קהל: אז לpset הסעות, אני
חושב שכשאני עשיתי את זה פעם אחת לחצתי

283
00:13:23,677 --> 00:13:26,300
דפדפן, אבל שום דבר לא עלה,
מה שהם כינו דף לבן.

284
00:13:26,300 --> 00:13:28,056
אבל זה היה בגלל הקוד.

285
00:13:28,056 --> 00:13:29,440
אני חושב שזה היה JavaScript, נכון?

286
00:13:29,440 --> 00:13:29,770
>> ROB אודן: כן.

287
00:13:29,770 --> 00:13:31,180
>> קהל: האם שגיאה
עדיין לבוא?

288
00:13:31,180 --> 00:13:34,290
>> ROB אודן: אז אתה לא הייתי מקבל
טעות זו, כי הכל

289
00:13:34,290 --> 00:13:36,930
מנקודת המבט של שרת האינטרנט
היה בסדר לחלוטין.

290
00:13:36,930 --> 00:13:39,090
אבל אתה ביקשת index.html.

291
00:13:39,090 --> 00:13:42,000
שביקשת shuttle.js
וservice.js.

292
00:13:42,000 --> 00:13:44,580
וזה היה מסוגל לחזור בהצלחה
לכל הדברים האלה שאתה -

293
00:13:44,580 --> 00:13:44,980
200.

294
00:13:44,980 --> 00:13:45,680
על אישור.

295
00:13:45,680 --> 00:13:49,330
זה רק כאשר הדפדפן שלך ניסה
לפרש את קוד JavaScript כי

296
00:13:49,330 --> 00:13:51,370
זה כמו, הרגע, זה לא
שגיאת JavaScript בתוקף.

297
00:13:51,370 --> 00:13:55,720

298
00:13:55,720 --> 00:13:58,210
יש עוד שאלות?

299
00:13:58,210 --> 00:14:00,750
בסדר.

300
00:14:00,750 --> 00:14:04,120
>> דוד י מלאן: אז הבא
עד היה מספר 11.

301
00:14:04,120 --> 00:14:07,610
ו11 היו הכי מפחידים
להרבה אנשים.

302
00:14:07,610 --> 00:14:14,620

303
00:14:14,620 --> 00:14:18,570
לכן הדבר החשוב ביותר לציין כאן
היה שזה היה, אכן, על

304
00:14:18,570 --> 00:14:19,840
רשימה מקושרת כפליים.

305
00:14:19,840 --> 00:14:23,160
אבל זה לא היה אותו הדבר כמו בשנה שעברה
בעיה הרשימה מקושרת כפליים,

306
00:14:23,160 --> 00:14:27,170
שלא אתן לך האזהרה כי
הרשימה יכולה, למעשה, להיות לא ממוינת.

307
00:14:27,170 --> 00:14:29,640
>> אז העובדה שהרשימה הייתה ממוינת
והעובדה שהמילה שהייתה

308
00:14:29,640 --> 00:14:32,930
הדגיש שם היה אמור להעביר
שזה בעצם פישוט

309
00:14:32,930 --> 00:14:35,430
ממה שאחרת היה
בעיה מאתגרת יותר

310
00:14:35,430 --> 00:14:36,600
ועוד אחד.

311
00:14:36,600 --> 00:14:40,760
אז טעות נפוצה כאן הייתה אמורה לשים
הפתרון של השנה שעברה באחד שלך

312
00:14:40,760 --> 00:14:45,580
הביפר ולאחר מכן רק בעיוורון להעתיק כי
למטה כמו התשובה, שהוא הזכות

313
00:14:45,580 --> 00:14:48,520
תשובה לשאלה אחרת
דומה ברוחן.

314
00:14:48,520 --> 00:14:51,340
אבל הדקויות כאן
היו כדלקמן.

315
00:14:51,340 --> 00:14:55,200
>> אז אחד, יש לנו צומת הוכרזה ו
מוגדר בדרך הרגילה כאן.

316
00:14:55,200 --> 00:14:59,230
לאחר מכן הגדרנו רשימה של להיות גלובלית
מצביע מאותחל ל NULL.

317
00:14:59,230 --> 00:15:02,150
ואז, ככל הנראה, יש שתי פונקציות
יש לנו אב טיפוס לכאן, להוסיף

318
00:15:02,150 --> 00:15:03,240
ולהסיר.

319
00:15:03,240 --> 00:15:06,600
ולאחר מכן יש לנו כמה דוגמאות קוד כאן
לעשות חבורה של הוספות.

320
00:15:06,600 --> 00:15:09,930
ואז אנחנו מבקשים ממך להשלים את
יישום של הכנס להלן בכזה

321
00:15:09,930 --> 00:15:14,380
אופן שבו מוסיף n לרשימה
בזמן קבוע, גם בקו תחתון,

322
00:15:14,380 --> 00:15:15,730
גם אם כבר בהווה.

323
00:15:15,730 --> 00:15:20,600
>> אז היופי של להיות מסוגל להכניס
בזמן קבוע הוא שזה מרמז

324
00:15:20,600 --> 00:15:23,060
כי אתה צריך להכניס
צומת החדש שבו?

325
00:15:23,060 --> 00:15:23,690
לחזית.

326
00:15:23,690 --> 00:15:27,760
אז זה מבטל, תודה לאל, לפחות
אחד המקרים שמשמשים לדורשים

327
00:15:27,760 --> 00:15:30,520
אפילו יותר שורות קוד, כמו שהוא עשו
בשנה שעברה ואפילו בכיתה כאשר אנו

328
00:15:30,520 --> 00:15:34,040
דיבר דרך דברים מסוג זה
עם בני אדם ועם כמה

329
00:15:34,040 --> 00:15:35,250
קוד פסאודו מילולי.

330
00:15:35,250 --> 00:15:39,190
אז בפתרון כאן, בואו נדלג על
לזה, רק כדי להיות בחזותי

331
00:15:39,190 --> 00:15:40,480
המסך.

332
00:15:40,480 --> 00:15:42,230
>> שים לב שאנחנו עושים את הדברים הבאים.

333
00:15:42,230 --> 00:15:45,140
וגם שם לב לפישוט האחר
היה שגם אם זה

334
00:15:45,140 --> 00:15:48,280
כבר בהווה, ולכן זה אומר שגם אם
המספר הוא כבר שם, אתה יכול

335
00:15:48,280 --> 00:15:50,280
רק בעיוורון להכניס עוד
עותק שלה.

336
00:15:50,280 --> 00:15:52,560
וגם את זה, היה אמור להיות
פישוט, כך שאתה יכול

337
00:15:52,560 --> 00:15:54,940
להתמקד, באמת, חלק מיותר
חלק ומעניין מבחינה אינטלקטואלית

338
00:15:54,940 --> 00:15:58,090
לא רק איזו שגיאה נוספת בדיקה
בהתחשב בזמן המוגבל.

339
00:15:58,090 --> 00:16:02,880
>> אז בפתרון מדגם זה, אנו מקצים
מצביע על השמאלי

340
00:16:02,880 --> 00:16:04,510
צד כאן לצומת.

341
00:16:04,510 --> 00:16:07,190
עכשיו, מבין שמצביע, כפי
רוב אמר, הוא רק 32 סיביות.

342
00:16:07,190 --> 00:16:09,060
וזה לא בעצם מכיל
כתובת עד שאתה

343
00:16:09,060 --> 00:16:09,970
להקצות לו את הכתובת.

344
00:16:09,970 --> 00:16:13,220
ואנחנו עושים את זה ביד ימין
צד באמצעות malloc.

345
00:16:13,220 --> 00:16:16,550
כמו אזרח טוב, אנחנו בודקים ש
malloc אינו, למעשה, ריק, כך ש

346
00:16:16,550 --> 00:16:18,690
אנחנו לא יוצרים בטעות
segfault כאן.

347
00:16:18,690 --> 00:16:22,840
וכל פעם שאתה משתמש malloc בחיים, אתה
צריך לבדוק לnull, שמא

348
00:16:22,840 --> 00:16:24,090
יש לך באג עדין.

349
00:16:24,090 --> 00:16:28,460
>> אז לאתחל null כי על ידי
הקצאת n והקודם והבא.

350
00:16:28,460 --> 00:16:32,450
ובמקרה הזה כאן, אני אותחל
קודם לריק, כי זה חדש

351
00:16:32,450 --> 00:16:34,780
צומת הולכת להיות חדש
החל מהרשימה שלי.

352
00:16:34,780 --> 00:16:37,050
אז הנה זה הולך להיות
שום דבר לפני זה.

353
00:16:37,050 --> 00:16:42,010
ואני רוצה להוסיף במהות
רשימה קיימת לצומת החדשה על ידי

354
00:16:42,010 --> 00:16:44,700
ההגדרה הבאה שווה לרשימה עצמה.

355
00:16:44,700 --> 00:16:47,120
אבל אני לא עשיתי עדיין.

356
00:16:47,120 --> 00:16:51,780
אז אם הרשימה עצמה כבר הייתה קיימת,
והייתה צומת אחת לפחות

357
00:16:51,780 --> 00:16:57,070
כבר במקום, אם זה ברשימה
כאן ואני מכניס צומת חדש כאן, אני

358
00:16:57,070 --> 00:17:01,840
צריך לוודא שהצומת שלי לשעבר
מצביע לאחור לצומת החדשה שלי,

359
00:17:01,840 --> 00:17:04,260
כי זה שוב הוא,,
רשימה מקושרת כפליים.

360
00:17:04,260 --> 00:17:05,460
>> אז אנחנו עושים בדיקת שפיות.

361
00:17:05,460 --> 00:17:10,109
אם הרשימה אינה ריקה, אם יש כבר
אחד או יותר בלוטות לשם, אז

362
00:17:10,109 --> 00:17:12,470
תוסיף, כי התייחסות בחזרה כביכול.

363
00:17:12,470 --> 00:17:15,420
ואז הדבר האחרון שאנחנו צריכים
לעשות הוא בעצם לעדכן את הגלובלי

364
00:17:15,420 --> 00:17:20,329
רשימה משתנה עצמו להצביע
כדי שהצומת החדשה.

365
00:17:20,329 --> 00:17:21,790
כן.

366
00:17:21,790 --> 00:17:26,579
>> קהל: בחץ המצביע
[לא ברור] שווה null, עושה את זה

367
00:17:26,579 --> 00:17:30,420
להתמודד עם הרשימה כי
הרשימה היא ריקה?

368
00:17:30,420 --> 00:17:30,596
>> דוד י מלאן: לא ולא.

369
00:17:30,596 --> 00:17:34,500
זה פשוט לי להיות באופן יזום
זהיר, בכך שאם זה שלי

370
00:17:34,500 --> 00:17:38,730
רשימה מקורית עם אולי כמה צמתים יותר
לכאן ואני מחדיר

371
00:17:38,730 --> 00:17:42,380
צומת חדשה כאן, יש הולך
להיות שום דבר כאן.

372
00:17:42,380 --> 00:17:44,720
ואני רוצה לתפוס את הרעיון כי
על ידי הגדרה קודמת

373
00:17:44,720 --> 00:17:47,740
null על הצומת החדשה.

374
00:17:47,740 --> 00:17:51,410
ומן הסתם, אם הקוד שלי הוא נכון
ואין שום דרך אחרת להוספה

375
00:17:51,410 --> 00:17:54,970
צמתים אחרים מפונקציה זו,
ככל הנראה, גם אם רשימה כבר יש

376
00:17:54,970 --> 00:18:00,090
בלוטות לאחד או יותר בזה, ככל הנראה
רשימה, על הצומת הראשונה, תהיה לי

377
00:18:00,090 --> 00:18:02,750
מצביע קודם של null עצמו.

378
00:18:02,750 --> 00:18:03,550
>> קהל: ורק מעקב.

379
00:18:03,550 --> 00:18:08,139
הסיבה לך לשים את מצביע שווים הבאים
רשימה שאתה עושה את המצביע

380
00:18:08,139 --> 00:18:13,579
לפני רשימה בכך שהוא מצביע
למשנהו, אני מניח -

381
00:18:13,579 --> 00:18:14,980
אני לא מבינים -

382
00:18:14,980 --> 00:18:15,450
רק מפרט?

383
00:18:15,450 --> 00:18:16,400
>> דוד י מלאן: בדיוק.

384
00:18:16,400 --> 00:18:19,400
ואז בואו בעצם רואים שני מקרים
כאן באמת, למרות

385
00:18:19,400 --> 00:18:22,070
על מנת שנוכל לשקול אותם הוא לא
בדיוק אותו הדבר כמו הקוד.

386
00:18:22,070 --> 00:18:26,250
אבל ברמה גבוהה, אם זה מייצג
רשימה וזה 32 סיביות

387
00:18:26,250 --> 00:18:29,560
מצביע, התרחיש הפשוט ביותר הוא
כי זה הוא ריק כברירת מחדל.

388
00:18:29,560 --> 00:18:33,010
ונניח שאני רוצה להכניס את
מספר 50 היה המספר הראשון.

389
00:18:33,010 --> 00:18:37,640
אז אני הולך קדימה ולהקצות
צומת, שבו הוא הולך להכיל

390
00:18:37,640 --> 00:18:38,770
שלושה תחומים -

391
00:18:38,770 --> 00:18:42,070
n, קודם, וקרוב.

392
00:18:42,070 --> 00:18:44,580
>> אני הולך לשים את המספר 50
כאן, כי זה יהיה n.

393
00:18:44,580 --> 00:18:46,130
זה יהיה הקרוב.

394
00:18:46,130 --> 00:18:48,530
וזה יהיה קודם.

395
00:18:48,530 --> 00:18:50,910
ואז מה עליי לעשות במקרה זה?

396
00:18:50,910 --> 00:18:53,900
ובכן, אני רק עשיתי את הקו 1 כאן.

397
00:18:53,900 --> 00:18:55,400
n המצביע מקבל n.

398
00:18:55,400 --> 00:18:57,740
אני לאחר מכן אמרתי, קודם
צריך לקבל null.

399
00:18:57,740 --> 00:18:59,470
אז זה הולך להיות ריק.

400
00:18:59,470 --> 00:19:01,365
ואז אני עומד להגיד
הוא הולך לקבל את הרשימה.

401
00:19:01,365 --> 00:19:05,150
>> וזה פשוט עובד טוב.

402
00:19:05,150 --> 00:19:06,500
זה הוא ריק.

403
00:19:06,500 --> 00:19:10,620
ואז אני אומר, הצומת של החדשה הבאה
שדה צריך לקבל את כל מה שזה.

404
00:19:10,620 --> 00:19:12,570
אז זה מעמיד null אחר שם.

405
00:19:12,570 --> 00:19:14,510
ואז הדבר האחרון
אני הוא לבדוק כאן.

406
00:19:14,510 --> 00:19:17,870
אם הרשימה אינה שווה לאפס, אבל זה
שווה ל null, כך אנחנו מדלגים כי

407
00:19:17,870 --> 00:19:18,470
לגמרי.

408
00:19:18,470 --> 00:19:23,520
וכך כל מה שאני עושה הבא היא רשימה מקבלת
מצביע, שpictorially תוצאות

409
00:19:23,520 --> 00:19:25,570
תמונה ככה.

410
00:19:25,570 --> 00:19:26,620
אז זה סיפור אחד.

411
00:19:26,620 --> 00:19:30,490
>> והאחד שאתה שואל על
במיוחד הוא מצב כזה,

412
00:19:30,490 --> 00:19:33,190
שבו כבר יש לנו רשימה אחת צמתים.

413
00:19:33,190 --> 00:19:36,240
ואם אני חוזר במקורי
הצהרת בעיה, הבא נהיה

414
00:19:36,240 --> 00:19:39,320
הכנס לומר הוא 34, רק בשביל
לצורך דיון.

415
00:19:39,320 --> 00:19:46,210
אז אני הולך רק בנוחות
לצייר את זה לכאן.

416
00:19:46,210 --> 00:19:47,540
אני פשוט כבר malloced.

417
00:19:47,540 --> 00:19:49,310
הבה נניח שאני בודק null.

418
00:19:49,310 --> 00:19:51,870
>> עכשיו, אני הולך לאתחל
n להיות 34.

419
00:19:51,870 --> 00:19:53,040
וזה יהיה n.

420
00:19:53,040 --> 00:19:54,670
זה יהיה הקרוב.

421
00:19:54,670 --> 00:19:57,100
וזה יהיה קודם.

422
00:19:57,100 --> 00:19:59,370
בואו נוודא שאני לא
לקבל את זה אחורה.

423
00:19:59,370 --> 00:20:01,110
קודם שיבוא קודם
בהגדרה.

424
00:20:01,110 --> 00:20:03,070
תן לי לתקן את זה.

425
00:20:03,070 --> 00:20:04,410
זה קודם.

426
00:20:04,410 --> 00:20:05,780
זה הקרוב.

427
00:20:05,780 --> 00:20:08,620
למרות אלה הם זהים,
בואו נשמור את זה בקנה אחד.

428
00:20:08,620 --> 00:20:09,450
>> קודם.

429
00:20:09,450 --> 00:20:11,030
זה הקרוב.

430
00:20:11,030 --> 00:20:16,310
אז יש לי רק malloced הפתק שלי, בדקתי
לnull, שהוקצה 34 לתוך הצומת.

431
00:20:16,310 --> 00:20:17,570
קודם מקבל אפס.

432
00:20:17,570 --> 00:20:19,480
אז זה נותן לי את זה.

433
00:20:19,480 --> 00:20:21,010
הבא מקבלת רשימה.

434
00:20:21,010 --> 00:20:22,370
אז רשימה היא זה.

435
00:20:22,370 --> 00:20:26,520
אז זה אותו הדבר עכשיו כמו ציור זה
חץ, כך שהם מצביעים על אחד

436
00:20:26,520 --> 00:20:27,940
באותו הדבר.

437
00:20:27,940 --> 00:20:30,400
ולאחר מכן אני בודק אם רשימה
אינו שווה לריק.

438
00:20:30,400 --> 00:20:31,740
וזה לא הפעם.

439
00:20:31,740 --> 00:20:35,580
ואז אני הולך לעשות את הרשימה
קודם מקבל מצביע.

440
00:20:35,580 --> 00:20:39,700
>> אז רשימה קודמת מקבל PTR.

441
00:20:39,700 --> 00:20:44,300
לכן יש לזה אפקט של לשים
חץ גרפי כאן.

442
00:20:44,300 --> 00:20:46,930
וזה מתחיל להיות קצת
גלי, את הקווים.

443
00:20:46,930 --> 00:20:50,780
ואז, לבסוף, אני מעדכן
רשימה להצביע על מצביע.

444
00:20:50,780 --> 00:20:55,560
אז עכשיו זה מצביע על הבחור הזה.

445
00:20:55,560 --> 00:20:57,170
ועכשיו, בואו נעשה מהיר
שפיות סימון.

446
00:20:57,170 --> 00:20:59,470
>> הנה הרשימה, שהוא
משתנה הגלובלי.

447
00:20:59,470 --> 00:21:02,850
הצומת הראשונה היא, אכן, 34, כי
אני עוקב אחרי החץ.

448
00:21:02,850 --> 00:21:05,210
וזה נכון, כי אני רוצה
הכנס בתחילת הרשימה

449
00:21:05,210 --> 00:21:06,070
כל צמתים החדשים.

450
00:21:06,070 --> 00:21:08,860
השדה הבא שלו מוביל אותי לאיש הזה.

451
00:21:08,860 --> 00:21:10,710
אם אמשיך, אני מכה הבא הוא null.

452
00:21:10,710 --> 00:21:11,760
כך שאין יותר רשימה.

453
00:21:11,760 --> 00:21:14,460
אם אני מכה קודם, אני מקבל
לגבות בו אני מצפה.

454
00:21:14,460 --> 00:21:16,435
>> אז יש עדיין כמה עצות,
כמובן, כדי לתפעל.

455
00:21:16,435 --> 00:21:19,870
אבל העובדה שאמרו לך לעשות
זה בזמן קבוע אומר שאתה רק

456
00:21:19,870 --> 00:21:22,910
יש מספר סופי של דברים
מותר לך לעשות.

457
00:21:22,910 --> 00:21:24,290
ומה הוא אותו המספר?

458
00:21:24,290 --> 00:21:25,185
זה יכול להיות צעד אחד.

459
00:21:25,185 --> 00:21:25,700
זה יכול להיות שתיים.

460
00:21:25,700 --> 00:21:26,820
זה יכול להיות 1,000 מדרגות.

461
00:21:26,820 --> 00:21:30,500
אבל זה סופי, מה שאומר שאתה לא יכול
יש כל סוג של לולאות קורה

462
00:21:30,500 --> 00:21:32,010
כאן, לא רקורסיה, לא לולאות.

463
00:21:32,010 --> 00:21:37,390
זה פשוט חייב להיות קווי קידוד קשיח
קוד שיש לנו במדגם זה.

464
00:21:37,390 --> 00:21:42,330
>> אז הבעיה הבאה 12 ביקשה מאיתנו
להשלים את יישום להסיר

465
00:21:42,330 --> 00:21:46,740
להלן בצורה כזאת, כי הוא מסיר
n מהרשימה בזמן ליניארי.

466
00:21:46,740 --> 00:21:48,740
אז יש לך קצת יותר
מרחב תמרון עכשיו.

467
00:21:48,740 --> 00:21:52,380
ניתן להניח כי n, אם קיים
ברשימה, יהיה נוכח

468
00:21:52,380 --> 00:21:53,340
לא יותר מפעם אחת.

469
00:21:53,340 --> 00:21:56,770
וגם זה אמור להיות מבוסס חידון
הנחה פישוט, כך

470
00:21:56,770 --> 00:21:59,780
כי אם אתה מוצא איפשהו מספר 50
ברשימה, אתה לא מבין גם

471
00:21:59,780 --> 00:22:02,890
צריך לדאוג ממשיך
לחזר, מחפש בכל אפשרי

472
00:22:02,890 --> 00:22:06,990
עותק של 50, אשר היה לעבור רק
לכמה פרטים קטנים בזמן מוגבל.

473
00:22:06,990 --> 00:22:10,460
>> אז עם הסרה, זה היה בהחלט
יותר מאתגר ויותר

474
00:22:10,460 --> 00:22:11,640
קוד לכתוב.

475
00:22:11,640 --> 00:22:14,990
אבל במבט ראשון, בכנות, שזה אולי
להיראות משהו מכריע וכמו

476
00:22:14,990 --> 00:22:17,060
אין שום דרך שאתה יכול להיות
לבוא עם בחידון.

477
00:22:17,060 --> 00:22:22,450
אבל אם אנחנו מתמקדים בצעדים הבודדים,
בתקווה, זה יהיה פתאום

478
00:22:22,450 --> 00:22:26,060
נראיתי לך שכל אחד מאלה בודדים
צעדים הגיוני ברורה

479
00:22:26,060 --> 00:22:27,080
במבט לאחור.

480
00:22:27,080 --> 00:22:28,200
אז בואו נסתכל.

481
00:22:28,200 --> 00:22:32,570
>> אז קודם כל, אנחנו לאתחל מצביע
להיות ברשימה עצמה.

482
00:22:32,570 --> 00:22:36,040
כי אני רוצה זמן ליניארי, שאמצעי
אני הולך לקבל קצת לולאה.

483
00:22:36,040 --> 00:22:39,730
ודרך נפוצה לחזר על
צמתים במבנה רשימה או כל סוג שהוא

484
00:22:39,730 --> 00:22:43,860
מבנה איטרטיבי הוא לקחת
מצביע לחלק הקדמי של נתונים

485
00:22:43,860 --> 00:22:46,990
מבנה ואז פשוט להתחיל לעדכן
זה וללכת בדרך שלך

486
00:22:46,990 --> 00:22:48,650
דרך מבנה נתונים.

487
00:22:48,650 --> 00:22:50,040
אז אני הולך לעשות בדיוק את זה.

488
00:22:50,040 --> 00:22:54,260
>> בעוד מצביע, משתנה הזמני שלי,
אינו שווה ל null, בואו

489
00:22:54,260 --> 00:22:55,660
קדימה, לבדוק.

490
00:22:55,660 --> 00:22:56,910
האם אני מקבל את המזל?

491
00:22:56,910 --> 00:23:01,740
האם שדה n בצומת אני כרגע
מסתכל שווה

492
00:23:01,740 --> 00:23:03,380
מספר שאני מחפש?

493
00:23:03,380 --> 00:23:05,410
ואם כן, בואו נעשה משהו.

494
00:23:05,410 --> 00:23:10,020
עכשיו, שים לב זה אם מצב
מקיף את כולו

495
00:23:10,020 --> 00:23:11,520
השורות הבאות של קוד.

496
00:23:11,520 --> 00:23:14,610
זה הדבר היחיד שאכפת לי -
מציאת מספר בשאלה.

497
00:23:14,610 --> 00:23:18,010
כך שאין שום דבר אחר, אשר מפשט
דברים מושגית קצת.

498
00:23:18,010 --> 00:23:22,040
>> אבל עכשיו, הבנתי, ואולי יש לך
רק הבין את זה אחרי שחשבתי

499
00:23:22,040 --> 00:23:24,720
זה דרך קצת, יש
למעשה שני מקרים כאן.

500
00:23:24,720 --> 00:23:28,060
אחת מהן הוא שבו הצומת היא ב
תחילתה של הרשימה, שהוא

501
00:23:28,060 --> 00:23:31,040
קצת מעצבן, כי זה
מקרה מיוחד, משום שיש לך להתמודד

502
00:23:31,040 --> 00:23:33,340
עם הדבר הזה, שבו
הוא האנומליה בלבד.

503
00:23:33,340 --> 00:23:35,720
בכל מקום אחר ברשימה,
זה אותו הדבר.

504
00:23:35,720 --> 00:23:38,050
יש צומת קודמת ובא
צומת, צומת קודמת, הצומת הבאה.

505
00:23:38,050 --> 00:23:40,940
אבל הבחור הזה הוא קצת מיוחד
אם הוא בתחילתו.

506
00:23:40,940 --> 00:23:48,710
>> אז אם המצביע שווה לרשימה
עצמו, כך שאם אני בתחילת

507
00:23:48,710 --> 00:23:53,960
הרשימה ומצאתי n, אני צריך
לעשות כמה דברים.

508
00:23:53,960 --> 00:23:59,230
אחד, אני צריך לשנות את הרשימה כדי
מצביע לשדה הבא, 50.

509
00:23:59,230 --> 00:24:01,270
אז נניח שאני מנסה
כדי להסיר 34.

510
00:24:01,270 --> 00:24:03,560
אז הבחור הזה חייב ללכת
משם ברגע.

511
00:24:03,560 --> 00:24:07,210
>> אז אני הולך לומר, רשימה
מקבל מצביע הבא.

512
00:24:07,210 --> 00:24:08,570
ובכן, זה מצביע.

513
00:24:08,570 --> 00:24:10,360
הבא מצביע לכאן.

514
00:24:10,360 --> 00:24:17,470
אז זה משתנה תקין החץ הזה
עכשיו להצביע על הבחור הזה כאן.

515
00:24:17,470 --> 00:24:19,580
עכשיו, זכור, יש לנו
משתנה זמני.

516
00:24:19,580 --> 00:24:23,520
אז אנחנו לא יתומים כל צמתים,
כי יש לי גם את הבחור הזה בי

517
00:24:23,520 --> 00:24:25,010
יישום הסרה.

518
00:24:25,010 --> 00:24:29,600
אז עכשיו, אם הרשימה עצמה היא לא ריקה,
אני צריך לתקן משהו קטן.

519
00:24:29,600 --> 00:24:32,690
>> אני צריך לעשות עכשיו בטוח שהלחץ הזה,
אשר הצביע בעבר

520
00:24:32,690 --> 00:24:36,830
50-34, זה חייב ללכת משם,
כי אם אני מנסה להיפטר

521
00:24:36,830 --> 00:24:41,910
34, 50 היו יותר טוב לא לשמור על כל
בחזרה התייחסות סוג של אליה כאל

522
00:24:41,910 --> 00:24:42,820
החץ שהציע.

523
00:24:42,820 --> 00:24:44,820
אז אני פשוט עשיתי את הקו הזה.

524
00:24:44,820 --> 00:24:46,520
אז אני סיימתי.

525
00:24:46,520 --> 00:24:48,040
מקרה זה הוא בעצם די קל.

526
00:24:48,040 --> 00:24:51,010
עריפת ראש הרשימה
הוא פשוט יחסית.

527
00:24:51,010 --> 00:24:52,980
>> למרבה הצער, אין זה
בלוק המעצבן אחר.

528
00:24:52,980 --> 00:24:56,170
אז עכשיו, אני צריך לשקול את המקרה
שבו יש משהו באמצע.

529
00:24:56,170 --> 00:24:59,880
אבל זה לא נורא מדי, למעט
לתחביר כזה.

530
00:24:59,880 --> 00:25:03,080
אז אם אני לא בתחילת
רשימה, אני איפשהו באמצע.

531
00:25:03,080 --> 00:25:08,160
והקו הזה כאן אומר, התחלה
בכל מה שאתה בצומת.

532
00:25:08,160 --> 00:25:11,210

533
00:25:11,210 --> 00:25:18,550
עבור לשדה הבא של הצומת הקודמת
ומצביע כי במצביע.

534
00:25:18,550 --> 00:25:20,390
>> בואו לעשות את זה באופן ציורי.

535
00:25:20,390 --> 00:25:21,640
שהולך ומסתבך.

536
00:25:21,640 --> 00:25:30,480

537
00:25:30,480 --> 00:25:37,990
אז אם יש לי שדות קודמים כאן -
בואו נעשיתי את זה - תחומים הבאים כאן.

538
00:25:37,990 --> 00:25:41,200
אני הולך כדי לפשט את המצביעים שלי ולא
מאשר לצייר חבורה של שלמה

539
00:25:41,200 --> 00:25:45,710
דברים הלוך ושוב חוצים
אחד את השני.

540
00:25:45,710 --> 00:25:50,870
ועכשיו, בואו נגיד את זה הוא 1, 2,
3 לצורך הדיון, גם

541
00:25:50,870 --> 00:25:53,410
למרות שלא ליישר קו עם
הבעיה בשאלה.

542
00:25:53,410 --> 00:25:55,900
>> אז הנה הרשימה המקושרת שלי.

543
00:25:55,900 --> 00:25:59,300
אני מנסה להסיר את שני בזה
גרסה מסוימת של הסיפור.

544
00:25:59,300 --> 00:26:01,960
אז אני כבר מעודכן מצביע
תצביע לבחור הזה.

545
00:26:01,960 --> 00:26:03,315
אז זה PTR.

546
00:26:03,315 --> 00:26:04,530
הוא מצביע כאן.

547
00:26:04,530 --> 00:26:07,170
זוהי רשימה, אשר קיים
בעולם כמו בעבר.

548
00:26:07,170 --> 00:26:09,200
והוא מצביע לכאן, לא משנה מה.

549
00:26:09,200 --> 00:26:10,800
ועכשיו, אני מנסה להסיר את שני.

550
00:26:10,800 --> 00:26:13,850
>> אז אם המצביע מצביע כאן, אני
הולך אחריו, ככל הנראה,

551
00:26:13,850 --> 00:26:17,110
מצביע קודם, אשר מעמיד ב1.

552
00:26:17,110 --> 00:26:22,290
אז אני הולך להגיד את זה ליד
שדה, מה שמביא אותי לזה

553
00:26:22,290 --> 00:26:25,410
תיבה כאן, הוא הולך
מצביע שווה הבא.

554
00:26:25,410 --> 00:26:28,400
אז אם מצביע זה, זה הבא.

555
00:26:28,400 --> 00:26:31,840
זה אומר שהצרכים של החץ הזה
כדי להצביע על הבחור הזה.

556
00:26:31,840 --> 00:26:35,140
>> אז מה שורה זו של קוד יש רק
עשה הוא קצת מזה.

557
00:26:35,140 --> 00:26:37,500
ועכשיו, זה נראה כמו
צעד בכיוון הנכון.

558
00:26:37,500 --> 00:26:41,390
אנחנו בעצם רוצים לגזור 2 מ
מאמצע 1 ו -3.

559
00:26:41,390 --> 00:26:44,400
אז זה הגיוני שאנחנו רוצים
מסלול מצביע זה סביב זה.

560
00:26:44,400 --> 00:26:50,400
אז זה הקו הבא הוא לבדוק אם מצביע
הוא הבא לא ריק, יש

561
00:26:50,400 --> 00:26:54,200
אכן מישהו בצד הימין של 2,
זה אומר שגם אנחנו צריכים לעשות

562
00:26:54,200 --> 00:26:55,850
קצת לגזור כאן.

563
00:26:55,850 --> 00:27:00,590
>> אז עכשיו אני צריך לעקוב אחרי מצביע זה
ולעדכן את המצביע הקודם על

564
00:27:00,590 --> 00:27:05,410
הבחור הזה לעשות קצת
לעקוף כאן הנקודה כאן.

565
00:27:05,410 --> 00:27:07,100
ועכשיו, מבחינה ויזואלית זה נחמד.

566
00:27:07,100 --> 00:27:11,930
זה קצת מבולגן שביש
אף אחד לא מצביע על 2 יותר.

567
00:27:11,930 --> 00:27:13,600
2 מצביע לשמאל.

568
00:27:13,600 --> 00:27:14,980
ו2 מצביע לימין.

569
00:27:14,980 --> 00:27:17,480
אבל הוא יכול לעשות מה שהוא רוצה, כי
הוא עומד לקבל משוחרר.

570
00:27:17,480 --> 00:27:19,480
וזה לא משנה מה
ערכים אלה הם יותר.

571
00:27:19,480 --> 00:27:23,040
>> מה שחשוב הוא שנותר
החבר 'ה ניתוב מעל

572
00:27:23,040 --> 00:27:24,280
ומתחתיו עכשיו.

573
00:27:24,280 --> 00:27:25,810
ואכן, זה מה שאנחנו עושים עכשיו.

574
00:27:25,810 --> 00:27:29,360
אנחנו מצביע חופשיים, מה שאומר שאנחנו אומרים לי
מערכת הפעלה, אתם מוזמנים

575
00:27:29,360 --> 00:27:30,906
כדי להשיב את זה.

576
00:27:30,906 --> 00:27:34,900
ואז לבסוף, אנחנו חוזרים.

577
00:27:34,900 --> 00:27:37,220
אחר במשתמע, אם אנחנו
עדיין לא חזר,

578
00:27:37,220 --> 00:27:38,290
אנחנו חייבים להמשיך לחפש.

579
00:27:38,290 --> 00:27:41,485
אז מצביע שווה מצביע הבא רק
משמעות הדבר היא להעביר את הבחור הזה כאן.

580
00:27:41,485 --> 00:27:42,600
הזז את הבחור הזה כאן.

581
00:27:42,600 --> 00:27:45,400
הזז את הבחור הזה כאן אם, למעשה,
לא מצאנו את המספר

582
00:27:45,400 --> 00:27:46,960
אנחנו מחפשים עדיין.

583
00:27:46,960 --> 00:27:49,630
>> אז בכנות, זה נראה לגמרי
מהמם, אני חושב, בהתחלה

584
00:27:49,630 --> 00:27:52,180
מבט אחד, במיוחד אם אתה נאבק
עם זה במהלך החידון ואז לראות

585
00:27:52,180 --> 00:27:52,850
משהו כזה.

586
00:27:52,850 --> 00:27:55,050
ולך לטפוח לעצמך על שכם.

587
00:27:55,050 --> 00:27:57,080
ובכן, אין שום סיכוי שיהיה לי
לבוא עם שבחידון.

588
00:27:57,080 --> 00:28:00,470
אבל אני טוען, שאתה יכול אם אתה שובר
אותו לאדם הבאים

589
00:28:00,470 --> 00:28:04,400
מקרים ופשוט לעבור את זה
זהירות, אם כי, יש להודות, תחת

590
00:28:04,400 --> 00:28:06,300
נסיבות מלחיצים.

591
00:28:06,300 --> 00:28:09,470
>> למרבה המזל, תמונה המורכבת
הכל מאושר.

592
00:28:09,470 --> 00:28:11,050
אתה יכול לצייר את זה ב
כל מספר הדרכים.

593
00:28:11,050 --> 00:28:12,760
אתה לא צריך לעשות מצטלב
דבר כאן.

594
00:28:12,760 --> 00:28:14,520
אתה יכול לעשות את זה עם ישר
שורות כמו זה.

595
00:28:14,520 --> 00:28:18,790
אבל התמצית של בעיה זו, ב
בכלל, היה להבין כי

596
00:28:18,790 --> 00:28:22,060
תמונה בסופו של הדבר צריכה להסתכל קצת
משהו כזה, כי

597
00:28:22,060 --> 00:28:25,030
זמן קבוע משתמע כי אתה שומר
שיבוש וחסימה ושיבוש

598
00:28:25,030 --> 00:28:29,900
צמתים חדשים בתחילת
של הרשימה.

599
00:28:29,900 --> 00:28:31,960
כל שאלה?

600
00:28:31,960 --> 00:28:34,565
כנראה המאתגר ביותר של
בהחלט שאלות הקידוד.

601
00:28:34,565 --> 00:28:37,690
>> קהל: אז היא רשימה דומה
ראש בדוגמאות קודמות.

602
00:28:37,690 --> 00:28:39,640
>> דוד י מלאן: בדיוק, בדיוק.

603
00:28:39,640 --> 00:28:43,130
רק שם שונה עבור
משתנה גלובלי.

604
00:28:43,130 --> 00:28:44,380
העולם רחב מה?

605
00:28:44,380 --> 00:28:48,880

606
00:28:48,880 --> 00:28:49,730
>> ROB אודן: אישור.

607
00:28:49,730 --> 00:28:52,020
אז זה אחד שבו אתה
הייתי צריך לכתוב פסקה.

608
00:28:52,020 --> 00:28:56,060
יש אנשים שכתבו מאמרים
לשאלה זו.

609
00:28:56,060 --> 00:29:00,230
אבל אתה רק צריך להשתמש ששת תנאים אלה
כדי לתאר את מה שקורה כאשר

610
00:29:00,230 --> 00:29:02,440
אתה מנסה ליצור קשר facebook.com.

611
00:29:02,440 --> 00:29:07,930
אז רק אני אדבר בתהליך
משתמש בכל המונחים האלה.

612
00:29:07,930 --> 00:29:11,290
אז בדפדפן שלנו, אנחנו סוג facebook.com
ולחץ על Enter.

613
00:29:11,290 --> 00:29:17,280
אז הדפדפן שלנו הולך לבנות
HTTP לבקש שזה הולך לשלוח

614
00:29:17,280 --> 00:29:22,220
דרך איזה תהליך לפייסבוק עבור
פייסבוק להגיב אלינו עם

615
00:29:22,220 --> 00:29:24,450
ה-HTML של הדף שלה.

616
00:29:24,450 --> 00:29:28,800
>> אז מה הוא את התהליך על ידי
שבקשת HTTP

617
00:29:28,800 --> 00:29:30,730
למעשה מקבל לפייסבוק?

618
00:29:30,730 --> 00:29:32,790
אז קודם כל, אנחנו צריכים לתרגם
Facebook.com.

619
00:29:32,790 --> 00:29:38,780
אז פשוט קבל את השם Facebook.com,
שבו בעצם עושה הבקשה HTTP

620
00:29:38,780 --> 00:29:39,940
צריך ללכת?

621
00:29:39,940 --> 00:29:44,120
אז אנחנו צריכים לתרגם Facebook.com
לכתובת ה-IP, אשר באופן ייחודי

622
00:29:44,120 --> 00:29:47,620
מזהה את מה שמכונה שאנחנו באמת
רוצה לשלוח בקשה זו ל.

623
00:29:47,620 --> 00:29:49,310
יש המחשב הנייד שלך כתובת ה-IP.

624
00:29:49,310 --> 00:29:52,240
כל מה שקשור לאינטרנט
יש כתובת IP.

625
00:29:52,240 --> 00:29:59,030
>> אז DNS, מערכת שמות מתחם, כי הוא
מה הולך להתמודד עם התרגום

626
00:29:59,030 --> 00:30:03,750
מfacebook.com לכתובת ה-IP ש
אתה באמת רוצה ליצור קשר.

627
00:30:03,750 --> 00:30:08,075
אז אנחנו פנו לשרתי DNS ו
למשל, מה הוא facebook.com?

628
00:30:08,075 --> 00:30:16,560
זה אומר, אוי, זה כתובת ה-IP 190.212
משהו, משהו, משהו.

629
00:30:16,560 --> 00:30:16,900
בסדר.

630
00:30:16,900 --> 00:30:18,850
עכשיו, אני יודע מה מכונה
אני רוצה ליצור קשר.

631
00:30:18,850 --> 00:30:22,360
>> אז אתה שולח בקשת HTTP שלך
מעל לזה מכונה.

632
00:30:22,360 --> 00:30:24,140
אז איך זה יגיע לזה מכונה?

633
00:30:24,140 --> 00:30:27,200
ובכן, הבקשה עוברת מ
הנתב להקפצת הנתב.

634
00:30:27,200 --> 00:30:32,630
זכור את הדוגמא בכיתה, שבו
אנחנו בעצם ראינו את המסלול בו

635
00:30:32,630 --> 00:30:35,340
מנות לקחו כשניסינו
כדי לתקשר.

636
00:30:35,340 --> 00:30:38,460
ראינו את זה לקפוץ מעל האוקיינוס ​​האטלנטי
אוקיינוס ​​בנקודה אחת או משהו כזה.

637
00:30:38,460 --> 00:30:42,820
>> אז יציאת הקדנציה האחרונה.

638
00:30:42,820 --> 00:30:46,520
אז זה עכשיו במחשב שלך.

639
00:30:46,520 --> 00:30:49,970
יכול להיות לך מספר דברים כרגע
תקשורת עם האינטרנט.

640
00:30:49,970 --> 00:30:53,730
אז אני יכול לפעול, למשל, סקייפ.

641
00:30:53,730 --> 00:30:55,670
אולי יש לי דפדפן אינטרנט פתוח.

642
00:30:55,670 --> 00:30:59,010
אולי יש לי משהו ש
torrenting קבצים.

643
00:30:59,010 --> 00:31:00,880
אז כל הדברים האלה הם
תקשורת עם

644
00:31:00,880 --> 00:31:02,600
אינטרנט בדרך כלשהי.

645
00:31:02,600 --> 00:31:08,070
>> לכן, כאשר המחשב שלך מקבל כמה נתונים
מהאינטרנט, איך עושה את זה

646
00:31:08,070 --> 00:31:10,130
יודע מה יישום בפועל
רוצה נתונים?

647
00:31:10,130 --> 00:31:12,610
איך הוא יודע אם זה בפרט
הנתונים נועדו עבור

648
00:31:12,610 --> 00:31:16,070
torrenting יישום בניגוד
לדפדפן האינטרנט?

649
00:31:16,070 --> 00:31:20,980
אז זו המטרה של יציאות שב
כל היישומים האלה יש לי

650
00:31:20,980 --> 00:31:22,720
טען יציאה במחשב שלך.

651
00:31:22,720 --> 00:31:27,580
אז דפדפן האינטרנט שלך אומר, היי,
אני מקשיב ביציאה 1000.

652
00:31:27,580 --> 00:31:32,240
ותכנית torrenting שלך אומרת,
אני מקשיב ביציאה 3000.

653
00:31:32,240 --> 00:31:34,770
וסקייפ אומר, אני משתמש ביציאה 4000.

654
00:31:34,770 --> 00:31:41,950
>> כך שכאשר אתה מקבל כמה נתונים שייך
לאחד מיישומים אלה, הנתונים

655
00:31:41,950 --> 00:31:45,510
מסומן שבנמל זה באמת
יש לשלוח יחד ל.

656
00:31:45,510 --> 00:31:47,950
אז זה אומר, אה, אני שייך
ליציאת 1000.

657
00:31:47,950 --> 00:31:50,950
אני יודע ואז אני צריך להעביר את זה
לאורך לדפדפן האינטרנט שלי.

658
00:31:50,950 --> 00:31:56,440
אז הסיבה שזה רלוונטי כאן
הוא ששרתי אינטרנט נוטים

659
00:31:56,440 --> 00:31:58,240
להקשיב ביציאה 80.

660
00:31:58,240 --> 00:32:02,420
לכן, כאשר אני יוצר קשר עם Facebook.com, אני
תקשורת עם חלק מכונה.

661
00:32:02,420 --> 00:32:06,390
אבל אני צריך לומר שנמל כי
מכונה שאני רוצה לתקשר איתו.

662
00:32:06,390 --> 00:32:09,160
ושרתי אינטרנט נוטים להיות
האזנה ביציאה 80.

663
00:32:09,160 --> 00:32:14,010
>> אם הם רוצים, הם יכולים להגדיר את זה
עד אז זה מפרט כמו ביציאה 7,000.

664
00:32:14,010 --> 00:32:19,090
ולאחר מכן בדפדפן אינטרנט, שיכולתי
הקלד באופן ידני Facebook.com: 7,000 ל

665
00:32:19,090 --> 00:32:24,600
לשלוח את הבקשה לנמל 7,000
של שרת האינטרנט של פייסבוק.

666
00:32:24,600 --> 00:32:26,820
>> דוד י מלאן: ובמקרה הזה, גם
למרות שאנחנו לא דורשים שאנשים

667
00:32:26,820 --> 00:32:30,000
הזכיר את זה, במקרה זה, מה יציאה
הייתי הבקשה בעצם ללכת ל?

668
00:32:30,000 --> 00:32:36,630

669
00:32:36,630 --> 00:32:37,880
נסה שוב.

670
00:32:37,880 --> 00:32:42,810

671
00:32:42,810 --> 00:32:44,300
בדיוק.

672
00:32:44,300 --> 00:32:47,960
לא מחפש את זה, אבל עידון
ששם אף אחד שעבר.

673
00:32:47,960 --> 00:32:51,770
>> ROB אודן: אז HTTPS, שכן זה
האזנה במיוחד עבור

674
00:32:51,770 --> 00:32:55,180
מוצפן, זה ביציאה 4430.

675
00:32:55,180 --> 00:32:57,680
>> קהל: ומיילים הם 25, נכון?

676
00:32:57,680 --> 00:33:00,670
>> דוד י מלאן: יוצא
מיילים, 25, כן.

677
00:33:00,670 --> 00:33:03,760
>> ROB אודן: אני אפילו לא מכיר את רוב
- כל אלה נמוכים יותר נוטים להיות

678
00:33:03,760 --> 00:33:06,310
שמורות לדברים.

679
00:33:06,310 --> 00:33:09,260
אני חושב שכל מה שמתחת
1024 הוא שמורות.

680
00:33:09,260 --> 00:33:13,450
>> קהל: למה אמרת
3 היו המספר השגוי?

681
00:33:13,450 --> 00:33:18,820
>> ROB אודן: כי בכתובת ה-IP,
יש ארבע קבוצות של ספרות.

682
00:33:18,820 --> 00:33:21,090
והם 0-255.

683
00:33:21,090 --> 00:33:28,060
אז 192.168.2.1 הוא נפוץ
כתובת ה-IP ברשת מקומית.

684
00:33:28,060 --> 00:33:30,840
שים לב כל אלה הם פחות מ 255.

685
00:33:30,840 --> 00:33:33,570
אז כשהתחלתי עם 300, כי
לא יכול להיות

686
00:33:33,570 --> 00:33:35,210
היה אחד מהמספרים.

687
00:33:35,210 --> 00:33:38,170
>> דוד י מלאן: אבל זה קליפ מטופש
מ-- היה זה CSI, שם היה להם

688
00:33:38,170 --> 00:33:39,970
מספר זה היה גדול מדי
לכתובת ה-IP.

689
00:33:39,970 --> 00:33:42,940

690
00:33:42,940 --> 00:33:46,110
>> ROB אודן: כל שאלות בעניין הזה?

691
00:33:46,110 --> 00:33:51,710
הבא, השינוי כל כך מלא ב
נושא, אבל יש לנו מערך PHP זה עבור

692
00:33:51,710 --> 00:33:53,270
הבתים במרובע.

693
00:33:53,270 --> 00:33:56,360
ויש לנו רשימה לא מסודרת.

694
00:33:56,360 --> 00:33:59,550
ואנחנו רוצים להדפיס את כל פריט ברשימה
רק מכיל את שם הבית.

695
00:33:59,550 --> 00:34:09,090

696
00:34:09,090 --> 00:34:11,870
אז יש לנו לולאת foreach.

697
00:34:11,870 --> 00:34:17,540
אז תזכור, התחביר הוא foreach
מערך כפריט במערך.

698
00:34:17,540 --> 00:34:22,360
אז דרך כל איטרציה של הלולאה,
הבית הולך לקחת על אחד

699
00:34:22,360 --> 00:34:24,060
ערכים הפנימיים של המערך.

700
00:34:24,060 --> 00:34:26,530
>> באיטרציה, הבית הראשון
יהיה בית קאבוט.

701
00:34:26,530 --> 00:34:30,370
באיטרציה, בית שני יהיה
להיות בית שליח וכן הלאה.

702
00:34:30,370 --> 00:34:34,370
אז לכל ארבעה כבית, אנחנו
פשוט הולך להדפסה -

703
00:34:34,370 --> 00:34:37,250
אתה גם יכול היה הדהד -

704
00:34:37,250 --> 00:34:42,199
פריט הרשימה ולאחר מכן שמו של הבית
ולאחר מכן לסגור את הפריט ברשימה.

705
00:34:42,199 --> 00:34:45,210
הסוגריים המסולסלים הם אופציונליים כאן.

706
00:34:45,210 --> 00:34:49,480
>> ואז גם אמרו בשאלה
עצמו, לזכור לסגור

707
00:34:49,480 --> 00:34:50,770
תג רשימה לא מסודרת.

708
00:34:50,770 --> 00:34:53,949
אז אנחנו צריכים לצאת ממצב PHP
כדי לעשות את זה.

709
00:34:53,949 --> 00:35:00,280
או שאנחנו יכולים להיות הדהדו
לסגור את תג רשימה לא מסודרת.

710
00:35:00,280 --> 00:35:02,380
>> דוד י מלאן: כן בסדר כאן היית
היה להשתמש בבית ספר ישן ל

711
00:35:02,380 --> 00:35:07,340
לולאה עם i $ = 0 0 ובאמצעות ספירה ל
להבין את אורכו של ריי.

712
00:35:07,340 --> 00:35:09,240
גם לגמרי בסדר, רק
wordier קטן.

713
00:35:09,240 --> 00:35:12,170

714
00:35:12,170 --> 00:35:14,742
>> קהל: אז אם אתה הולך
[לא ברור], היית עושה -

715
00:35:14,742 --> 00:35:16,734
אני לא זוכר מה [לא ברור] היא הלולאה.

716
00:35:16,734 --> 00:35:21,380
הייתי לך $ quad סוגר אני?

717
00:35:21,380 --> 00:35:21,850
>> דוד י מלאן: בדיוק.

718
00:35:21,850 --> 00:35:23,100
כן, בדיוק.

719
00:35:23,100 --> 00:35:26,650

720
00:35:26,650 --> 00:35:27,900
>> ROB אודן: כל דבר אחר?

721
00:35:27,900 --> 00:35:31,350

722
00:35:31,350 --> 00:35:32,010
>> דוד י מלאן: בסדר.

723
00:35:32,010 --> 00:35:32,300
פשרות.

724
00:35:32,300 --> 00:35:38,290
אז היו צרורות של תשובות
אפשרי עבור כל אחד מאלה.

725
00:35:38,290 --> 00:35:40,510
היינו באמת רק מחפשים
משהו משכנע הפוך ו

726
00:35:40,510 --> 00:35:41,100
חיסרון.

727
00:35:41,100 --> 00:35:44,830
ומספר 16 שאל, אימות של משתמשים
קלט בצד לקוח, כמו עם JavaScript,

728
00:35:44,830 --> 00:35:47,280
במקום בצד השרת, כמו PHP.

729
00:35:47,280 --> 00:35:49,450
אז מה יתרון של
בצד הלקוח עושה?

730
00:35:49,450 --> 00:35:53,780
>> ובכן, אחד הדברים שהצענו הוא
כי לך להפחית את זמן האחזור, כי אתה

731
00:35:53,780 --> 00:35:56,750
לא צריך להטריד את הפנייה
שרת, שעלול לקחת כמה

732
00:35:56,750 --> 00:36:00,390
אלפיות שנייה או אפילו כמה שניות
על ידי הימנעות ושרק

733
00:36:00,390 --> 00:36:04,670
אימות הקלט בצד הלקוח של משתמשים על ידי
מפעילה מטפל בלהגיש ו

734
00:36:04,670 --> 00:36:06,650
רק בודק, האם הם מקלידים
משהו בשם?

735
00:36:06,650 --> 00:36:08,080
האם הם מקלידים משהו
לכתובת דואר אלקטרוני?

736
00:36:08,080 --> 00:36:10,950
האם הם בוחרים במעונות מ
התפריט הנפתח?

737
00:36:10,950 --> 00:36:14,360
>> אתה יכול לתת להם משוב מיידי
שימוש במחשב גיגה הרץ

738
00:36:14,360 --> 00:36:16,770
או מה שיש להם זה
דווקא על השולחן שלהם.

739
00:36:16,770 --> 00:36:19,310
אז זה רק משתמש טוב יותר
חווה בדרך כלל.

740
00:36:19,310 --> 00:36:24,460
אבל חיסרון של עושה בצד הלקוח
אימות, אם אתה עושה את זה גם בלי

741
00:36:24,460 --> 00:36:29,860
עושה אימות בצד השרת הוא כי
מישהו ביותר שיצא מCS50 יודע

742
00:36:29,860 --> 00:36:33,980
כי אתה יכול פשוט לשלוח את כל הנתונים שאתה רוצה
לשרת כל מספר הדרכים.

743
00:36:33,980 --> 00:36:37,030
למען האמת, ברוב כל דפדפן, אתה יכול
לחץ סביב בהגדרות ורק

744
00:36:37,030 --> 00:36:40,110
לכבות את JavaScript, שהיית,
לכן, להשבית כל צורה של

745
00:36:40,110 --> 00:36:41,080
אימות.

746
00:36:41,080 --> 00:36:44,460
>> אבל אתה גם אולי זוכר שאפילו אני
עשה כמה דברים מסתוריים בכיתה באמצעות

747
00:36:44,460 --> 00:36:47,790
Telnet ו בעצם מעמידים פן
להיות דפדפן על ידי שליחת גט

748
00:36:47,790 --> 00:36:49,240
בקשות לשרת.

749
00:36:49,240 --> 00:36:51,030
וזה בהחלט לא
באמצעות כל JavaScript.

750
00:36:51,030 --> 00:36:53,290
זה רק אני הקלדת פקודות
במקלדת.

751
00:36:53,290 --> 00:36:57,410
אז באמת, כל מתכנת בתוך מספיק
נוחות עם האינטרנט ו-HTTP

752
00:36:57,410 --> 00:37:01,690
יכול לשלוח את כל הנתונים שהוא או היא רוצה
לשרת ללא אימות.

753
00:37:01,690 --> 00:37:05,470
ואם השרת שלך אינו גם בדיקה,
האם הם נותנים לי שם, הוא

754
00:37:05,470 --> 00:37:08,930
למעשה כתובת דוא"ל חוקית זה, עשתה
הם בוחרים במעונות, אתה עלול בסופו

755
00:37:08,930 --> 00:37:12,800
עד החדרה מזויפת או סתם נתונים ריקים
לתוך מסד הנתונים שלך, שכנראה

756
00:37:12,800 --> 00:37:15,450
הוא לא הולך להיות דבר טוב אם
היית בהנחה שזה היה שם.

757
00:37:15,450 --> 00:37:16,770
>> אז זו מציאות מעצבן.

758
00:37:16,770 --> 00:37:19,890
אבל בצד הלקוח כללי,
האימות היא מצוינת.

759
00:37:19,890 --> 00:37:21,810
אבל זה אומר שעבודה כפליים.

760
00:37:21,810 --> 00:37:25,970
למרות שיש לעשות קיימת שונים
ספריות, ספריות JavaScript עבור

761
00:37:25,970 --> 00:37:28,830
למשל, שתעשה את זה הרבה,
הרבה פחות כאב ראש.

762
00:37:28,830 --> 00:37:31,940
ואתה יכול לעשות שימוש חוזר בחלק מהקוד
בצד שרת, בצד לקוח.

763
00:37:31,940 --> 00:37:35,980
אבל מבין שזה בדרך כלל
עבודה נוספת.

764
00:37:35,980 --> 00:37:36,415
כן.

765
00:37:36,415 --> 00:37:37,792
>> קהל: אז אם אנחנו רק
אמר פחות בטוח -

766
00:37:37,792 --> 00:37:39,205
>> דוד י מלאן: [צוחק]

767
00:37:39,205 --> 00:37:39,680
איכס.

768
00:37:39,680 --> 00:37:43,105
אלה הם תמיד קשים יותר
אלה לפסוק.

769
00:37:43,105 --> 00:37:44,480
>> ROB אודן: זה יהיה
כבר קיבל.

770
00:37:44,480 --> 00:37:44,810
>> דוד י מלאן: מה?

771
00:37:44,810 --> 00:37:45,810
>> ROB אודן: אני יצרתי את הבעיה הזו.

772
00:37:45,810 --> 00:37:46,735
שהיה מתקבל.

773
00:37:46,735 --> 00:37:47,220
>> דוד י מלאן: כן.

774
00:37:47,220 --> 00:37:47,830
>> קהל: מגניב.

775
00:37:47,830 --> 00:37:51,770
>> ROB אודן: אבל אנחנו לא קיבלנו
לראשון -

776
00:37:51,770 --> 00:37:53,630
כן, מה שאנחנו מחפשים הוא
משהו כמו שאתה לא צריך

777
00:37:53,630 --> 00:37:55,270
לתקשר עם השרת.

778
00:37:55,270 --> 00:37:58,355
אנחנו לא קיבלנו רק מהר יותר.

779
00:37:58,355 --> 00:38:00,080
>> קהל: מה עם
לא לטעון מחדש את הדף?

780
00:38:00,080 --> 00:38:00,430
>> ROB אודן: כן.

781
00:38:00,430 --> 00:38:03,000
זה היה תשובה מקובלת.

782
00:38:03,000 --> 00:38:06,300
>> דוד י מלאן: כל דבר שבו אנו חשים
זה היה יותר סביר מאשר לא סביר

783
00:38:06,300 --> 00:38:09,780
כי אתה ידעת מה שהיית
אומר, שהוא קשה

784
00:38:09,780 --> 00:38:13,500
שורה לצייר לפעמים.

785
00:38:13,500 --> 00:38:16,000
שימוש ברשימה מקושרת במקום
של מערך כדי לשמור על

786
00:38:16,000 --> 00:38:17,590
מסודרים על הרשימה של מספרים שלמים.

787
00:38:17,590 --> 00:38:21,000
אז הפוך לעתים קרובות אנו לצטט עם מקושרים
רשימות שהניעו את כולם

788
00:38:21,000 --> 00:38:22,370
הקדמה הייתה לך לקבל את הדינמיות.

789
00:38:22,370 --> 00:38:23,030
הם יכולים לגדול.

790
00:38:23,030 --> 00:38:23,950
הם יכולים להתכווץ.

791
00:38:23,950 --> 00:38:27,370
אז אתה לא צריך לקפוץ דרך חישוקים
למעשה ליצור יותר זיכרון

792
00:38:27,370 --> 00:38:28,140
עם מערך.

793
00:38:28,140 --> 00:38:30,310
או שאין לך פשוט
אומר, סליחה, משתמש.

794
00:38:30,310 --> 00:38:31,410
המערך מלא.

795
00:38:31,410 --> 00:38:35,850
צמיחה כל כך דינמית של הרשימה.

796
00:38:35,850 --> 00:38:37,210
חיסרון אף של רשימות מקושרות?

797
00:38:37,210 --> 00:38:40,916

798
00:38:40,916 --> 00:38:43,356
>> קהל: זה ליניארי.

799
00:38:43,356 --> 00:38:45,800
חיפוש ברשימה מקושרת הוא ליניארי
במקום מה שאתה נכנסת פנימה

800
00:38:45,800 --> 00:38:46,360
>> דוד י מלאן: בדיוק.

801
00:38:46,360 --> 00:38:50,160
חיפוש ברשימה מקושרת הוא ליניארי,
גם אם זה מסודרים, כי אתה יכול

802
00:38:50,160 --> 00:38:53,170
רק לעקוב אחר פירורי לחם אלה, אלה
מצביעים, מההתחלה של הרשימה

803
00:38:53,170 --> 00:38:53,570
עד הסוף.

804
00:38:53,570 --> 00:38:57,970
אתה לא יכול למנף את גישה ואקראית,
וכך, חיפוש בינארי, אפילו אם זה

805
00:38:57,970 --> 00:39:00,740
מסודרים, כי אתה יכול
לעשות עם מערך.

806
00:39:00,740 --> 00:39:02,390
ויש גם עלות נוספת.

807
00:39:02,390 --> 00:39:02,966
כן.

808
00:39:02,966 --> 00:39:03,800
>> קהל: זיכרון לא יעיל?

809
00:39:03,800 --> 00:39:04,130
>> דוד י מלאן: כן.

810
00:39:04,130 --> 00:39:06,940
ובכן, לא הייתי בהכרח
אומר לא יעיל.

811
00:39:06,940 --> 00:39:10,110
אבל זה יעלה לך יותר זיכרון,
כי אתה צריך 32 סיביות לכל

812
00:39:10,110 --> 00:39:13,400
צומת למצביע נוסף, ב
לפחות לרשימה מקושרת ביחידים.

813
00:39:13,400 --> 00:39:16,660
עכשיו, אם אתה אחסון רק מספרים שלמים ו
אתה מוסיף את המצביע, זה

814
00:39:16,660 --> 00:39:17,830
למעשה סוג של לא טריוויאלית.

815
00:39:17,830 --> 00:39:19,340
זה מכפיל את כמות הזיכרון.

816
00:39:19,340 --> 00:39:22,330
אבל במציאות, אם אתה אחסון
רשימה מקושרת של מבנים שאולי יש לי

817
00:39:22,330 --> 00:39:25,540
8 בתים, 16 בתים, אפילו יותר
יותר מזה, אולי זה פחות

818
00:39:25,540 --> 00:39:26,500
של עלות שולית.

819
00:39:26,500 --> 00:39:28,320
אבל זה עלות בכל זאת.

820
00:39:28,320 --> 00:39:31,880
אז או של אלה שיש לי
היה בסדר כל חסרונות.

821
00:39:31,880 --> 00:39:32,110
>> 18.

822
00:39:32,110 --> 00:39:36,100
שימוש ב-PHP במקום C לכתוב
תכנית של שורת הפקודה.

823
00:39:36,100 --> 00:39:41,890
אז הנה, זה בדרך כלל מהיר יותר לשימוש
שפה כמו PHP או Ruby או Python.

824
00:39:41,890 --> 00:39:43,700
אתה פשוט לפתוח במהירות
עד עורך טקסט.

825
00:39:43,700 --> 00:39:45,900
יש לך הרבה יותר פונקציות
עומד לרשותך.

826
00:39:45,900 --> 00:39:49,325
PHP יש כיור המטבח של פונקציות,
ואילו ב-C, אתה

827
00:39:49,325 --> 00:39:50,420
יש לי מאוד, מעט מאוד.

828
00:39:50,420 --> 00:39:53,820
למעשה, החבר 'ה יודעת את הדרך הקשה
שאין לך שולחנות חשיש.

829
00:39:53,820 --> 00:39:55,000
אתה לא מצאת קשר בין רשימות.

830
00:39:55,000 --> 00:39:57,470
אם אתה רוצה אותם, שיש לך
ליישם אותם בעצמך.

831
00:39:57,470 --> 00:40:00,950
>> אז הפוך אחד של PHP או בעצם כל
שפה פירשה היא המהירות

832
00:40:00,950 --> 00:40:02,920
שבה אתה יכול לכתוב קוד.

833
00:40:02,920 --> 00:40:06,660
אבל חיסרון, ראינו את זה כשאני
קצפת במהירות misspeller

834
00:40:06,660 --> 00:40:11,780
יישום בהרצאה באמצעות PHP, הוא
כי שימוש בשפה פירשה

835
00:40:11,780 --> 00:40:13,570
הוא בדרך כלל איטי יותר.

836
00:40:13,570 --> 00:40:18,420
וראינו שאופן מובהק עם
להגדיל בזמן מ0.3 שניות עד 3

837
00:40:18,420 --> 00:40:24,440
שניות, בגלל הפרשנות
מה שקורה בפועל.

838
00:40:24,440 --> 00:40:27,060
>> הפוך נוסף היה שאתה
לא צריך לקמפל.

839
00:40:27,060 --> 00:40:30,130
אז זה גם מאיץ את פיתוח
אגב, בגלל שאין לך

840
00:40:30,130 --> 00:40:31,360
שני צעדים להפעלת תכנית.

841
00:40:31,360 --> 00:40:32,140
פשוט יש לך אחד.

842
00:40:32,140 --> 00:40:35,260
ואז זה די
משכנע גם כן.

843
00:40:35,260 --> 00:40:38,450
שימוש במסד נתוני SQL במקום
קובץ CSV לאחסון נתונים.

844
00:40:38,450 --> 00:40:40,230
מסד הנתונים אז SQL משמש לpset7.

845
00:40:40,230 --> 00:40:42,060
קבצי CSV לא השתמשו הרבה.

846
00:40:42,060 --> 00:40:45,960
אבל אתה השתמשת בו באופן עקיף בpset7 כמו
היטב על ידי מדבר עם Yahoo Finance.

847
00:40:45,960 --> 00:40:49,330
>> אבל CSV הוא בדיוק כמו קובץ Excel, אך
סופר פשוט, שבו העמודות

848
00:40:49,330 --> 00:40:54,010
רק demarked בפסיקים בתוך
של אחרת קובץ טקסט.

849
00:40:54,010 --> 00:40:56,740
ומשתמש במסד נתוני SQL הוא
קצת יותר משכנע.

850
00:40:56,740 --> 00:41:00,060
זה הפוך, כי אתה מקבל דברים
כמו לבחור ולהוסיף ולמחוק.

851
00:41:00,060 --> 00:41:03,790
ואתה מקבל, ככל הנראה, מאינדקסים ש
MySQL ומסדי נתונים אחרים, כמו

852
00:41:03,790 --> 00:41:07,510
אורקל, לבנות לך בזיכרון, אשר
משמעות הדבר היא הבחירה שלך היא כנראה לא

853
00:41:07,510 --> 00:41:09,000
הולך להיות ראש ליניארי לתחתית.

854
00:41:09,000 --> 00:41:11,300
זה באמת הולך להיות משהו
כמו חיפוש או משהו בינארי

855
00:41:11,300 --> 00:41:12,520
דומה ברוחן.

856
00:41:12,520 --> 00:41:13,930
ולכן הם בדרך כלל מהר יותר.

857
00:41:13,930 --> 00:41:16,040
>> אבל חיסרון הוא ש
זה רק יותר עבודה.

858
00:41:16,040 --> 00:41:16,730
זה יותר מאמץ.

859
00:41:16,730 --> 00:41:18,140
אתה צריך להבין מסדי נתונים.

860
00:41:18,140 --> 00:41:18,940
אתה צריך להגדיר את זה.

861
00:41:18,940 --> 00:41:20,840
אתה צריך שרת לרוץ
מסד נתונים שעל.

862
00:41:20,840 --> 00:41:22,750
אתה צריך להבין
איך להגדיר את זה.

863
00:41:22,750 --> 00:41:24,930
אז אלה הם רק אלה
סוגים של פשרות.

864
00:41:24,930 --> 00:41:27,860
ואילו קובץ CSV, שאתה יכול
ליצור אותו עם gedit.

865
00:41:27,860 --> 00:41:28,770
ואתה טוב ללכת.

866
00:41:28,770 --> 00:41:31,550
אין מורכבות מעבר לכך.

867
00:41:31,550 --> 00:41:34,870
>> באמצעות הגיבורים במקום שולחן חשיש
עם שרשור נפרד לאחסון

868
00:41:34,870 --> 00:41:37,490
מילון של מילות המזכירות
של pset5.

869
00:41:37,490 --> 00:41:42,480
אז מנסה הפוך, בתאוריה
לפחות, זה מה?

870
00:41:42,480 --> 00:41:46,380
זמן קבוע, לפחות אם אתה
וליבון בכל הפרט

871
00:41:46,380 --> 00:41:48,990
אותיות במילה, כמוך
אולי יש לpset5.

872
00:41:48,990 --> 00:41:52,720
זה יכול להיות חמישה אלגוריתמים Hash, שש
hashes אם יש חמש או שש

873
00:41:52,720 --> 00:41:53,900
אותיות במילה.

874
00:41:53,900 --> 00:41:54,580
וזה די טוב.

875
00:41:54,580 --> 00:41:56,910
ואם יש חסם עליון על איך
עוד המילים שלך עשויות להיות, זה

876
00:41:56,910 --> 00:41:59,320
זמן אכן asymptotically קבוע.

877
00:41:59,320 --> 00:42:05,180
>> ואילו שולחן חשיש עם נפרד
שרשור, הבעיה שיש עם זה

878
00:42:05,180 --> 00:42:09,070
סוג של מבנה הנתונים הוא כי
ביצועים של האלגוריתמים שלך בדרך כלל

879
00:42:09,070 --> 00:42:12,700
תלוי במספר הדברים
כבר במבנה הנתונים.

880
00:42:12,700 --> 00:42:15,660
וזה בהחלט המקרה עם
שרשרות, לפיה יותר את הדברים שהכנסתם

881
00:42:15,660 --> 00:42:18,800
לשולחן חשיש, עוד אלה
הרשתות ילכו, מה שאומר במקרה הרע

882
00:42:18,800 --> 00:42:21,960
מקרה, הדבר שאתה יכול להיות מחפש
הוא את כל הדרך בסוף אחד

883
00:42:21,960 --> 00:42:26,000
חלק מרשתות אלה, אשר למעשה
מוטל למשהו ליניארי.

884
00:42:26,000 --> 00:42:29,450
>> עכשיו, בפועל, זה בהחלט יכול
להיות במקרה זה עם שולחן חשיש

885
00:42:29,450 --> 00:42:32,820
רשתות מהירות יותר ממקביל
יישום הגיבורים.

886
00:42:32,820 --> 00:42:35,570
אבל זה מסיבות שונות, בין
שניסיונותיהם להשתמש בהמון

887
00:42:35,570 --> 00:42:39,240
זיכרון שיכול, למעשה, את הדברים לאט
למטה, כי אתה לא מקבל נחמד

888
00:42:39,240 --> 00:42:42,410
יתרונות של משהו שנקרא במטמון,
שבו דברים שהם קרובים זה לזה

889
00:42:42,410 --> 00:42:45,420
לזכרו ניתן לגשת
לעתים קרובות יותר במהירות.

890
00:42:45,420 --> 00:42:48,180
ולפעמים אתה יכול לבוא עם
פונקציית hash ממש טובה.

891
00:42:48,180 --> 00:42:51,060
גם אם אתה צריך לבזבז קצת
זיכרון, ייתכן, אכן, להיות מסוגל

892
00:42:51,060 --> 00:42:54,430
למצוא מהר ולא דברים
גרוע כמו באופן ליניארי.

893
00:42:54,430 --> 00:42:58,410
>> אז בקיצור, לא היה בהכרח
עם כל אחד אלה או אפילו שתיים

894
00:42:58,410 --> 00:43:00,050
דברים ספציפיים שאנחנו מחפשים.

895
00:43:00,050 --> 00:43:03,080
באמת שום דבר משכנע
כהפוך וחסרון

896
00:43:03,080 --> 00:43:04,800
בדרך כלל תפס את העין שלנו.

897
00:43:04,800 --> 00:43:11,840
>> ROB אודן: אז להפוך, שעשינו
לא קיבל על עצמו "מהר יותר." אתה

898
00:43:11,840 --> 00:43:14,540
היה לי לומר משהו על זה.

899
00:43:14,540 --> 00:43:17,910
גם אם אתה אמר באופן תיאורטי יותר מהר,
ידעת שאתה סוג של הבין

900
00:43:17,910 --> 00:43:19,470
שזה 0 של 1.

901
00:43:19,470 --> 00:43:22,820
ושולחן חשיש, בתאוריה,
הוא לא 0 של 1.

902
00:43:22,820 --> 00:43:26,550
להזכיר משהו על ריצה
בדרך כלל יש לך הנקודות.

903
00:43:26,550 --> 00:43:32,640
אבל "מהר יותר," רוב הפתרונות על
הלוח הגדול שהיו מנסה היו

904
00:43:32,640 --> 00:43:34,990
אובייקטיבי איטי יותר מאשר פתרונות
שהיו שולחנות חשיש.

905
00:43:34,990 --> 00:43:37,250
אז מהר יותר ובעצמו
לא ממש נכון.

906
00:43:37,250 --> 00:43:41,550

907
00:43:41,550 --> 00:43:44,380
>> דוד י מלאן: דום דה dom dom.

908
00:43:44,380 --> 00:43:46,686
אני כנראה היחיד שמבין
ככה זה אמור

909
00:43:46,686 --> 00:43:47,500
להיות מבוטא, נכון?

910
00:43:47,500 --> 00:43:50,400
>> ROB אודן: היה לי מושג באמת.

911
00:43:50,400 --> 00:43:51,650
>> דוד י מלאן: זה גרם
תחושה בראש שלי.

912
00:43:51,650 --> 00:43:53,830

913
00:43:53,830 --> 00:43:57,580
>> ROB אודן: אני עושה את זה.

914
00:43:57,580 --> 00:43:58,020
על אישור.

915
00:43:58,020 --> 00:44:04,243
אז זה אחד שבו היה לך לצייר
התרשים הדומה לך אולי

916
00:44:04,243 --> 00:44:06,040
ראה בבחינות האחרונות.

917
00:44:06,040 --> 00:44:12,200
אז בואו פשוט להסתכל על זה.

918
00:44:12,200 --> 00:44:18,170
אז מצומת ה-HTML, יש לנו שני
ילדים, בראש ובגוף.

919
00:44:18,170 --> 00:44:20,570
אז אנחנו מתפצלים - ראש וגוף.

920
00:44:20,570 --> 00:44:22,280
יש ראש תג כותרת.

921
00:44:22,280 --> 00:44:23,710
אז יש לנו כותרת.

922
00:44:23,710 --> 00:44:28,450
>> עכשיו, הדבר אחד הרבה אנשים
שכח הוא שצומת של טקסט אלה

923
00:44:28,450 --> 00:44:30,430
גורמים בעץ הזה.

924
00:44:30,430 --> 00:44:36,260
אז הנה אנחנו לקרות כדי למשוך אותם כאליפסות
כדי להבדיל אותם מאלה

925
00:44:36,260 --> 00:44:37,380
סוגים של צמתים.

926
00:44:37,380 --> 00:44:41,450
אבל שימו לב גם כאן יש לנו בראש,
באמצע, וחלק תחתון יהיה בסופו של דבר להיות

927
00:44:41,450 --> 00:44:42,560
בלוטות לטקסט.

928
00:44:42,560 --> 00:44:46,250
אז שוכח אותם היה קצת
טעות נפוצה.

929
00:44:46,250 --> 00:44:48,770
>> לגוף יש שלושה ילדים -
שלושת אלמנטים div אלה.

930
00:44:48,770 --> 00:44:53,340
אז div, div, div ולאחר מכן את הטקסט
ילדי צומת של אלמנטים מהסוג div אלה.

931
00:44:53,340 --> 00:44:55,900
זה פחות או יותר אותו
לשאלות ש.

932
00:44:55,900 --> 00:44:57,860
>> דוד י מלאן: וזה ראוי לציין,
למרות שאנחנו לא להתעכב על אלה

933
00:44:57,860 --> 00:45:01,040
פרטים בזמן שאנחנו מבלים על
JavaScript, כי הצו עושה, ב

934
00:45:01,040 --> 00:45:02,290
למעשה, עניין טכני.

935
00:45:02,290 --> 00:45:06,330
אז אם הראש מגיע לפני הגוף ב
HTML, אז זה צריך להיראות

936
00:45:06,330 --> 00:45:08,860
שמאלי של גוף בDOM בפועל.

937
00:45:08,860 --> 00:45:12,265
כי שלו הוא, באופן כללי, רק לידיעתך,
משהו שנקרא סדר מסמך, שבו

938
00:45:12,265 --> 00:45:13,260
זה כן משנה.

939
00:45:13,260 --> 00:45:17,470
ואם היית מיישמים מנתח,
תכנית שקוראת ה-HTML בבנייה

940
00:45:17,470 --> 00:45:20,960
על העץ בזיכרון, אם להיות כנה,
זה כנראה מה שאתה באופן אינטואיטיבי

941
00:45:20,960 --> 00:45:24,720
לעשות בכל מקרה - מלמעלה למטה,
משמאל לימין.

942
00:45:24,720 --> 00:45:26,116
>> ROB אודן: שאלות על זה?

943
00:45:26,116 --> 00:45:29,080

944
00:45:29,080 --> 00:45:30,000
אני צריך לעשות הבא?

945
00:45:30,000 --> 00:45:32,380
>> דוד י מלאן: בטח.

946
00:45:32,380 --> 00:45:33,810
>> ROB אודן: אישור.

947
00:45:33,810 --> 00:45:39,320
אז זה הצפת המאגר
שאלת התקפה.

948
00:45:39,320 --> 00:45:43,740
הדבר העיקרי שיש להכיר כאן הוא,
כן, איך ייתכן טריק יריב

949
00:45:43,740 --> 00:45:46,170
תכנית זו לביצוע
קוד שרירותי?

950
00:45:46,170 --> 00:45:51,860
, שורת הפקודה הראשונה אז argv1
טיעון לתכנית זו, שיכול להיות

951
00:45:51,860 --> 00:45:53,920
ארוך באופן שרירותי.

952
00:45:53,920 --> 00:45:59,160
אבל כאן אנחנו משתמשים בה memcpy להעתיק
argv1, אשר כאן הוא הבר.

953
00:45:59,160 --> 00:46:00,165
אנחנו עוברים את זה כטיעון.

954
00:46:00,165 --> 00:46:02,050
ואז זה לוקח על השם בר.

955
00:46:02,050 --> 00:46:08,040
>> אז אנחנו memcpying הבר
למאגר ג זה.

956
00:46:08,040 --> 00:46:09,400
כמה בתים אנחנו מעתיקים?

957
00:46:09,400 --> 00:46:14,040
ובכן בר בתים אולם רב קורה לי
אשתמש, אורכו של טיעון זה.

958
00:46:14,040 --> 00:46:17,930
אבל ג הוא רחב רק 12 בתים.

959
00:46:17,930 --> 00:46:22,280
אז אם אנחנו הקלד טיעון שורת הפקודה
זה זמן רב יותר מאשר 12 בתים, אנחנו

960
00:46:22,280 --> 00:46:25,470
הולך לגלוש זה
חיץ מסוים.

961
00:46:25,470 --> 00:46:31,000
עכשיו, איך ייתכן שיריב להערים
תכנית להפעלת קוד שרירותית?

962
00:46:31,000 --> 00:46:34,910
>> אז לזכור כי כאן
עיקרי הוא קורא foo.

963
00:46:34,910 --> 00:46:37,340
וכן לאחר מכן שיחות עיקריות foo.

964
00:46:37,340 --> 00:46:40,408
בואו לצייר את זה.

965
00:46:40,408 --> 00:46:44,720

966
00:46:44,720 --> 00:46:46,990
אז יש לנו הערימה שלנו.

967
00:46:46,990 --> 00:46:49,090
ועיקרי יש מסגרת מחסנית
בתחתית.

968
00:46:49,090 --> 00:46:51,860

969
00:46:51,860 --> 00:46:53,250
בשלב מסוים, שיחות עיקריות foo.

970
00:46:53,250 --> 00:46:55,390
ובכן, באופן מיידי, שיחות עיקריות foo.

971
00:46:55,390 --> 00:46:57,130
וכך foo מקבל מסגרתו של המחסנית.

972
00:46:57,130 --> 00:46:59,650

973
00:46:59,650 --> 00:47:02,220
>> עכשיו, בשלב מסוים, foo
הוא הולך לחזור.

974
00:47:02,220 --> 00:47:06,810
והלכתי חוזר foo, אנחנו צריכים לדעת על
מה שורת קוד הפנימית שלנו עיקרי

975
00:47:06,810 --> 00:47:10,610
היו כדי לדעת איפה
אנחנו צריכים לחדש בראשיים.

976
00:47:10,610 --> 00:47:13,100
אנחנו יכולים לקרוא foo מכל
חבורה של מקומות שונים.

977
00:47:13,100 --> 00:47:14,620
איך אנחנו יודעים לאן לחזור?

978
00:47:14,620 --> 00:47:16,460
ובכן, אנחנו צריכים לאחסן איפשהו ש.

979
00:47:16,460 --> 00:47:23,010
>> אז איפשהו ממש כאן בסביבה, אנו מאחסנים
שבו אנחנו צריכים לחזור לפעם אחת

980
00:47:23,010 --> 00:47:24,070
חוזר foo.

981
00:47:24,070 --> 00:47:26,350
וזה הכתובה השולח.

982
00:47:26,350 --> 00:47:30,490
אז איך ייתכן שיריב לנצל
לכך היא העובדה כי

983
00:47:30,490 --> 00:47:37,550
חיץ ג זה מאוחסן, בוא
אומר, ממש כאן הוא ג.

984
00:47:37,550 --> 00:47:39,690
אז יש לנו 12 בתים לג.

985
00:47:39,690 --> 00:47:40,540
זה ג.

986
00:47:40,540 --> 00:47:43,030
וזו טבעת הערימה של foo.

987
00:47:43,030 --> 00:47:49,970
אז אם המשתמש הזדוני נכנס יותר
ביטים מ 12 או שהם נכנסים לפקודה

988
00:47:49,970 --> 00:47:54,570
טענה כי קו זה יותר מ 12
תווים, אז אנחנו הולכים

989
00:47:54,570 --> 00:47:57,540
הצפת מאגר זה.

990
00:47:57,540 --> 00:47:59,910
>> אנחנו יכולים להמשיך.

991
00:47:59,910 --> 00:48:02,220
ובשלב מסוים, אנחנו נגיע רחוק
די בכך שאנחנו מתחילים

992
00:48:02,220 --> 00:48:05,120
החלפת כתובת שולח זה.

993
00:48:05,120 --> 00:48:08,310
אז ברגע שאנחנו להחליף את כתובת השולח,
זה אומר שכאשר foo

994
00:48:08,310 --> 00:48:14,220
חוזר, אנחנו חוזרים לכל מקום
משתמש זדוני אומר לו על ידי

995
00:48:14,220 --> 00:48:19,490
מה ערך שהיא נכנסה, על ידי מה
תווים שהמשתמש נכנסו.

996
00:48:19,490 --> 00:48:24,320
ולכן אם המשתמש הזדוני הוא להיות
חכם במיוחד, הוא יכול לקבל את זה

997
00:48:24,320 --> 00:48:29,255
לחזור למקום כלשהו בprintDef
פונקציה או איפשהו בmalloc

998
00:48:29,255 --> 00:48:31,830
פונקציה, פשוט בכל מקום שרירותי.

999
00:48:31,830 --> 00:48:38,420
>> אבל עוד יותר חכם הוא מה אם יש לו
המשתמש לחזור לכאן.

1000
00:48:38,420 --> 00:48:41,920
ואז אתה מתחיל מבצע
אלה כשורות של קוד.

1001
00:48:41,920 --> 00:48:46,610
ולכן בשלב זה, המשתמש יכול להזין
מה שהוא רוצה לאזור זה.

1002
00:48:46,610 --> 00:48:52,210
ויש לו שליטה מלאה
על התכנית שלך.

1003
00:48:52,210 --> 00:48:53,460
שאלות על זה?

1004
00:48:53,460 --> 00:48:56,380

1005
00:48:56,380 --> 00:49:00,970
אז השאלה הבאה היא מלאה
reimplementation של foo בצורה כזאת

1006
00:49:00,970 --> 00:49:02,620
שזה כבר לא פגיע.

1007
00:49:02,620 --> 00:49:03,870
>> אז יש כמה דרכים
אתה יכול לעשות את זה.

1008
00:49:03,870 --> 00:49:10,900

1009
00:49:10,900 --> 00:49:13,330
עדיין יש לנו ג בלבד
להיות באורך 12.

1010
00:49:13,330 --> 00:49:16,480
אתה היה יכול לשנות את זה
כחלק מהפתרון שלך.

1011
00:49:16,480 --> 00:49:18,930
אנחנו גם הוספנו סימון כדי להפוך
בר בטוח שלא היה ריק.

1012
00:49:18,930 --> 00:49:24,460
למרות שאתה לא צריך
כי לזיכוי מלא.

1013
00:49:24,460 --> 00:49:27,690
אז אנחנו בודקים ראשון
אורך מחרוזת של בר.

1014
00:49:27,690 --> 00:49:31,650
אם זה יותר מ 12, ולאחר מכן
לא ממש עושה את העותק.

1015
00:49:31,650 --> 00:49:33,010
אז זו דרך אחת לתקן את זה.

1016
00:49:33,010 --> 00:49:36,750
>> דרך נוספת של תיקון היא במקום
יש ג יהיה רק ​​של אורך 12, יש לו

1017
00:49:36,750 --> 00:49:39,310
להיות strlen אורך (בר).

1018
00:49:39,310 --> 00:49:43,370
דרך נוספת של תיקון זה היא
לבעצם רק לחזור.

1019
00:49:43,370 --> 00:49:46,690
אז אם אתה זה עתה נפטרת מכל
זה, אם אתה רק מחקת את כל

1020
00:49:46,690 --> 00:49:51,830
שורות של קוד, אתה היה מקבל
קרדיט מלא, שכן פונקציה זו

1021
00:49:51,830 --> 00:49:54,150
לא ממש להשיג משהו.

1022
00:49:54,150 --> 00:49:57,650
זה העתקת של שורת הפקודה
ויכוח לכמה מערך ב

1023
00:49:57,650 --> 00:49:59,960
מסגרת הערימה המקומית שלה.

1024
00:49:59,960 --> 00:50:01,310
ואז הדבר חוזר.

1025
00:50:01,310 --> 00:50:04,020
וכל מה שהשיג, הוא נעלם.

1026
00:50:04,020 --> 00:50:09,740
אז תמורה הייתה גם מספיק
דרך לקבל זיכוי מלא.

1027
00:50:09,740 --> 00:50:13,425
>> דוד י מלאן: לא די הרוח
השאלה אך מקובלת ל

1028
00:50:13,425 --> 00:50:15,580
spec בכל זאת.

1029
00:50:15,580 --> 00:50:18,260
>> ROB אודן: שאלות על כל זה?

1030
00:50:18,260 --> 00:50:22,270
דבר אחד שאתה לפחות
צריך להיות הידור קוד.

1031
00:50:22,270 --> 00:50:24,810
אז למרות שהמבחינה טכנית אתה לא
פגיע אם הקוד שלך לא

1032
00:50:24,810 --> 00:50:29,130
לקמפל, אנחנו לא מקבלים את זה.

1033
00:50:29,130 --> 00:50:31,350
אין שאלות?

1034
00:50:31,350 --> 00:50:33,320
על אישור.

1035
00:50:33,320 --> 00:50:34,580
>> דוד י מלאן: האם אתה רוצה
לומר בתואר הזה?

1036
00:50:34,580 --> 00:50:37,230
>> ROB אודן: מס

1037
00:50:37,230 --> 00:50:40,470
>> דוד י מלאן: אז בזה, זה
היה או חדשות טובות או חדשות רעות.

1038
00:50:40,470 --> 00:50:43,870
זה ממש את אותה הבעיה
כחידון הראשון.

1039
00:50:43,870 --> 00:50:46,140
וזה כמעט אותו הדבר
בעיה כמו pset1.

1040
00:50:46,140 --> 00:50:49,980
אבל זה היה פשוט יותר במכוון להיות
פירמידה פשוטה יותר, אחד שיכול להיות

1041
00:50:49,980 --> 00:50:52,330
פתרתי עם מעט
איטרציה פשוטה יותר.

1042
00:50:52,330 --> 00:50:55,680
ובאמת, מה אנחנו מקבלים ב
כאן לא היה כל כך הרבה ההיגיון,

1043
00:50:55,680 --> 00:50:58,100
משום שככל הנראה, בשלב הזה, אתה
יותר נוח ממה שהייתם

1044
00:50:58,100 --> 00:51:01,850
בשבוע אחד עם לולאות או למה לולאות,
אבל באמת להקניט בנפרד כי

1045
00:51:01,850 --> 00:51:04,790
אתה מרגיש בנוח עם קטן
רעיון כי PHP היא לא רק על מה

1046
00:51:04,790 --> 00:51:05,290
תכנות.

1047
00:51:05,290 --> 00:51:07,820
זה באמת יכול לשמש כשפה
לכתוב תוכניות שורת הפקודה.

1048
00:51:07,820 --> 00:51:10,060
>> ואכן, זה מה שאנחנו מנסים
כדי למשוך את תשומת הלב שלך.

1049
00:51:10,060 --> 00:51:12,060
זוהי תכנית PHP שורת הפקודה.

1050
00:51:12,060 --> 00:51:16,690
אז קוד C כאן, נכון בזמן
ב-C, לא תתקן עבור PHP.

1051
00:51:16,690 --> 00:51:17,940
אבל את הקוד הוא באמת אותו הדבר.

1052
00:51:17,940 --> 00:51:21,720
אם להשוות את הפתרונות לחידון
0 נגד 1 חידון, אתה תמצא כי

1053
00:51:21,720 --> 00:51:25,630
זה כמעט זהה, למעט
כמה סימני דולר ועבור

1054
00:51:25,630 --> 00:51:27,250
היעדרם של נתונים מסוג.

1055
00:51:27,250 --> 00:51:31,720
בפרט, אם אנחנו נסתכל כאן,
אתה תראה שאנחנו לחזר, בזה

1056
00:51:31,720 --> 00:51:33,730
מקרה, החל מיום 1 עד עד 7.

1057
00:51:33,730 --> 00:51:34,910
>> אנחנו יכולים לעשות את זה 0 מדד.

1058
00:51:34,910 --> 00:51:37,320
אבל לפעמים, אני חושב שזה פשוט
קל יותר מבחינה נפשית לחשוב על דברים

1059
00:51:37,320 --> 00:51:38,200
מ 1 עד 7.

1060
00:51:38,200 --> 00:51:40,300
אם אתה רוצה בלוק אחד, אז שני
בלוקים, ולאחר מכן שלוש, ולאחר מכן

1061
00:51:40,300 --> 00:51:41,770
נקודה, נקודה, נקודה שבע.

1062
00:51:41,770 --> 00:51:45,960
יש לנו י שמאותחל ל 1
ולאחר מכן בונה על עד i.

1063
00:51:45,960 --> 00:51:48,150
והכל כאן
מלבד זאת היא זהה.

1064
00:51:48,150 --> 00:51:49,790
אבל ראוי לציון הם
כמה דברים.

1065
00:51:49,790 --> 00:51:53,230
אנו נותנים לכם שתי שורות אלה, זה ראשון
אחד, בשם goofily כעסק

1066
00:51:53,230 --> 00:51:54,560
למפץ חד.

1067
00:51:54,560 --> 00:51:58,770
וזה רק מציין את הנתיב,
תיקייה, שבתכנית יכולה להיות

1068
00:51:58,770 --> 00:52:02,160
מצא כי ברצונך להשתמש
לפרש קובץ זה.

1069
00:52:02,160 --> 00:52:04,710
>> ולאחר מכן את הקו אחרי זה, של
כמובן, משמעות הדבר היא להיכנס למצב PHP.

1070
00:52:04,710 --> 00:52:07,740
ואת השורה בתחתית מאוד
משמעות מצב PHP היציאה.

1071
00:52:07,740 --> 00:52:09,740
וזה עובד, באופן כללי, עם
פירש שפות.

1072
00:52:09,740 --> 00:52:14,370
זה סוג של מעצבן אם אתה כותב
תכנית בקובץ שנקרא foo.php.

1073
00:52:14,370 --> 00:52:17,320
ולאחר מכן יש למשתמשים שלך פשוט
זוכר, בסדר, להפעיל תכנית זו, אני

1074
00:52:17,320 --> 00:52:22,320
צריך להקליד "foo.php חלל PHP." סוג
של מעצבן אם לא שום דבר אחר.

1075
00:52:22,320 --> 00:52:25,270
והוא גם מגלה כי התכנית שלך
כתוב ב-PHP, וזה לא כל

1076
00:52:25,270 --> 00:52:27,060
שתאורה למשתמש.

1077
00:52:27,060 --> 00:52:30,100
>> כדי שתוכל להסיר. Php לגמרי
זוכר מהרצאה.

1078
00:52:30,100 --> 00:52:35,690
ואתה באמת יכול לעשות. / Foo אם
שchmodded בכך שהוא

1079
00:52:35,690 --> 00:52:36,500
הפעלה.

1080
00:52:36,500 --> 00:52:39,630
אז + x foo chmod היה עושה את זה.

1081
00:52:39,630 --> 00:52:41,460
ואם אתה גם להוסיף את העסק כאן.

1082
00:52:41,460 --> 00:52:45,320
אבל באמת, הבעיה הייתה מקבלת ב
הדפסה החוצה משהו כזה.

1083
00:52:45,320 --> 00:52:51,100
לא HTML, לא C-קוד בהחלט,
רק חלק PHP.

1084
00:52:51,100 --> 00:52:54,100
אז מילו ולאחר מכן חזר בבעיה 25.

1085
00:52:54,100 --> 00:52:58,050
וב25, אתה קיבל את הדברים הבאים
קוד שלד, שהיה

1086
00:52:58,050 --> 00:52:59,730
דף אינטרנט פשוט למדי.

1087
00:52:59,730 --> 00:53:04,230
והחלק העסיסי HTML החכם היה למטה
כאן, איפה שיש לנו בתוך הגוף

1088
00:53:04,230 --> 00:53:09,160
טופס הכולל זיהוי ייחודי של תשומות
בתוכה הייתה שתי כניסות, אחת

1089
00:53:09,160 --> 00:53:11,950
עם רעיון של שמו, אחד
עם רעיון של כפתור.

1090
00:53:11,950 --> 00:53:14,240
>> הראשון היה סוג טקסט,
שני מסוג submit.

1091
00:53:14,240 --> 00:53:16,930
וכך אנחנו נתנו לך, בעצם, יותר
מרכיבים ממה שאתה צורך, רק כדי

1092
00:53:16,930 --> 00:53:19,230
הייתה לך חבר 'ה אפשרויות שבה
כדי לפתור את הבעיה הזו.

1093
00:53:19,230 --> 00:53:21,130
אתה לא צריך בקפדנות
כל תעודות זהות של אלה.

1094
00:53:21,130 --> 00:53:23,580
אבל זה מאפשר לך לפתור
אותו בדרכים שונות.

1095
00:53:23,580 --> 00:53:27,050
ולמעלה בחלק העליון, שים לב כי
המטרה הייתה לעורר

1096
00:53:27,050 --> 00:53:27,960
חלון כזה -

1097
00:53:27,960 --> 00:53:28,780
הלו, מילו! -

1098
00:53:28,780 --> 00:53:31,270
לצוץ בדפדפן באמצעות
סופר פשוט, אם

1099
00:53:31,270 --> 00:53:33,190
פונקציה לא מכוערת, דרוכה.

1100
00:53:33,190 --> 00:53:37,480
וכך, סופו של דבר, זה מסתכם
מושגית להאזנה איכשהו ל

1101
00:53:37,480 --> 00:53:41,290
הגשות של הטופס בצד הלקוח
, לא בצד השרת, איכשהו

1102
00:53:41,290 --> 00:53:45,640
בתגובה להגשה שעל ידי
תופס את הערך שמשתמש הקליד

1103
00:53:45,640 --> 00:53:50,120
לשם השדה, ולאחר מכן
להציג אותה בגופו של התראה.

1104
00:53:50,120 --> 00:53:53,460
>> אז דרך אחת אתה יכול לעשות זאת היא עם
jQuery, שנראה קצת

1105
00:53:53,460 --> 00:53:56,880
מבחינה תחבירית מביך בהתחלה.

1106
00:53:56,880 --> 00:54:00,760
אתה יכול לעשות את זה עם קוד DOM טהור -
document.getelement לפי תעודת זהות.

1107
00:54:00,760 --> 00:54:02,530
אבל בואו נסתכל על גרסה זו.

1108
00:54:02,530 --> 00:54:05,110
יש לי כמה חשוב
השורות הראשונות.

1109
00:54:05,110 --> 00:54:09,460
אז אחד, יש לנו את הקו הזה, שהוא
זהה למה שאולי ראה

1110
00:54:09,460 --> 00:54:13,830
ב, אני מאמין, form2.html
מכיתה בשבוע 9.

1111
00:54:13,830 --> 00:54:16,960
וזה רק אומר, לבצע
הקוד הבא בעת

1112
00:54:16,960 --> 00:54:18,430
המסמך מוכן.

1113
00:54:18,430 --> 00:54:21,770
זה להיות חשוב רק בגלל
דפי HTML נקראים מלמעלה

1114
00:54:21,770 --> 00:54:23,280
למטה, משמאל לימין.

1115
00:54:23,280 --> 00:54:27,910
>> ולכן, אם אתה מנסה לעשות
משהו בקוד כאן לכמה DOM

1116
00:54:27,910 --> 00:54:31,560
אלמנט, כמה תג HTML, זה למטה
כאן, אתה עושה את זה מוקדם מדי,

1117
00:54:31,560 --> 00:54:34,220
בגלל זה יש לו אפילו לא
נקראו לזיכרון.

1118
00:54:34,220 --> 00:54:37,740
אז באומרו document.ready זה
קו, שאנחנו אומרים,

1119
00:54:37,740 --> 00:54:39,040
הנה קוד, דפדפן מסוים.

1120
00:54:39,040 --> 00:54:42,440
אבל לא מבצע את זה עד שכל
המסמך מוכן, כי הוא DOM

1121
00:54:42,440 --> 00:54:44,320
עץ קיים בזיכרון.

1122
00:54:44,320 --> 00:54:47,110
זה אחד הוא קצת יותר
פשוט, אם מבחינה תחבירית

1123
00:54:47,110 --> 00:54:51,890
קצת שונה, שבו אני אומר, לתפוס
אלמנט ה-HTML שייחודי

1124
00:54:51,890 --> 00:54:53,560
מזהה הוא תשומות.

1125
00:54:53,560 --> 00:54:56,220
זה מה שתג החשיש
מציין, את המזהה הייחודית.

1126
00:54:56,220 --> 00:54:58,070
ואז אני מתקשר. שליחה.

1127
00:54:58,070 --> 00:55:01,660
>> אז. להגיש כאן היא פונקציה, אחרת
הידועה בשם שיטה, זה

1128
00:55:01,660 --> 00:55:05,850
פנימי של האובייקט בצד שמאל היד
בצד יש שלא להדגיש.

1129
00:55:05,850 --> 00:55:08,990
אז אם אתה חושב על תשומות כאובייקט
בזיכרון - ואכן זה הוא.

1130
00:55:08,990 --> 00:55:10,440
זה צומת בעץ -

1131
00:55:10,440 --> 00:55:16,580
. להגיש באמצעות טופס זה כאשר עם
זיהוי זה הוגש, לבצע

1132
00:55:16,580 --> 00:55:17,700
את הקוד הבא.

1133
00:55:17,700 --> 00:55:20,290
לא אכפת לי מה שמו של
פונקציה היא שאני מבצע.

1134
00:55:20,290 --> 00:55:23,760
כאן אז אני משתמש, כמו קודם, מה זה
קרא לפונקציה למבדה או

1135
00:55:23,760 --> 00:55:24,720
פונקציה אנונימית.

1136
00:55:24,720 --> 00:55:27,640
זה בכלל לא מבחינה אינטלקטואלית
מעניין אחרים מאשר שאין לה שם,

1137
00:55:27,640 --> 00:55:30,220
וזה בסדר אם אתה רק
אי פעם הולך לקרוא את זה פעם אחת.

1138
00:55:30,220 --> 00:55:34,490
ובפנים יש לי בעצם להתמודד
הגשת הטופס.

1139
00:55:34,490 --> 00:55:36,810
אני מכריז על משתנה ראשון
בשם ערך.

1140
00:55:36,810 --> 00:55:40,610
ואז מה היא ההשפעה של זה
הדגיש חלק כאן עכשיו?

1141
00:55:40,610 --> 00:55:44,755
מה זה עושה ב
רמה גבוהה בשבילי?

1142
00:55:44,755 --> 00:55:48,539
>> קהל: הוא מקבל את הערך ש
משתמש לא עשה בקוד HTML שלהלן.

1143
00:55:48,539 --> 00:55:50,920
זה נהיה מזהה ושלאחר מכן
מוצא את הערך של זה.

1144
00:55:50,920 --> 00:55:51,590
>> דוד י מלאן: בדיוק.

1145
00:55:51,590 --> 00:55:54,300
זה תופס את הצומת, שייחודי
מזהה הוא שם.

1146
00:55:54,300 --> 00:55:56,900
הוא מקבל את הערך בו, שבו
הוא, ככל הנראה, מה שהמשתמש

1147
00:55:56,900 --> 00:55:58,190
הקליד אותו או את עצמה.

1148
00:55:58,190 --> 00:56:01,020
ואז הוא מאחסן שב
משתנים בשם ערך.

1149
00:56:01,020 --> 00:56:03,720
במאמר מוסגר, אפשר שיש לך גם
עשה את זה קצת אחר.

1150
00:56:03,720 --> 00:56:09,250
מקובל לחלוטין על ידי עושה משהו
מקבל ערך var השקר

1151
00:56:09,250 --> 00:56:10,500
document.getElementById.

1152
00:56:10,500 --> 00:56:12,860

1153
00:56:12,860 --> 00:56:15,460
וזו הסיבה לכך שזה קצת
משעמם לא להשתמש jQuery.

1154
00:56:15,460 --> 00:56:16,710
"שם". ערך.

1155
00:56:16,710 --> 00:56:18,330

1156
00:56:18,330 --> 00:56:19,620
אז לגמרי מתקבל על הדעת.

1157
00:56:19,620 --> 00:56:22,770
דרכים שונות לעשות את זה. jQuery פשוט
נוטה להיות קצת יותר תמציתי ו

1158
00:56:22,770 --> 00:56:25,230
בהחלט יותר פופולרי
בין מתכנתים.

1159
00:56:25,230 --> 00:56:27,590
>> עכשיו, אני עושה קצת שפיות
לבדוק, כי בבעיה

1160
00:56:27,590 --> 00:56:30,820
אמירה שאמרנו במפורש, אם
משתמש עדיין לא הוקלד או שלה

1161
00:56:30,820 --> 00:56:32,580
שם, לא מראה התראות.

1162
00:56:32,580 --> 00:56:35,390
אבל אתה יכול לבדוק את זה, רק על ידי
בדיקה למחרוזת הריקה עבור

1163
00:56:35,390 --> 00:56:37,850
כביכול הזאת אם יש
שום דבר לא באמת שם.

1164
00:56:37,850 --> 00:56:40,880
אבל אם זה לא שווה כביכול הזאת,
אני רוצה להתקשר התראות.

1165
00:56:40,880 --> 00:56:45,610
והחלק המעניין כאן הוא ש
אנו משתמשים למפעיל בתוספת, אשר

1166
00:56:45,610 --> 00:56:48,130
עושה מה ב-JavaScript?

1167
00:56:48,130 --> 00:56:48,740
לשרשר.

1168
00:56:48,740 --> 00:56:50,690
אז זה כמו מפעיל נקודת PHPs.

1169
00:56:50,690 --> 00:56:52,820
אותו רעיון, תחביר שונה במקצת.

1170
00:56:52,820 --> 00:56:55,280
ואני רק יוצר את המחרוזת ש
שראית בצילום המסך -

1171
00:56:55,280 --> 00:56:57,750
שלום, כך וכך.

1172
00:56:57,750 --> 00:56:59,200
>> ולאחר מכן הפרט האחרון הוא זה.

1173
00:56:59,200 --> 00:57:04,970
למה אני חוזר בתוך שקר
של פונקציה אנונימית זה?

1174
00:57:04,970 --> 00:57:07,420
>> קהל: אין שום ערך.

1175
00:57:07,420 --> 00:57:09,380
אתה שם אותו בטופס.

1176
00:57:09,380 --> 00:57:12,320

1177
00:57:12,320 --> 00:57:16,730
זה פשוט אומר, אם הערך אינו
שווה לריק, אז לעשות את זה.

1178
00:57:16,730 --> 00:57:20,040

1179
00:57:20,040 --> 00:57:20,940
היה ריק בהגשה ש.

1180
00:57:20,940 --> 00:57:21,170
>> דוד י מלאן: אישור.

1181
00:57:21,170 --> 00:57:21,640
זהירות אף.

1182
00:57:21,640 --> 00:57:22,830
אין אף אחד אחר כאן.

1183
00:57:22,830 --> 00:57:25,510
וששקר השיבה הוא מחוץ
של אם תנאים.

1184
00:57:25,510 --> 00:57:29,470
אז זה מודגש קו, בתמורת שווא,
מבצע לא משנה מה, כאשר

1185
00:57:29,470 --> 00:57:32,310
שליחת הטופס.

1186
00:57:32,310 --> 00:57:36,810
מה חוזר בתוך שווא של זה
מטפל באירועים, כפי שהוא נקרא,

1187
00:57:36,810 --> 00:57:38,450
האירוע מדובר
להיות הגשה?

1188
00:57:38,450 --> 00:57:42,350

1189
00:57:42,350 --> 00:57:44,470
>> קהל: כי זה
קורה רק פעם אחת.

1190
00:57:44,470 --> 00:57:45,320
>> דוד י מלאן: קורה רק פעם אחת.

1191
00:57:45,320 --> 00:57:46,821
לא ממש.

1192
00:57:46,821 --> 00:57:47,292
כן?

1193
00:57:47,292 --> 00:57:50,589
>> קהל: זה מונע את הטופס מ
הגשה להתנהגות ברירת המחדל,

1194
00:57:50,589 --> 00:57:52,480
אשר יגרום רענן הדף.

1195
00:57:52,480 --> 00:57:53,110
>> דוד י מלאן: בדיוק.

1196
00:57:53,110 --> 00:57:56,490
אז אני עומס יתר על הטווח להגיש כאן,
בגלל שאני אומר, את הטופס הוא

1197
00:57:56,490 --> 00:57:57,670
שהוגש.

1198
00:57:57,670 --> 00:58:02,240
אבל כפי שאתה מציע, זה בעצם לא
הוגש בדרך HTTP האמיתית.

1199
00:58:02,240 --> 00:58:06,870
לאחר הלחיצה על שלח, בגללנו
מטפל onsubmit, אנחנו יירוט

1200
00:58:06,870 --> 00:58:09,040
כי הגשת הטופס כביכול.

1201
00:58:09,040 --> 00:58:11,290
לאחר מכן, אנו עושים את הדבר שלנו
עם קוד JavaScript.

1202
00:58:11,290 --> 00:58:14,070
אבל אני בכוונה חוזר שווא,
כי מה שאני לא רוצה שקורה

1203
00:58:14,070 --> 00:58:18,430
שבריר שני לאחר מכן הוא לכל הצורה
עצמו שיוגש לאינטרנט

1204
00:58:18,430 --> 00:58:22,800
שרת עם זוגות ערך מפתח על ידי שינוי
את כתובת האתר צריך להיות משהו כמו

1205
00:58:22,800 --> 00:58:26,180
q = חתולים או כל דבר אחר שעשינו,
למשל, בכיתה.

1206
00:58:26,180 --> 00:58:29,640
אני לא רוצה שזה יקרה, כי
אין הקשבה שרת בשביל זה

1207
00:58:29,640 --> 00:58:30,690
טופס הגשה.

1208
00:58:30,690 --> 00:58:32,320
זה אך ורק לעשות זאת בקוד JavaScript.

1209
00:58:32,320 --> 00:58:35,760
ובגלל זה אני אפילו לא
פעולה מייחסת הטופס שלי, בגלל שאני

1210
00:58:35,760 --> 00:58:38,870
לא מתכוון לזה כדי
אי פעם ללכת לשרת.

1211
00:58:38,870 --> 00:58:40,780
>> אז זה שהוא הגיש.

1212
00:58:40,780 --> 00:58:44,340
אבל אנחנו יירוט צורה ש
הגשה ומניעת ברירת המחדל

1213
00:58:44,340 --> 00:58:47,477
התנהגות, שבו היא למעשה
ללכת את כל הדרך לשרת.

1214
00:58:47,477 --> 00:58:48,730
>> קהל: אז לשמור אותו בצד לקוח.

1215
00:58:48,730 --> 00:58:49,780
>> דוד י מלאן: שמירה
זה בצד לקוח.

1216
00:58:49,780 --> 00:58:51,030
בדיוק נכון.

1217
00:58:51,030 --> 00:58:53,240

1218
00:58:53,240 --> 00:58:55,757
עד הבא היה שלי הו MySQL.

1219
00:58:55,757 --> 00:59:00,000

1220
00:59:00,000 --> 00:59:00,430
>> ROB אודן: אישור.

1221
00:59:00,430 --> 00:59:04,990
אז השאלה ראשונה זה הייתה בדרך כלל
מחוספס לאנשים.

1222
00:59:04,990 --> 00:59:07,270
למרות שמאוחר יותר אלה הלכו טובים יותר.

1223
00:59:07,270 --> 00:59:12,260
אז היית צריך לבחור את הנתונים הנכונים
סוגים עבור שתי עמודות אלה.

1224
00:59:12,260 --> 00:59:17,750
ושני אלה יש לי כמה
דברים עליהם כי

1225
00:59:17,750 --> 00:59:20,620
לעשות את הבחירה קשה.

1226
00:59:20,620 --> 00:59:24,430
אז int לא היה בתוקף
הקלד את מספר.

1227
00:59:24,430 --> 00:59:29,410
להיות חשבון 12 ספרות הסיבה
מספר, int הוא לא גדול מספיק כדי

1228
00:59:29,410 --> 00:59:31,070
לאחסן ספרות בסך הכל.

1229
00:59:31,070 --> 00:59:36,570
אז אפשרות חוקית הייתה גדולה
int אם אתה במקרה יודע את זה.

1230
00:59:36,570 --> 00:59:42,090
בחירה נוספת הייתה יכולה להיות
שדה תווים של אורך 12.

1231
00:59:42,090 --> 00:59:44,560
אז או של אלה היו עובד.

1232
00:59:44,560 --> 00:59:46,100
Int לא.

1233
00:59:46,100 --> 00:59:50,170
>> עכשיו, שיווי משקל, חושב לחזור pset7.

1234
00:59:50,170 --> 00:59:59,540
אז אנחנו משמשים במיוחד עשרוניים
לאחסן את הערך של מניות או -

1235
00:59:59,540 --> 01:00:00,550
>> דוד י מלאן: מזומן.

1236
01:00:00,550 --> 01:00:01,060
>> ROB אודן: מזומן.

1237
01:00:01,060 --> 01:00:05,710
אנחנו השתמשנו עשרוניים לאחסן כמות
מזומנים שיש לו כרגע את המשתמש.

1238
01:00:05,710 --> 01:00:10,950
אז הסיבה שאנחנו עושים את זה היא
כי, זכור, צף.

1239
01:00:10,950 --> 01:00:12,480
יש נקודה צפה בדייקנות.

1240
01:00:12,480 --> 01:00:18,200
זה לא יכול בדיוק לאחסן את המזומנים
ערכים כמו שאנחנו רוצים כאן.

1241
01:00:18,200 --> 01:00:23,630
אז עשרוני הוא מסוגלים בדיוק חנות
משהו, אומר, שני מקומות אחרי נקודה עשרונית.

1242
01:00:23,630 --> 01:00:27,630
לכן איזון, אנחנו רוצים את זה
להיות עשרוני ולא תצוף.

1243
01:00:27,630 --> 01:00:30,230
>> דוד י מלאן: וגם, מדי, אם כי
זה היה יכול להיות חכם באחר

1244
01:00:30,230 --> 01:00:32,760
הקשרים לחשוב, אולי זה
סיכוי לint.

1245
01:00:32,760 --> 01:00:34,420
אני פשוט לעקוב אחר
במטבעות אלו.

1246
01:00:34,420 --> 01:00:38,670
כי אנחנו במפורש הראו ברירת המחדל
ערך של להיות 100.00, כי

1247
01:00:38,670 --> 01:00:40,380
אומר שזה רק יכול להיות int.

1248
01:00:40,380 --> 01:00:45,310
ועידון נוסף מדי עם מספר
היה שזה לא היה אמור

1249
01:00:45,310 --> 01:00:46,180
להיות שאלה מכשילה.

1250
01:00:46,180 --> 01:00:49,860
אבל זוכר שint ב-MySQL,
כמו ב-C, לפחות ב

1251
01:00:49,860 --> 01:00:51,440
מכשיר, הוא 32 סיביות.

1252
01:00:51,440 --> 01:00:53,960
ולמרות שאנו לא מצפים לך
יודע בדיוק כמה ספרות ש

1253
01:00:53,960 --> 01:00:56,910
אמצעים, זוכר שהמספר הגדול ביותר
אתה יכול לייצג את פוטנציאל

1254
01:00:56,910 --> 01:01:00,710
עם מספר 32 סיביות הוא בערך מה?

1255
01:01:00,710 --> 01:01:02,760
>> מה מספר אנחנו תמיד אומרים?

1256
01:01:02,760 --> 01:01:04,530
2 ל32, וזה מה שפחות או יותר?

1257
01:01:04,530 --> 01:01:07,492

1258
01:01:07,492 --> 01:01:08,780
אתה לא צריך לדעת בדיוק.

1259
01:01:08,780 --> 01:01:10,580
אבל בערך הוא מועיל בחיים.

1260
01:01:10,580 --> 01:01:12,200
זה בערך 4 מליארד דולרים.

1261
01:01:12,200 --> 01:01:14,430
אז אנחנו כבר אמרו את זה כמה פעמים.

1262
01:01:14,430 --> 01:01:16,360
אני יודע שכבר אמרתי את זה כמה פעמים.

1263
01:01:16,360 --> 01:01:17,670
וזה בערך 4 מליארד דולרים.

1264
01:01:17,670 --> 01:01:19,710
וזה כלל טוב
אצבע לדעת.

1265
01:01:19,710 --> 01:01:21,880
אם יש לך 8 ביטים, 256
הוא מספר הקסם.

1266
01:01:21,880 --> 01:01:24,160
אם יש לך 32 ביטים, 4
מיליארדים פחות או יותר.

1267
01:01:24,160 --> 01:01:27,140
אז אם אתה פשוט לרשום 4 מליארד דולרים,
אתה תראה שזה פחות ספרות מ

1268
01:01:27,140 --> 01:01:30,970
12, מה שאומר שזה ברור שלא
מספיק הבעה כדי ללכוד

1269
01:01:30,970 --> 01:01:34,220
מספר חשבון 12 ספרות.

1270
01:01:34,220 --> 01:01:34,940
>> ROB אודן: אישור.

1271
01:01:34,940 --> 01:01:38,520
אז האחרים הלכו טובים יותר.

1272
01:01:38,520 --> 01:01:40,900
אז נניח שהבנק
מטיל 20 $ חודשיים

1273
01:01:40,900 --> 01:01:42,400
דמי אחזקה בכל החשבונות.

1274
01:01:42,400 --> 01:01:45,506
עם מה SQL שאילתה יכול הבנק
לנכות 20 $ מכל ספירה, גם אם

1275
01:01:45,506 --> 01:01:47,520
תוצאות כמה יתרות שליליות?

1276
01:01:47,520 --> 01:01:50,380
אז בעצם, יש ארבעה
סוגים עיקריים של שאילתות -

1277
01:01:50,380 --> 01:01:52,840
הכנס, בחר, לעדכן ולמחוק.

1278
01:01:52,840 --> 01:01:56,080
אז מה שאנחנו חושבים שאנחנו
הולך להשתמש כאן?

1279
01:01:56,080 --> 01:01:57,000
עדכון.

1280
01:01:57,000 --> 01:01:58,260
>> אז בואו נסתכל.

1281
01:01:58,260 --> 01:02:04,290

1282
01:02:04,290 --> 01:02:05,870
אז הנה אנחנו מעדכנים.

1283
01:02:05,870 --> 01:02:09,900
מה טבלה אנו מעדכנים את החשבונות?

1284
01:02:09,900 --> 01:02:11,670
אז לעדכן את החשבונות.

1285
01:02:11,670 --> 01:02:15,390
ולאחר מכן את התחביר, אומר, מה
בחשבונותיהם אנו מעדכנים?

1286
01:02:15,390 --> 01:02:19,520
ובכן, אנחנו קביעת איזון שווה
ערך הנוכחי של איזון מינוס 20.

1287
01:02:19,520 --> 01:02:22,860
אז זה יעדכן את כל השורות
בחשבונות, הפחתה

1288
01:02:22,860 --> 01:02:26,250
20 $ מהאיזון.

1289
01:02:26,250 --> 01:02:29,260
>> דוד י מלאן: טעות נפוצה כאן,
למרות שאנחנו לפעמים סלחנו לו,

1290
01:02:29,260 --> 01:02:32,990
היה למעשה יש קוד PHP כאן
קריאה לפונקצית השאילתה או לשים

1291
01:02:32,990 --> 01:02:35,460
מרכאות סביב כל מה ש
לא הייתי צריך להיות שם.

1292
01:02:35,460 --> 01:02:39,780
>> ROB אודן: זכור כי MySQL הוא
שפה נפרדת מ-PHP.

1293
01:02:39,780 --> 01:02:42,410
אנחנו במקרה כותבים MySQL ב-PHP.

1294
01:02:42,410 --> 01:02:46,180
ו-PHP אז הוא שולח אותו
מעל לשרת MySQL.

1295
01:02:46,180 --> 01:02:51,120
אבל אתה לא צריך PHP כדי
לתקשר עם שרת MySQL.

1296
01:02:51,120 --> 01:02:51,730
>> דוד י מלאן: בדיוק.

1297
01:02:51,730 --> 01:02:54,240
אז לא משתנה עם סימני דולר
צריך להיות בהקשר זה.

1298
01:02:54,240 --> 01:02:59,550
זה פשוט יכול לעשות את כל המתמטיקה
בתוך מסד הנתונים עצמו.

1299
01:02:59,550 --> 01:03:00,080
>> ROB אודן: אישור.

1300
01:03:00,080 --> 01:03:01,300
אז הבא בתור.

1301
01:03:01,300 --> 01:03:02,731
האם זה הבא?

1302
01:03:02,731 --> 01:03:03,210
כן.

1303
01:03:03,210 --> 01:03:06,570
אז עם מה SQL שאילתה יכול הבנק
לאחזר את מספרי החשבון שלה

1304
01:03:06,570 --> 01:03:09,300
הלקוחות העשירים ביותר, אלה עם
יתרות גדולות מ 1,000?

1305
01:03:09,300 --> 01:03:13,280
אז איזה מארבעת הסוגים העיקריים
אנחנו הולכים לרוצים כאן?

1306
01:03:13,280 --> 01:03:14,430
בחר.

1307
01:03:14,430 --> 01:03:16,650
אז אנחנו רוצים לבחור.

1308
01:03:16,650 --> 01:03:17,610
מה שאנחנו כן רוצים לבחור?

1309
01:03:17,610 --> 01:03:19,380
מה עמודה אנחנו רוצים לבחור?

1310
01:03:19,380 --> 01:03:20,970
אנחנו במיוחד נרצה
כדי לבחור מספר.

1311
01:03:20,970 --> 01:03:23,910
אבל אם אתה אמר כוכב, אנחנו
גם קיבל את זה.

1312
01:03:23,910 --> 01:03:25,820
>> אז תבחר מספר ממה ששולחן?

1313
01:03:25,820 --> 01:03:26,640
חשבונות.

1314
01:03:26,640 --> 01:03:28,370
ולאחר מכן את המצב שאנחנו רוצים?

1315
01:03:28,370 --> 01:03:30,140
איפה איזון גדול מ 1,000.

1316
01:03:30,140 --> 01:03:31,720
אנחנו גם קיבלנו יותר
או שווה.

1317
01:03:31,720 --> 01:03:35,230

1318
01:03:35,230 --> 01:03:36,190
האחרון.

1319
01:03:36,190 --> 01:03:42,940
עם מה SQL שאילתה יכול הבנק
קרוב, דהיינו, למחוק כל חשבון ש

1320
01:03:42,940 --> 01:03:44,480
יש איזון של 0 $?

1321
01:03:44,480 --> 01:03:47,620
אז איזה מארבעת אנחנו
הולך רוצים להשתמש?

1322
01:03:47,620 --> 01:03:48,320
מחיקה.

1323
01:03:48,320 --> 01:03:50,180
אז התחביר לזה?

1324
01:03:50,180 --> 01:03:51,890
מחיקה ממה ששולחן?

1325
01:03:51,890 --> 01:03:53,550
חשבונות.

1326
01:03:53,550 --> 01:03:55,790
ולאחר מכן את המצב שבו
אנחנו רוצים למחוק -

1327
01:03:55,790 --> 01:03:57,280
שבו איזון שווה אפס.

1328
01:03:57,280 --> 01:04:03,050
אז למחוק את כל השורות מחשבונות
שיתרתו היא אפס.

1329
01:04:03,050 --> 01:04:04,300
שאלות על כל אלה?

1330
01:04:04,300 --> 01:04:08,840

1331
01:04:08,840 --> 01:04:10,260
רוצה לעמוד בתור?

1332
01:04:10,260 --> 01:04:11,200
>> דוד י מלאן: מדריך תור.

1333
01:04:11,200 --> 01:04:17,110
אז בזה, לנו נתתי לך מעט
מבנה מוכר שבדקנו

1334
01:04:17,110 --> 01:04:20,450
קצת בכיתה לצד של structs,
שהיה נתונים

1335
01:04:20,450 --> 01:04:21,910
מבנה הקשורים ברוחו.

1336
01:04:21,910 --> 01:04:24,670
ההבדל אם כי עם תור הוא
שאנחנו צריכים לזכור שאיכשהו

1337
01:04:24,670 --> 01:04:27,900
היה בראש התור, במידה רבה
חלק כדי שנוכל להרוויח יותר

1338
01:04:27,900 --> 01:04:30,530
שימוש יעיל בזיכרון, לפחות
אם היינו משתמשים במערך.

1339
01:04:30,530 --> 01:04:35,460
>> מכיוון שזוכר, אם יש לנו מערך, אם,
למשל, זה מול

1340
01:04:35,460 --> 01:04:38,470
התור, אם אני מקבל לתוך התור כאן,
ואז מישהו מקבל בשורה

1341
01:04:38,470 --> 01:04:42,710
מאחוריי, מאחוריי, מאחוריי, ו
אדם אחד יוצא מהשורה, אתה

1342
01:04:42,710 --> 01:04:45,930
יכול, כפי שראינו חלק האנושי שלנו
מתנדב בכיתה, לכולם יש

1343
01:04:45,930 --> 01:04:47,100
לעבור בדרך זו.

1344
01:04:47,100 --> 01:04:50,880
אבל באופן כללי, לאחר שכולם עושים
משהו לא את השימוש הטוב ביותר של זמן

1345
01:04:50,880 --> 01:04:54,600
בתכנית, כי זה אומר שלך
אלגוריתם פועל במה

1346
01:04:54,600 --> 01:04:56,520
זמן ריצה אסימפטוטי?

1347
01:04:56,520 --> 01:04:57,420
זה ליניארי.

1348
01:04:57,420 --> 01:04:59,600
>> ואני מרגיש שזה סוג של טיפשים.

1349
01:04:59,600 --> 01:05:02,890
אם האדם הבא בתור הוא הבא
מי שאמור להיכנס ל

1350
01:05:02,890 --> 01:05:04,660
חנות, לא כל שיש להם
לנוע יחדיו.

1351
01:05:04,660 --> 01:05:08,200
רק תן לו האדם שיקטוף את
בבוא העת, למשל.

1352
01:05:08,200 --> 01:05:09,870
אז אנחנו יכולים לחסוך קצת זמן שם.

1353
01:05:09,870 --> 01:05:14,840
וכך לעשות את זה אם כי, אמצעי ש
שראש התור או

1354
01:05:14,840 --> 01:05:18,060
ראש התור הולך
בהדרגה לנוע עמוק יותר ויותר

1355
01:05:18,060 --> 01:05:23,340
לתוך המערך וסופו של דבר אולי
למעשה לעטוף אם אנו משתמשים

1356
01:05:23,340 --> 01:05:25,790
מערך לאחסון האנשים
בתור הזה.

1357
01:05:25,790 --> 01:05:28,390
אז אתה כמעט יכול לחשוב על
מערך כנתונים מעגליים

1358
01:05:28,390 --> 01:05:29,880
מבנה במובן הזה.

1359
01:05:29,880 --> 01:05:33,970
>> אז אתה איכשהו צריך לעקוב אחר
גודל שלו או באמת הסוף שלו

1360
01:05:33,970 --> 01:05:36,250
ואז שבו בתחילת שהוא.

1361
01:05:36,250 --> 01:05:39,490
אז אנחנו מציעים שאתה מצהיר
בתור אחד כזה, שיחות

1362
01:05:39,490 --> 01:05:41,330
q זה, רק מכתב אחד.

1363
01:05:41,330 --> 01:05:44,570
אז אנחנו מציעים שהחזית תהיה
אותחל לאפס וכי הגודל

1364
01:05:44,570 --> 01:05:45,470
להיות מאותחל לאפס.

1365
01:05:45,470 --> 01:05:47,770
>> אז עכשיו, אין שום דבר
בתוך התור ש.

1366
01:05:47,770 --> 01:05:50,910
ואנו מבקשים ממך להשלים את
יישום Enqueue להלן ב

1367
01:05:50,910 --> 01:05:55,250
כך שהפונקציה מוסיפה n ל
סוף q ולאחר מכן מחזיר אמת.

1368
01:05:55,250 --> 01:05:58,690
אבל אם q הוא מלא או שלילי,
פונקציה צריכה במקום לחזור שווא.

1369
01:05:58,690 --> 01:06:01,060
ואנחנו נתנו לך כמה
הנחות.

1370
01:06:01,060 --> 01:06:04,320
אבל הם לא ממש מבחינה תפקודית
רלוונטי, רק bool שקיים,

1371
01:06:04,320 --> 01:06:06,690
כי, מבחינה טכנית, bool לא
קיים ב-C, אלא אם אתה כולל

1372
01:06:06,690 --> 01:06:07,310
קובץ כותרת מסוים.

1373
01:06:07,310 --> 01:06:09,350
אז זה היה רק ​​לוודא שיש
היו לא הוא זה טריק

1374
01:06:09,350 --> 01:06:10,940
סוג השאלה של דבר.

1375
01:06:10,940 --> 01:06:16,280
>> אז Enqueue, הצענו במדגם
פתרונות ליישום באופן הבא.

1376
01:06:16,280 --> 01:06:20,420
אחד, אנחנו בודקים את קלות הראשונות,
הפירות נמוכים התלויים.

1377
01:06:20,420 --> 01:06:23,820
אם התור מלא או את המספר ש
אתה מנסה להכניס פחות

1378
01:06:23,820 --> 01:06:26,380
מ אפס, שבו אנו אומרים ב
מפרט של הבעיה צריכה

1379
01:06:26,380 --> 01:06:30,320
לא יתאפשר, כי אנחנו רוצים רק
ערכים שאינם שליליים, אז אתה צריך

1380
01:06:30,320 --> 01:06:31,640
רק בתמורת שווא באופן מיידי.

1381
01:06:31,640 --> 01:06:33,820
אז כמה קל יחסית
בדיקת שגיאות.

1382
01:06:33,820 --> 01:06:38,720
אם למרות רצונך להוסיף כי בפועל
מספר, שהיית צריך לעשות קצת

1383
01:06:38,720 --> 01:06:39,440
חושב כאן.

1384
01:06:39,440 --> 01:06:41,330
וזה מקום שבו זה קצת מעצבן
מבחינה נפשית, בגלל שיש לך

1385
01:06:41,330 --> 01:06:43,000
להבין איך להתמודד עם המעטפת.

1386
01:06:43,000 --> 01:06:46,870
>> אבל את הנבט של הרעיון כאן זה של
מעניין אותנו היא מעטפת ש

1387
01:06:46,870 --> 01:06:51,480
לעתים קרובות מרמז חשבון מודולרי ו
מפעיל mod, בצד אחוזים,

1388
01:06:51,480 --> 01:06:55,140
שבו אתה יכול ללכת מערך גדול יותר
חזרה לאפס ואז אחד ושני ו

1389
01:06:55,140 --> 01:06:58,650
שלוש ולאחר מכן חזרה סביב לאפס,
אחת ושתיים ושלוש וכן הלאה

1390
01:06:58,650 --> 01:06:59,380
שוב ושוב.

1391
01:06:59,380 --> 01:07:02,880
לכן הדרך אנו מציעים לעשות זאת היא
כי אנחנו רוצים מדד ל

1392
01:07:02,880 --> 01:07:05,850
מערך נקרא מספרים שבו
המספרים השלמים לשקר.

1393
01:07:05,850 --> 01:07:10,740
אבל כדי להגיע לשם, אנחנו רוצים קודם כל לעשות
מה הגודל של התור הוא אלא

1394
01:07:10,740 --> 01:07:14,080
לאחר מכן להוסיף שלכל מה
מול הרשימה.

1395
01:07:14,080 --> 01:07:17,880
ואת ההשפעה של זה היא לשים אותנו ב
המיקום הנכון ובתור

1396
01:07:17,880 --> 01:07:20,970
אין להניח כי האדם הראשון בשורה
הוא בתחילתו, שבו הוא או

1397
01:07:20,970 --> 01:07:24,130
היא בהחלט יכולה להיות אם אנחנו
גם הסטה כולם.

1398
01:07:24,130 --> 01:07:26,710
אבל אנחנו רק יוצרים עבודה
לעצמנו אם אנחנו לקחנו

1399
01:07:26,710 --> 01:07:27,800
נתיב מסוים.

1400
01:07:27,800 --> 01:07:29,330
>> אז אנחנו יכולים לשמור את זה פשוט יחסית.

1401
01:07:29,330 --> 01:07:32,180
אנחנו צריכים לזכור שאנחנו רק
הוסיף int לתור.

1402
01:07:32,180 --> 01:07:35,850
ואז אנחנו פשוט החזר אמיתי.

1403
01:07:35,850 --> 01:07:38,560
בינתיים, בdequeue, שאלנו
לך לעשות את הדברים הבאים.

1404
01:07:38,560 --> 01:07:42,260
ליישם אותו בצורה כזאת שזה
dequeues, כי הוא מסיר וחוזר,

1405
01:07:42,260 --> 01:07:44,190
int בקדמת התור.

1406
01:07:44,190 --> 01:07:46,410
כדי להסיר את int, די
לשכוח את זה.

1407
01:07:46,410 --> 01:07:47,650
אתה לא צריך לעקוף את שלו.

1408
01:07:47,650 --> 01:07:48,820
אז זה עדיין ממש שם.

1409
01:07:48,820 --> 01:07:51,930
בדיוק כמו הנתונים על כונן קשיח,
אנחנו פשוט מתעלמים מהעובדה

1410
01:07:51,930 --> 01:07:52,970
שזה עכשיו יש.

1411
01:07:52,970 --> 01:07:55,520
ואם q הוא ריק, אנחנו צריכים
במקום לחזור 1 שלילי.

1412
01:07:55,520 --> 01:07:56,750
אז זה מרגיש שרירותי.

1413
01:07:56,750 --> 01:08:01,640
למה לחזור 1 שלילי
במקום שווא?

1414
01:08:01,640 --> 01:08:02,620
כן.

1415
01:08:02,620 --> 01:08:05,070
>> קהל: Q הוא אחסון
ערכים חיוביים.

1416
01:08:05,070 --> 01:08:10,950
מכיוון שאתה לאחסן רק ערכים חיוביים
בq, שלילי הוא שגיאה.

1417
01:08:10,950 --> 01:08:11,510
>> דוד י מלאן: בסדר, נכון.

1418
01:08:11,510 --> 01:08:14,850
אז בגלל שאנחנו אחסון רק חיוביים
ערכים או אפס, אז זה בסדר

1419
01:08:14,850 --> 01:08:18,050
להחזיר ערך שלילי כזקיף
ערך, סמל מיוחד.

1420
01:08:18,050 --> 01:08:21,630
אבל אתה משכתב את ההיסטוריה לשם,
בגלל הסיבה שאנחנו רק

1421
01:08:21,630 --> 01:08:25,890
חוזר ערכים שאינם שליליים
בגלל שאנחנו רוצים

1422
01:08:25,890 --> 01:08:27,670
יש ערך זקיף.

1423
01:08:27,670 --> 01:08:32,617
אז לייתר דיוק, למה לא פשוט
בתמורת שווא במקרים של טעויות?

1424
01:08:32,617 --> 01:08:33,099
כן.

1425
01:08:33,099 --> 01:08:35,510
>> קהל: אתה כבר נכשל
כדי להחזיר מספר שלם.

1426
01:08:35,510 --> 01:08:36,630
>> דוד י מלאן: בדיוק.

1427
01:08:36,630 --> 01:08:38,569
וזה מקום שבי C מקבל
די מגביל.

1428
01:08:38,569 --> 01:08:40,590
אם אתה אומר שאתה הולך
להחזיר int, יש לך

1429
01:08:40,590 --> 01:08:41,279
להחזיר int.

1430
01:08:41,279 --> 01:08:43,689
אתה לא יכול לקבל מפואר ולהתחיל לחזור
bool או לצוף או

1431
01:08:43,689 --> 01:08:45,040
מחרוזת או משהו כזה.

1432
01:08:45,040 --> 01:08:49,370
עכשיו, בינתיים, JavaScript ו-PHP ו
כמה שפות אחרות יכול, למעשה,

1433
01:08:49,370 --> 01:08:51,310
יש לך חוזר שונה
סוגים של ערכים.

1434
01:08:51,310 --> 01:08:54,819
וזה באמת יכול להיות שימושי, שבו
אתה יכול לחזור ints, אפסים חיוביים,

1435
01:08:54,819 --> 01:08:59,439
ints השלילי, או שקר או null
אפילו כדי לסמן שגיאה.

1436
01:08:59,439 --> 01:09:01,890
אבל אין לנו את זה
רבגוניות בג

1437
01:09:01,890 --> 01:09:04,569
>> אז עם dequeue, מה שאנחנו
מציע לעשות הוא -

1438
01:09:04,569 --> 01:09:07,350

1439
01:09:07,350 --> 01:09:09,830
>> ROB אודן: אתה יכול לחזור שווא.

1440
01:09:09,830 --> 01:09:13,189
זה רק ששקר הוא חשיש
להגדיר שווא לאפס.

1441
01:09:13,189 --> 01:09:16,000
אז אם אתם בתמורת שווא,
אתה חוזר לאפס.

1442
01:09:16,000 --> 01:09:25,470
ואפס הוא דבר חוקי בתורנו,
ואילו 1 שלילי הוא לא אם

1443
01:09:25,470 --> 01:09:27,000
שקר במקרה 1 שלילי.

1444
01:09:27,000 --> 01:09:29,972
אבל אתה לא צריך אפילו
צריך לדעת את זה.

1445
01:09:29,972 --> 01:09:32,399
>> דוד י מלאן: זה
למה אני לא אומר את זה.

1446
01:09:32,399 --> 01:09:36,450
>> ROB אודן: אבל זה לא היה נכון
כי אתה לא יכול לחזור שווא.

1447
01:09:36,450 --> 01:09:37,700
>> דוד י מלאן: בטח.

1448
01:09:37,700 --> 01:09:40,920

1449
01:09:40,920 --> 01:09:44,240
אז dequeue, שים לב שאנו מקבלים
ביטול כטענתה.

1450
01:09:44,240 --> 01:09:45,479
וזה בגלל שאנחנו לא
עובר כל דבר פנימה

1451
01:09:45,479 --> 01:09:48,359
אנחנו רק רוצים להסיר את האלמנט
בראש התור.

1452
01:09:48,359 --> 01:09:49,819
אז איך אנחנו יכולים ללכת על עושים את זה?

1453
01:09:49,819 --> 01:09:51,290
ובכן, ראשית, בואו נעשיתי את זה
בדיקת שפיות מהירה.

1454
01:09:51,290 --> 01:09:53,350
אם גודל התור הוא 0, יש
אין עבודה שצריך לעשות.

1455
01:09:53,350 --> 01:09:54,210
תשואה שלילית 1.

1456
01:09:54,210 --> 01:09:54,800
בוצע.

1457
01:09:54,800 --> 01:09:56,340
אז זה כמה שורות של התכנית שלי.

1458
01:09:56,340 --> 01:09:58,180
אז רק ארבע שורות יישארו.

1459
01:09:58,180 --> 01:10:01,310
>> אז הנה אני מחליט הפחה
הגודל.

1460
01:10:01,310 --> 01:10:04,620
וdecrementing הגודל ביעילות
אומר שאני שוכח

1461
01:10:04,620 --> 01:10:06,010
משהו הוא שם.

1462
01:10:06,010 --> 01:10:09,910
אבל יש לי גם לעדכן בי
מול המספרים.

1463
01:10:09,910 --> 01:10:11,620
אז כדי לעשות את זה, אני צריך
לעשות שני דברים.

1464
01:10:11,620 --> 01:10:16,390
אני קודם כל צריך לזכור מה המספר
הוא בראש התור,

1465
01:10:16,390 --> 01:10:17,860
כי אני צריך להחזיר את הדבר הזה.

1466
01:10:17,860 --> 01:10:20,910
אז אני לא רוצה לשכוח בטעות
על זה ולאחר מכן להחליף אותו.

1467
01:10:20,910 --> 01:10:22,840
אני רק הולך לזכור בint.

1468
01:10:22,840 --> 01:10:27,310
>> ועכשיו, אני רוצה לעדכן
q.front להיות q.front +1.

1469
01:10:27,310 --> 01:10:30,070
אז אם זה היה האדם הראשון ב
קו, עכשיו, אני רוצה לעשות בתוספת 1 עד

1470
01:10:30,070 --> 01:10:31,930
להצביע על האדם הבא בתור.

1471
01:10:31,930 --> 01:10:33,420
אבל אני צריך להתמודד עם מעטפת ש.

1472
01:10:33,420 --> 01:10:37,270
ואם הקיבולת היא קבועה עולמי,
זה הולך כדי לאפשר לי לוודא

1473
01:10:37,270 --> 01:10:41,140
כפי שאני מצביע על האדם מאוד שעבר ב
קו, פעולת מודולו תביא

1474
01:10:41,140 --> 01:10:43,840
אותי בחזרה לאפס ב
ראש התור.

1475
01:10:43,840 --> 01:10:46,050
ושמטפל במעטפת כאן.

1476
01:10:46,050 --> 01:10:48,950
ואז אני ממשיך לחזור n.

1477
01:10:48,950 --> 01:10:51,530
>> עכשיו, בעצם, אני לא
יש להכריז על n.

1478
01:10:51,530 --> 01:10:53,880
אני לא הייתי צריך לתפוס אותו ולאחסן אותו
באופן זמני, משום שהערך הוא

1479
01:10:53,880 --> 01:10:54,740
עדיין שם.

1480
01:10:54,740 --> 01:10:57,490
אז רק אני יכול לעשות את החשבון הנכון
לחזור לשעבר הראש

1481
01:10:57,490 --> 01:10:58,450
של התור.

1482
01:10:58,450 --> 01:11:01,850
אבל אני פשוט הרגשתי שזה היה יותר ברור
למעשה לתפוס int, לשים אותו

1483
01:11:01,850 --> 01:11:04,320
בn, ואז לחזור כי
למען הבהירות אבל

1484
01:11:04,320 --> 01:11:05,735
לא הכרחי.

1485
01:11:05,735 --> 01:11:09,313

1486
01:11:09,313 --> 01:11:12,130
פססט.

1487
01:11:12,130 --> 01:11:13,410
הם כולם להגות בראש שלי.

1488
01:11:13,410 --> 01:11:15,940

1489
01:11:15,940 --> 01:11:19,110
>> ROB אודן: שאלה אז קודם
הבעיה הוא העץ בינארי.

1490
01:11:19,110 --> 01:11:22,140
שאלה אז ראשונה היא, שאנחנו
נתן את המספרים האלה.

1491
01:11:22,140 --> 01:11:27,160
ואנחנו רוצים להכניס אותם איכשהו לתוך
בלוטות אלה כאלה שזה הוא

1492
01:11:27,160 --> 01:11:30,110
עץ חיפוש בינארי בתוקף.

1493
01:11:30,110 --> 01:11:36,260
אז הדבר אחד שיש לזכור לגבי
עצי חיפוש בינארי הוא שזה לא

1494
01:11:36,260 --> 01:11:39,800
רק שהדבר שמשמאל
הוא פחות והדבר

1495
01:11:39,800 --> 01:11:41,120
הנכון הוא גדול יותר.

1496
01:11:41,120 --> 01:11:44,580
זה צריך להיות שכולו העץ
השמאל הוא פחות, וכל העץ

1497
01:11:44,580 --> 01:11:45,740
בצד הימין הוא גדול יותר.

1498
01:11:45,740 --> 01:11:55,260
>> אז אם אני שם את 34 כאן בחלקו העליון, ולאחר מכן
שמתי 20 כאן, אז זה חוקי כל כך

1499
01:11:55,260 --> 01:11:56,970
כה, כי כאן 34 למעלה.

1500
01:11:56,970 --> 01:11:57,920
20 הוא הולך לצד השמאל.

1501
01:11:57,920 --> 01:11:58,950
אז זה פחות.

1502
01:11:58,950 --> 01:12:03,640
אבל אני לא יכול ואז לשים 59 כאן, כי
למרות 59 הוא בצד הימין של 20,

1503
01:12:03,640 --> 01:12:06,140
זה עדיין בצד השמאל של 34.

1504
01:12:06,140 --> 01:12:10,760
אז עם אילוץ זה בחשבון,
הדרך הקלה ביותר של ככל הנראה פתרון זה

1505
01:12:10,760 --> 01:12:14,330
בעיה היא רק מעין
המספרים האלה -

1506
01:12:14,330 --> 01:12:18,720
כך 20, 34, 36, 52, 59, 106.

1507
01:12:18,720 --> 01:12:21,640
ולאחר מכן להוסיף אותם
משמאל לימין.

1508
01:12:21,640 --> 01:12:23,390
>> אז 20 הולך כאן.

1509
01:12:23,390 --> 01:12:24,630
34 הולך כאן.

1510
01:12:24,630 --> 01:12:25,830
36 הולך כאן.

1511
01:12:25,830 --> 01:12:29,360
52, 59, 106.

1512
01:12:29,360 --> 01:12:34,730
ואתה גם יכול להבין עם
כמה חיבור והגשמה,

1513
01:12:34,730 --> 01:12:38,830
אה, רגע, אין לי מספיק מספרים
כדי למלא את זה בפה.

1514
01:12:38,830 --> 01:12:42,170
אז אני צריך reshift מה
פתק מסלול הולך להיות.

1515
01:12:42,170 --> 01:12:47,490
אבל שמו לב שבשלושה הסופיים, אם
אתה קורא משמאל לימין, הוא ב

1516
01:12:47,490 --> 01:12:48,740
סדר הולך וגובר.

1517
01:12:48,740 --> 01:12:52,150

1518
01:12:52,150 --> 01:12:56,540
>> אז עכשיו, אנחנו רוצים להכריז מה
struct הולך להיות עבור

1519
01:12:56,540 --> 01:12:58,300
צמתים בעץ הזה.

1520
01:12:58,300 --> 01:13:02,720
אז מה אנחנו צריכים לעשות בעץ בינארי?

1521
01:13:02,720 --> 01:13:05,830
אז יש לנו ערך מסוג
int, אז איזה ערך int.

1522
01:13:05,830 --> 01:13:07,220
אני לא יודע מה שאנחנו נקראים
זה בפתרון -

1523
01:13:07,220 --> 01:13:08,500
int n.

1524
01:13:08,500 --> 01:13:13,570
אנחנו צריכים מצביע לילד השמאלי
ומצביע לילד הנכון.

1525
01:13:13,570 --> 01:13:17,540
אז זה הולך להיראות כך.

1526
01:13:17,540 --> 01:13:20,510
וזה באמת ייראה לפני
מתי צמוד כפליים

1527
01:13:20,510 --> 01:13:25,090
דברים ברשימה, ולכן הודעה -

1528
01:13:25,090 --> 01:13:27,860
אני הולך צריך לגלול את כל
בדרך חזרה למטה לבעיה 11.

1529
01:13:27,860 --> 01:13:30,980

1530
01:13:30,980 --> 01:13:36,390
>> אז שם לב שזה נראה זהה לזה,
מלבדנו רק במקרה קוראים לאלה

1531
01:13:36,390 --> 01:13:38,590
שמות שונים.

1532
01:13:38,590 --> 01:13:41,440
עדיין יש לנו מספר שלם
ערך ושני מצביעים.

1533
01:13:41,440 --> 01:13:44,850
זה רק שבמקום לטפל
מצביעים כמצביעים על הדבר הבא

1534
01:13:44,850 --> 01:13:47,955
והדבר האחרון, אנחנו מטפלים
המצביעים להצביע על ילד שמאלי

1535
01:13:47,955 --> 01:13:49,205
וילד נכון.

1536
01:13:49,205 --> 01:13:57,372

1537
01:13:57,372 --> 01:13:57,860
על אישור.

1538
01:13:57,860 --> 01:13:59,650
אז זה צומת struct שלנו.

1539
01:13:59,650 --> 01:14:03,920
ועכשיו, הפונקציה היחידה שאנחנו צריכים
ליישם לכך הוא חוצה, אשר

1540
01:14:03,920 --> 01:14:08,320
אנחנו רוצים ללכת על העץ, ההדפסה
את ערכיו של העץ בהזמנה.

1541
01:14:08,320 --> 01:14:15,241
>> אז מחפש כאן, היינו רוצה להדפיס
מתוך 20, 34, 36, 52, 59, ו106.

1542
01:14:15,241 --> 01:14:17,970
איך אפשר להשיג את זה?

1543
01:14:17,970 --> 01:14:18,890
אז זה די דומה.

1544
01:14:18,890 --> 01:14:22,910
אם ראה בבחינה האחרונה הבעיה
שאתה רוצה להדפיס

1545
01:14:22,910 --> 01:14:25,940
כל העץ עם פסיקים בין
הכל, זה היה בעצם אפילו

1546
01:14:25,940 --> 01:14:27,320
יותר קל מזה.

1547
01:14:27,320 --> 01:14:30,950
אז הנה הפתרון.

1548
01:14:30,950 --> 01:14:33,110
זה היה קל יותר באופן משמעותי
אם עשה את זה באופן רקורסיבי.

1549
01:14:33,110 --> 01:14:36,650
אני לא יודע אם מישהו ניסה
כדי לעשות את זה איטרטיבי.

1550
01:14:36,650 --> 01:14:38,340
>> אבל קודם כל, יש לנו מקרה הבסיס שלנו.

1551
01:14:38,340 --> 01:14:39,660
מה אם השורש הוא ריק?

1552
01:14:39,660 --> 01:14:40,610
אז אנחנו פשוט הולכים לחזור.

1553
01:14:40,610 --> 01:14:42,300
אנחנו לא רוצים להדפיס כל דבר.

1554
01:14:42,300 --> 01:14:45,940
אחר אנחנו הולכים לעבור
באופן רקורסיבי למטה.

1555
01:14:45,940 --> 01:14:48,140
הדפס עץ המשנה של השמאל כולו.

1556
01:14:48,140 --> 01:14:51,440
אז להדפיס כל דבר פחות
מהערך הנוכחי שלי.

1557
01:14:51,440 --> 01:14:53,930
ולאחר מכן אני הולך להדפיס את עצמי.

1558
01:14:53,930 --> 01:14:57,310
ולאחר מכן אני הולך recurse אותי
עץ המשנה של ימין כולו, ולכן כל מה

1559
01:14:57,310 --> 01:14:58,810
גדול יותר מהערך שלי.

1560
01:14:58,810 --> 01:15:03,870
וזה הולך להדפסה
הכל כדי לצאת.

1561
01:15:03,870 --> 01:15:05,860
שאלות על איך זה בעצם
משיג את זה?

1562
01:15:05,860 --> 01:15:09,892

1563
01:15:09,892 --> 01:15:12,545
>> קהל: יש לי שאלה
על [לא ברור].

1564
01:15:12,545 --> 01:15:15,090

1565
01:15:15,090 --> 01:15:23,550
>> ROB אודן: אז דרך אחת מתקרב
כל בעיה רקורסיבית היא לחשוב רק

1566
01:15:23,550 --> 01:15:26,275
על זה כמו שאתה צריך לחשוב
על כל המקרים שפינה.

1567
01:15:26,275 --> 01:15:32,150

1568
01:15:32,150 --> 01:15:38,110
לכן קחו בחשבון שאנחנו רוצים
להדפיס כל העץ הזה.

1569
01:15:38,110 --> 01:15:42,030
אז כל מה שאנחנו הולכים להתמקד על
היא צומת המסוימת הזה -

1570
01:15:42,030 --> 01:15:43,740
36.

1571
01:15:43,740 --> 01:15:47,420
שיחות רקורסיבית, אנו מעמידים פנים
אלה רק לעבוד.

1572
01:15:47,420 --> 01:15:54,000
אז הנה, קריאה רקורסיבית זה כדי
Traverse, אנחנו אפילו בלי לחשוב

1573
01:15:54,000 --> 01:15:58,640
על זה, פשוט חוצה את השמאל
שלוש, מתאר לעצמי שכבר מדפיס 20

1574
01:15:58,640 --> 01:16:00,730
ו34 עבורנו.

1575
01:16:00,730 --> 01:16:03,350
ולאחר מכן כאשר אנו סופו של דבר באופן רקורסיבי
קורא Traverse על

1576
01:16:03,350 --> 01:16:07,890
בסדר, שיהיה בצורה נכונה להדפיס
52, 59, ו106 עבורנו.

1577
01:16:07,890 --> 01:16:13,620
>> אז בהתחשב בכך שזה יכול להדפיס 20, 34, ו
האחרים יכול להדפיס 52, 59, 108,

1578
01:16:13,620 --> 01:16:17,180
כל מה שאנחנו צריכים להיות מסוגלים לעשות הוא להדפיס
את עצמנו באמצע זה.

1579
01:16:17,180 --> 01:16:21,250
אז להדפיס את כל מה שלפנינו.

1580
01:16:21,250 --> 01:16:27,710
להדפיס את עצמנו, ולכן הדפסת הצומת הנוכחית
36, printf הרגיל, ולאחר מכן

1581
01:16:27,710 --> 01:16:31,170
להדפיס כל דבר אחרינו.

1582
01:16:31,170 --> 01:16:32,730
>> דוד י מלאן: זה מקום שבי רקורסיה
מקבל ממש יפה.

1583
01:16:32,730 --> 01:16:36,270
זה הזינוק המדהים הזה של אמונה בי
אתה עושה השמץ של עבודה.

1584
01:16:36,270 --> 01:16:38,460
ואז אתה נותן למישהו
אחר יעשה את השאר.

1585
01:16:38,460 --> 01:16:40,180
וכי מישהו אחר
הוא, באופן אירוני, אותך.

1586
01:16:40,180 --> 01:16:44,260

1587
01:16:44,260 --> 01:16:48,360
אז לנקודות בראוני רציניות, אם
שלך לגלול למעלה על השאלות -

1588
01:16:48,360 --> 01:16:50,530
>> ROB אודן: בשאלות?

1589
01:16:50,530 --> 01:16:53,490
>> דוד י מלאן: ולמטה מעט
המספרים, האם מישהו יודעים איפה

1590
01:16:53,490 --> 01:16:55,190
מספרים אלה באים?

1591
01:16:55,190 --> 01:16:56,610
>> ROB אודן: יש לי ממש מושג.

1592
01:16:56,610 --> 01:16:59,794
>> דוד י מלאן: הם מופיעים
לאורך כל החידון.

1593
01:16:59,794 --> 01:17:01,150
>> קהל: האם הם אותם המספרים?

1594
01:17:01,150 --> 01:17:01,910
>> דוד י מלאן: מספרים אלה.

1595
01:17:01,910 --> 01:17:03,260
ביצת פסחא קטנה.

1596
01:17:03,260 --> 01:17:08,100
אז לאלה מכם צופים באינטרנט ב
הבית, אם אתה יכול לספר לנו באמצעות דואר אלקטרוני ל

1597
01:17:08,100 --> 01:17:12,680
heads@CS50.net מה המשמעות
של ששת מספרים חוזרים אלה הם

1598
01:17:12,680 --> 01:17:18,560
לאורך 1 חידון, אנו להתקלח
עם תשומת לב מדהימה בגמר

1599
01:17:18,560 --> 01:17:21,610
הרצאה ולחץ כדור.

1600
01:17:21,610 --> 01:17:25,460

1601
01:17:25,460 --> 01:17:27,790
נחמד, עדין.

1602
01:17:27,790 --> 01:17:29,570
>> ROB אודן: כל שאלות שעברה
על כל דבר בחידון?

1603
01:17:29,570 --> 01:17:32,608