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

2
00:00:08,070 --> 00:00:10,430
>> R.J. אקינו: בואו פשוט להתחיל.

3
00:00:10,430 --> 00:00:12,310
אז זה 1 חידון.

4
00:00:12,310 --> 00:00:14,890
הנה קצת מידע ברמה גבוהה.

5
00:00:14,890 --> 00:00:19,915
הדף אודות לחידון הוא בשלב זה
כתובת אתר, כבר לא CS50.net, למרות ש

6
00:00:19,915 --> 00:00:21,080
ימשיך לעבוד.

7
00:00:21,080 --> 00:00:26,920
זה CS50.harvard.edu/quizzes/2013/1.

8
00:00:26,920 --> 00:00:31,070
זה גדול על דף, אומר לך
היכן ומתי, כלומר ביום רביעי הבא

9
00:00:31,070 --> 00:00:32,100
בחבורה של חדרים.

10
00:00:32,100 --> 00:00:36,120
ועל ידי ביום רביעי הבא, אני
אומר שני ימים מהיום.

11
00:00:36,120 --> 00:00:37,890
כל המידע הזה נמצא שם.

12
00:00:37,890 --> 00:00:39,110
אבל זה מצטבר.

13
00:00:39,110 --> 00:00:43,790
>> אז כל דבר, החל במחצית הראשונה של
שנה היא באופן פוטנציאלי על החידון,

14
00:00:43,790 --> 00:00:50,780
כי אתה לא באמת יכול לעשות מתקדם
דברים ב-C ללא אם תנאים ו

15
00:00:50,780 --> 00:00:51,920
ללולאות וכדומה.

16
00:00:51,920 --> 00:00:55,580
אבל יהיה דגש על
חומר מכוסה מאז חידון 0,

17
00:00:55,580 --> 00:00:59,570
החל structs וקובץ
I / O. זה בדרך כלל יותר

18
00:00:59,570 --> 00:01:01,620
מאתגר יותר מחידון 0.

19
00:01:01,620 --> 00:01:03,870
הציון הממוצע הוא בדרך כלל נמוך יותר.

20
00:01:03,870 --> 00:01:05,980
ללמוד קשה.

21
00:01:05,980 --> 00:01:09,340
>> בזמן שאתה לומד, כדי להיות בטוח לשימוש
CS50/discuss לפרסם השאלות שלך

22
00:01:09,340 --> 00:01:10,830
ולקרוא על השאלות של אנשים אחרים.

23
00:01:10,830 --> 00:01:13,550
אז אם אין לך שאלות,
להיכנס ולקרוא

24
00:01:13,550 --> 00:01:14,580
השאלות של חבריך.

25
00:01:14,580 --> 00:01:16,560
הם כנראה שאלות טובות.

26
00:01:16,560 --> 00:01:17,730
ולקחת את החידונים בפועל.

27
00:01:17,730 --> 00:01:20,750
אנחנו כבר נותנים לחידונים
שבע או שמונה שנים עם החברה.

28
00:01:20,750 --> 00:01:22,180
הם כולם באינטרנט.

29
00:01:22,180 --> 00:01:25,540
שאלות דומות בעתיד
לשאלות ישנות.

30
00:01:25,540 --> 00:01:26,550
ככה אנחנו עושים אותם.

31
00:01:26,550 --> 00:01:27,740
>> החידון אינו קיים עדיין.

32
00:01:27,740 --> 00:01:28,670
אף אחד מאתנו לא ראה אותו.

33
00:01:28,670 --> 00:01:32,496
אבל זה ייראה
חידונים קודמים.

34
00:01:32,496 --> 00:01:36,500
למפגש סקירה זו, זה לא
רשימה ממצה של נושאים.

35
00:01:36,500 --> 00:01:40,740
אתה לא יכול פשוט להשתתף בזה ולאחר מכן
להיות מוכן בצורה מושלמת לחידון.

36
00:01:40,740 --> 00:01:43,330
אחרת, זה לא יהיה
שהרבה מחידון.

37
00:01:43,330 --> 00:01:46,270
וזה לא בהכרח גם
כל מה שאתה צריך לדעת על כל

38
00:01:46,270 --> 00:01:46,970
ניתנו בנושא.

39
00:01:46,970 --> 00:01:50,520
זה אמור לחשוף אותך לדברים
אנחנו כבר כיסינו, להזכיר לך את מה שאנחנו

40
00:01:50,520 --> 00:01:53,070
מכוסה, ואת הדרך ש
שכיסינו אותו.

41
00:01:53,070 --> 00:01:57,030
אבל תצטרך ללכת רחוק יותר ו
עמוק יותר כאשר אתה לומד כדי לבדוק פעמיים

42
00:01:57,030 --> 00:02:00,230
שאתה יודע הכל על כל שניתן
נושא וכי אתה כבר מילאת

43
00:02:00,230 --> 00:02:03,320
כל הפינות שהיו
מכוסה בהרצאה.

44
00:02:03,320 --> 00:02:07,980
>> הערות החידון תגיד לך ללכת ל
הערות סופר, קטעי וידאו הרצאת שעון.

45
00:02:07,980 --> 00:02:10,155
זוהי דרך טובה כדי לוודא שיש לך
כיסה את כל הבסיסים שלך.

46
00:02:10,155 --> 00:02:12,670

47
00:02:12,670 --> 00:02:17,340
אז בתחילת הדרך, כאשר אני עשיתי אלה
שקופיות, ניסיתי לשים שם מצאתי

48
00:02:17,340 --> 00:02:18,350
מידע.

49
00:02:18,350 --> 00:02:22,890
אז עבורי קובץ / O, למשל, 7 בשבוע,
הרצאה של יום שני, ופורסם

50
00:02:22,890 --> 00:02:27,960
סעיף 6 והבעיה סט כל מה שיש
מידע על קובץ I / O. אני כבר עשיתי

51
00:02:27,960 --> 00:02:28,840
זה לכל נושא.

52
00:02:28,840 --> 00:02:33,010
אז שקופיות הכותרת אלה עשויות
להיות לך לעזר.

53
00:02:33,010 --> 00:02:38,950
>> אז הנה יש לנו אני קובץ / O. זכור, ב
בעיה הגדרת 5, השתמשנו fopen, fclose,

54
00:02:38,950 --> 00:02:41,210
fwrite, fread, וfseek.

55
00:02:41,210 --> 00:02:48,090
לאחר שהתאושש 30ish תמונות JPEG ו
לאחר שינוי גודל והתעסקתי עם

56
00:02:48,090 --> 00:02:50,320
מפות סיביות, אתה צריך להיות די מוכרת
עם הפונקציות האלה

57
00:02:50,320 --> 00:02:51,830
ואיך הם עובדים.

58
00:02:51,830 --> 00:02:54,420
אם אתה כבר לא מוכר,
בהחלט לעיין בהם.

59
00:02:54,420 --> 00:02:56,860
וודא שאתה מבין מה
הטיעונים השונים,

60
00:02:56,860 --> 00:02:58,260
כשהם בשימוש.

61
00:02:58,260 --> 00:03:03,620
>> אבל באגים הקשורים לקבצים הנפוצים
ייתכן שתתבקש על -

62
00:03:03,620 --> 00:03:07,270
ובכן, אם אתה שכחת לבדוק אם
fopen עבד בפועל לפני שאתה הולך

63
00:03:07,270 --> 00:03:08,350
לשנות קובץ.

64
00:03:08,350 --> 00:03:09,760
זה יכול להיות רע.

65
00:03:09,760 --> 00:03:13,560
אם שכחת לfclose קובץ
כי אתה כבר fopened, זה דומה ל

66
00:03:13,560 --> 00:03:14,400
דליפת זיכרון.

67
00:03:14,400 --> 00:03:15,980
זה די רע.

68
00:03:15,980 --> 00:03:18,670
ושוכח לבדוק אם יש לך
הגיע לסוף של הקובץ לפני שאתה

69
00:03:18,670 --> 00:03:19,790
להתחיל לכתוב אליו.

70
00:03:19,790 --> 00:03:22,320
>> אז אם אתה אומר, היי, אני ב
סוף הקובץ.

71
00:03:22,320 --> 00:03:23,750
תן לי 5 בתים יותר.

72
00:03:23,750 --> 00:03:27,370
ובכן, זה כנראה לא הולך
תסתדר כפי שאתה מצפה.

73
00:03:27,370 --> 00:03:30,930
זה באמת אותו לקובץ I / O,
בגלל שעשינו כל כך הרבה יותר מזה

74
00:03:30,930 --> 00:03:32,300
עם הבעיה מוגדרת.

75
00:03:32,300 --> 00:03:36,000
אז אם אתה מבין מה קורה
בבעיה הסט 5, זוכר את bitmats

76
00:03:36,000 --> 00:03:40,090
והתמונות JPEG, אז אתה כנראה כל
נקבע לקובץ I / O. אם זה קצת

77
00:03:40,090 --> 00:03:44,770
מטושטש, בהחלט תבדוק את הבעיה
להגדיר והחומר הנלווה.

78
00:03:44,770 --> 00:03:51,110
>> Structs היה הנושא שהיו על
קו בין חידון 0 ו -1 החידון.

79
00:03:51,110 --> 00:03:53,090
לא ממש להפוך את החיתוך לחידון 0.

80
00:03:53,090 --> 00:03:57,040
אז הם בהחלט נהיה על
חידון 1, שבוע 7, יום שני.

81
00:03:57,040 --> 00:03:58,150
מהו struct?

82
00:03:58,150 --> 00:04:00,250
כאן אנו מראים struct.

83
00:04:00,250 --> 00:04:03,140
זה כמו סוג חדש.

84
00:04:03,140 --> 00:04:07,940
זה כמו מיכל
עבור שדות מרובים.

85
00:04:07,940 --> 00:04:12,970
>> במקרה זה, אנחנו כבר הכריזו struct
תלמיד שיש לו שני שדות -

86
00:04:12,970 --> 00:04:17,750
שם מחרוזת שאנחנו קוראים ו
int שאנחנו קוראים לי גיל.

87
00:04:17,750 --> 00:04:21,450
לכן, כאשר אני עובר סביב סטודנטים או שאני
לשנות תלמידים, אני אהיה מסוגל

88
00:04:21,450 --> 00:04:24,430
לגשת שמם וגילם.

89
00:04:24,430 --> 00:04:26,670
בואו נסתכל על קצת קוד בשביל זה.

90
00:04:26,670 --> 00:04:29,090
כאן אנו רואים, כי אני כבר הכריז
של תלמיד, בדיוק כמו

91
00:04:29,090 --> 00:04:30,300
אני מצהיר כל משתנה -

92
00:04:30,300 --> 00:04:32,430
x int, y int, וכולי.

93
00:04:32,430 --> 00:04:34,180
>> הנה של תלמיד.

94
00:04:34,180 --> 00:04:37,370
הוא מתחיל עם שום דבר בתחומיו.

95
00:04:37,370 --> 00:04:38,240
אז בואו להגדיר אותם.

96
00:04:38,240 --> 00:04:40,681
אתה מגדיר את השדות של struct עם נקודה.

97
00:04:40,681 --> 00:04:43,780
אז אני כבר אמרתי כאן s.name ש= RJ.

98
00:04:43,780 --> 00:04:46,470
וs.age = 21.

99
00:04:46,470 --> 00:04:48,500
ניתן גם לעדכן שדות
באותו אופן שהיית לעדכן

100
00:04:48,500 --> 00:04:49,550
הערך של משתנה.

101
00:04:49,550 --> 00:04:53,270
אז אני רוצה לשנות את השם שלי מRJ עם
אין תקופות לR.J. כוסמין

102
00:04:53,270 --> 00:04:54,540
דרך נכונה.

103
00:04:54,540 --> 00:04:58,890
זה יהיה s.name = RJ, אותו
כפי שאמרנו אותו מקור.

104
00:04:58,890 --> 00:05:00,030
ואז אתה יכול לגשת אליהם.

105
00:05:00,030 --> 00:05:00,930
>> אז יש לנו להגדיר אותם.

106
00:05:00,930 --> 00:05:01,840
שנעדכן אותם.

107
00:05:01,840 --> 00:05:03,890
ניתן גם לגשת אליהם
באותה הדרך.

108
00:05:03,890 --> 00:05:09,330
אז הנה, אני מדפיס את
R.J. האם ישן 21 שנים.

109
00:05:09,330 --> 00:05:14,700
ואני גישה ערכים אלה
עם s.name וs.age.

110
00:05:14,700 --> 00:05:17,040
אז שגישת structs
עם סימון הנקודה.

111
00:05:17,040 --> 00:05:17,850
כן, שאלה?

112
00:05:17,850 --> 00:05:21,176
>> קהל: האם יש סיבה על
שקופית קודמת שלא לשים

113
00:05:21,176 --> 00:05:24,848
סטודנט בשורה העליונה, כמו typedef
תלמיד struct ולאחר מכן

114
00:05:24,848 --> 00:05:25,840
סטודנט בסופו של הדבר?

115
00:05:25,840 --> 00:05:29,040
>> R.J. אקינו: אז השאלה הייתה, על
השקופית הזו, שראינו בדרך כלל

116
00:05:29,040 --> 00:05:32,400
typedef struct צומת ולאחר מכן
שדות של struct ו

117
00:05:32,400 --> 00:05:34,250
אז מילת הצומת.

118
00:05:34,250 --> 00:05:37,790
ואיך הגיע לכאן אני לא אומר, typedef
תלמיד struct ולאחר מכן

119
00:05:37,790 --> 00:05:39,820
שדות של struct ולאחר מכן סטודנט?

120
00:05:39,820 --> 00:05:44,310
הסיבה לכך היא שאני לא צריך
לגשת אליו בתוך struct.

121
00:05:44,310 --> 00:05:46,270
אז זה בסדר להשאיר אותה ללא שם.

122
00:05:46,270 --> 00:05:49,210
אני רק יכול להשאיר אותו כפי
struct בעילום שם.

123
00:05:49,210 --> 00:05:53,130
>> הסיבה שאנחנו עושים את זה לרשימות מקושרות ו
דברים הוא, כי בתוכך צריכים

124
00:05:53,130 --> 00:05:55,360
הפניה כוכב צמתים struct.

125
00:05:55,360 --> 00:05:58,220
אז struct חייב להיות שם,
כך שאתה יכול לגשת אליו מאוחר יותר.

126
00:05:58,220 --> 00:05:59,540
זה פרט שולי.

127
00:05:59,540 --> 00:06:04,750
אבל אתה בדרך כלל רואה typedef struct
סוגריים מסולסלים אם אתה לא צריך

128
00:06:04,750 --> 00:06:08,720
השם וtypedef struct כמה שם
ואחריו בסוגריים מסולסלים, אם תרצה

129
00:06:08,720 --> 00:06:09,520
צריך את השם.

130
00:06:09,520 --> 00:06:12,070
כך שזו שאלה טובה.

131
00:06:12,070 --> 00:06:17,000
>> ועל נקודה זו, אנו נוטים לשנות
structs ולעבור מסביב structs ידי

132
00:06:17,000 --> 00:06:18,680
התייחסות, לא על ידי ערך.

133
00:06:18,680 --> 00:06:21,940
אז אנחנו פשוט מעבירים מצביעים
structs במקום עובר סביב

134
00:06:21,940 --> 00:06:23,150
structs עצמם.

135
00:06:23,150 --> 00:06:28,050
אז אתה לעתים קרובות מאוד הולך להיות
שימוש, במקרה זה, * תלמיד או

136
00:06:28,050 --> 00:06:34,150
* צומת מבנה או צומת * במקום
סטודנטים או צמתים החוצה.

137
00:06:34,150 --> 00:06:39,350
אז הנה, אני כבר אמרתי, אוקיי, PTR משתנה
הולך להיות כתובתו של ים.

138
00:06:39,350 --> 00:06:45,570
זה הולך להיות המצביע
לתלמיד R.J.

139
00:06:45,570 --> 00:06:48,965
>> אז אנחנו יכולים לקבל בתחומים אלה
אותו הדבר כמו שאנחנו מקבלים כל דבר.

140
00:06:48,965 --> 00:06:51,460
ראשית, זיהוי להפנות את המצביע
כדי לקבל את struct.

141
00:06:51,460 --> 00:06:55,530
זה * ptr ולאחר מכן
נקודה ולאחר מכן גיל.

142
00:06:55,530 --> 00:06:58,790
אז כדי לגשת לשדה, ואני כבר מעודכן
את זה עכשיו כדי 22, כי, בוא

143
00:06:58,790 --> 00:07:00,860
נניח, זה היה יום ההולדת שלי.

144
00:07:00,860 --> 00:07:03,990
יש תחביר קיצור
באמצעות החץ כאן.

145
00:07:03,990 --> 00:07:07,060
גיל חץ כך PTR הוא רק
אותו הדבר כמו * ptr.age.

146
00:07:07,060 --> 00:07:10,150

147
00:07:10,150 --> 00:07:11,550
עכשיו, זה משהו שיהיה לך
לשנן ולזכור.

148
00:07:11,550 --> 00:07:15,010
>> אתה השתמשת בו הרבה בpset6,
pset האיות.

149
00:07:15,010 --> 00:07:18,350
אבל זה בעצם מה שקורה
על מתחת למכסת המנוע.

150
00:07:18,350 --> 00:07:20,500
זה ביטול הפניה למבנה המצביע
ולאחר מכן לגשת אליו.

151
00:07:20,500 --> 00:07:21,432
שאלה?

152
00:07:21,432 --> 00:07:22,682
>> קהל: [לא ברור].

153
00:07:22,682 --> 00:07:25,860

154
00:07:25,860 --> 00:07:28,060
>> R.J. אקינו: אז למה אנחנו משתמשים
מצביעים כstructs במקום

155
00:07:28,060 --> 00:07:29,500
structs עצמם?

156
00:07:29,500 --> 00:07:33,740
הסיבה תהיה אם אתה עובר
struct לפונקציה, אתה כנראה

157
00:07:33,740 --> 00:07:36,900
רוצה לעבור מסביב רק 4 או כך
בתים המייצגים את המצביע, כפי

158
00:07:36,900 --> 00:07:40,375
בניגוד לפוטנציאל או 30
40 בתים כי הם struct.

159
00:07:40,375 --> 00:07:44,410
אז עובר משהו לפונקציה
קל יותר כאשר הדבר

160
00:07:44,410 --> 00:07:48,230
הוא קטן יותר בזמן קצר.

161
00:07:48,230 --> 00:07:49,074
שאלה?

162
00:07:49,074 --> 00:07:53,026
>> קהל: ייתכן שהזכיר את זה
בהתחלה, אבל הם שם

163
00:07:53,026 --> 00:07:56,000
שקופיות עד אחרות על [לא ברור]?

164
00:07:56,000 --> 00:07:58,960
>> R.J. אקינו: שקופיות אלה יהיו
עד לאחר פגישת הביקורת.

165
00:07:58,960 --> 00:08:00,210
אנחנו נפרסם אותם באתר.

166
00:08:00,210 --> 00:08:02,450

167
00:08:02,450 --> 00:08:06,870
אז ממשיך הלאה ולהמשיך הלאה במקצת
מהר יותר, אנחנו הולכים לדבר על נתונים

168
00:08:06,870 --> 00:08:07,350
מבנים.

169
00:08:07,350 --> 00:08:08,040
יש הרבה.

170
00:08:08,040 --> 00:08:10,080
כיסינו חבורה שלהם.

171
00:08:10,080 --> 00:08:12,500
הנה מה שאתה צריך להבין
על מבנה הנתונים.

172
00:08:12,500 --> 00:08:15,590
>> אתה באמת צריך להבין בגבוה
רמה מה הוא כל מבנה.

173
00:08:15,590 --> 00:08:21,190
האם אתה יכול להסביר באנגלית לך
חבר שלא נקט CS50 איך

174
00:08:21,190 --> 00:08:25,580
אנחנו מארגנים את הנתונים שלנו ולמה אנחנו היינו
ישתמש משהו בדרך זו?

175
00:08:25,580 --> 00:08:26,990
זה דבר אחד.

176
00:08:26,990 --> 00:08:29,650
דבר שני, מבין
היישום.

177
00:08:29,650 --> 00:08:34,270
אז להבין כיצד להשתמש בדברים האלה
בג ואנחנו נלך על זה.

178
00:08:34,270 --> 00:08:39,030
>> ואז דבר שלושה היה יודע
פעמים לרוץ והמגבלות של

179
00:08:39,030 --> 00:08:40,470
מבנים שונים אתה משתמש.

180
00:08:40,470 --> 00:08:44,059
אז הבנתי למה היית משתמש
חשיש שולחן במקום מערך.

181
00:08:44,059 --> 00:08:49,570
להבין כמה מהר, בממוצע,
גישה לשולחן חשיש.

182
00:08:49,570 --> 00:08:54,010
להבין מה פעולות מהירות על
רשימה מקושרת אבל איטית על מערכים ו

183
00:08:54,010 --> 00:08:56,080
להיפך.

184
00:08:56,080 --> 00:08:59,780
אז כדי להבין את זה, יהיה לך ל
מבין סימון Big-O רק כדי לדעת

185
00:08:59,780 --> 00:09:01,310
איך לדבר על אלה
מיני דברים.

186
00:09:01,310 --> 00:09:02,700
ונדבר על זה.

187
00:09:02,700 --> 00:09:06,040
>> דבר אז קודם כל, רשימות מקושרות.

188
00:09:06,040 --> 00:09:07,770
הנה תמונה ברמה גבוהה
של רשימה מקושרת.

189
00:09:07,770 --> 00:09:08,830
אנחנו מראים את זה בכיתה.

190
00:09:08,830 --> 00:09:11,670
בדרך כלל יש לנו 10 אנשים
עומד על הבמה.

191
00:09:11,670 --> 00:09:16,790
אבל יש לנו סדרה של צמתים שבו כל
יש צומת קצת ערך ומצביע

192
00:09:16,790 --> 00:09:18,610
לערך הבא שלה.

193
00:09:18,610 --> 00:09:21,730
אז כדי להגיע מצומת אחד למשנהו, אתה
רק אומר, תן לי את הצומת הבאה.

194
00:09:21,730 --> 00:09:22,530
יש לך הצומת.

195
00:09:22,530 --> 00:09:23,770
תן לי את הצומת הבאה.

196
00:09:23,770 --> 00:09:24,400
יש לך הצומת.

197
00:09:24,400 --> 00:09:28,790
תן לי את הצומת הבאה וכן הלאה
עד שאין שמאל צומת.

198
00:09:28,790 --> 00:09:31,850
>> אז תמשיך לדבר על
זה ברמה גבוהה.

199
00:09:31,850 --> 00:09:34,100
זה קל מאוד להכניס דברים
לרשימה מקושרת.

200
00:09:34,100 --> 00:09:36,010
אם לא אכפת לך על ההזמנה,
אתה יכול פשוט להפיל אותו

201
00:09:36,010 --> 00:09:36,840
מייד בהתחלה.

202
00:09:36,840 --> 00:09:38,520
זה זמן קבוע.

203
00:09:38,520 --> 00:09:39,900
אבל קשה למצוא את ערך.

204
00:09:39,900 --> 00:09:43,060
אם אתה מנסה לשאול,
הוא שבע ברשימה שלי?

205
00:09:43,060 --> 00:09:44,740
אתה צריך לעבור
כל ערך.

206
00:09:44,740 --> 00:09:45,680
האם זה שבע?

207
00:09:45,680 --> 00:09:46,610
האם זה שבע?

208
00:09:46,610 --> 00:09:47,770
האם זה שבע?

209
00:09:47,770 --> 00:09:48,690
האם זה שבע?

210
00:09:48,690 --> 00:09:49,830
שוב ושוב.

211
00:09:49,830 --> 00:09:51,520
וזה O (n).

212
00:09:51,520 --> 00:09:53,800
לכן, כאשר לומדים לחידון,
להשוות את זה עם מערכים.

213
00:09:53,800 --> 00:09:57,010

214
00:09:57,010 --> 00:09:58,220
>> האם זה בסדר?

215
00:09:58,220 --> 00:09:59,220
האורות כבו עמומות.

216
00:09:59,220 --> 00:10:01,110
על אישור.

217
00:10:01,110 --> 00:10:02,400
מתי רשימה מקושרת טובה יותר?

218
00:10:02,400 --> 00:10:04,640
כאשר הוא מערך טוב יותר?

219
00:10:04,640 --> 00:10:06,670
אז בואו נסתכל על כמה קוד.

220
00:10:06,670 --> 00:10:08,960
הנה צומת פוטנציאלית.

221
00:10:08,960 --> 00:10:09,770
זה struct.

222
00:10:09,770 --> 00:10:12,220
יש לו n int, אשר
יהיה הערך שלנו.

223
00:10:12,220 --> 00:10:17,780
ויש לה צומת struct * הבא, אשר
הוא מצביענו לצומת הבאה.

224
00:10:17,780 --> 00:10:23,040
אז הנה, אנחנו יכולים לראות שאנחנו קרו
ליש לשים int בצומת שלנו.

225
00:10:23,040 --> 00:10:27,850
אבל אם זו היתה רשימה מקושרת של char
כוכבים או רשימה מקושרת של צף, אנחנו

226
00:10:27,850 --> 00:10:28,820
לגמרי יכול לעשות את זה יותר מדי.

227
00:10:28,820 --> 00:10:33,110
>> זכרו בpset6, סביר להניח שהיה לי
רשימה מקושרת של כוכבי char או סתם

228
00:10:33,110 --> 00:10:34,360
מערכי char סטטי.

229
00:10:34,360 --> 00:10:37,370

230
00:10:37,370 --> 00:10:39,040
בואו נסתכל כאן במבצע.

231
00:10:39,040 --> 00:10:43,570
אז אנחנו רוצים להכניס חדשים
n לרשימה המקושרת שלנו.

232
00:10:43,570 --> 00:10:48,940
אנחנו מתחילים עם מצביע ראש שהוא
מצביע לצומת הזה שיש לו את

233
00:10:48,940 --> 00:10:53,460
ערך של n והבא של מצביע כי
נקודות לצומת הזה היא ערך של

234
00:10:53,460 --> 00:10:57,760
n והבא של null, כי
זה הצומת האחרונה.

235
00:10:57,760 --> 00:11:00,440
אז בעניין של זמן, אני
לשים את כל הקוד על המסך.

236
00:11:00,440 --> 00:11:03,130
ונדריך את דרכו
כמה שורות בכל פעם.

237
00:11:03,130 --> 00:11:05,790
>> אז הנה הקוד.

238
00:11:05,790 --> 00:11:07,560
אני מקווה שזה קריא.

239
00:11:07,560 --> 00:11:11,275
הדבר הראשון שאנחנו עושים הוא
אנו malloc צומת חדשה.

240
00:11:11,275 --> 00:11:15,105
אז זה הופך את מצביע לצומת חדשה ש
לא די לי שום דבר מוגדר

241
00:11:15,105 --> 00:11:16,450
בזה עדיין.

242
00:11:16,450 --> 00:11:19,580
אנחנו בודקים לוודא כי
הצומת החדשה היא לא ריקה.

243
00:11:19,580 --> 00:11:22,220
אחרת, אנחנו צריכים לוותר.

244
00:11:22,220 --> 00:11:27,680
אז לאחר שבדק כי, אנחנו עכשיו
להגדיר את הערכים בצומת.

245
00:11:27,680 --> 00:11:31,520
אז אנחנו שמים n החדש לתוך שדה n שלנו.

246
00:11:31,520 --> 00:11:36,050
ואנו קובעים את המצביע הבא כדי להצביע
הראש המקורי, כך שנוכל

247
00:11:36,050 --> 00:11:38,900
עכשיו הכניס את זה
צומת לרשימה שלנו.

248
00:11:38,900 --> 00:11:44,600
>> לבסוף, יש לנו את נקודת הראש הגלובלית
לצומת החדשה שלנו, כך שאם היינו

249
00:11:44,600 --> 00:11:50,300
להתחיל בראש, היינו בשלב זה
הצומת הראשונה חדשה במקום

250
00:11:50,300 --> 00:11:51,560
הצומת הראשונה הישנה.

251
00:11:51,560 --> 00:11:55,320
וכאשר פונקציה זו יוצאת,
צומת חדשה משתנה כבר לא קיימת,

252
00:11:55,320 --> 00:11:57,130
בגלל שזה היה מקומי לפונקציה.

253
00:11:57,130 --> 00:11:59,770
אז זה המצב של העולם.

254
00:11:59,770 --> 00:12:03,570
הראש הגלובלי שלנו מצביע על החדש שלנו
צומת ראשונה, שמצביעה עלינו

255
00:12:03,570 --> 00:12:06,346
צומת הראשונה מקורית, שנקודות
לצומת אחרי זה.

256
00:12:06,346 --> 00:12:09,790
>> זה היה כניסה.

257
00:12:09,790 --> 00:12:12,150
אני מקווה שהיה יחסית
פשוט לעקוב.

258
00:12:12,150 --> 00:12:14,300
במקרה של ספק, לצייר תמונה.

259
00:12:14,300 --> 00:12:17,820
אז אני מוצא שמדבר על
רשימות מקושרות ומסתכל על

260
00:12:17,820 --> 00:12:19,870
קוד הוא מאוד לא מועיל.

261
00:12:19,870 --> 00:12:23,790
בעוד מסתכל על תמונה של מקושר
רשימה מאפשרת לי לחשוב, הו, כל כך

262
00:12:23,790 --> 00:12:24,970
יש לי את הצומת הזה כאן.

263
00:12:24,970 --> 00:12:28,980
אבל אם אני מעדכן את המצביע ש,
זה בסופו מנותק.

264
00:12:28,980 --> 00:12:34,340
ושכחתי שבי
הצומת הולכת.

265
00:12:34,340 --> 00:12:35,390
וקוד יציאתו.

266
00:12:35,390 --> 00:12:37,830
ויש לך צמתים מרובים
כי הם מנותקים.

267
00:12:37,830 --> 00:12:39,970
ואתה לא בסופו של דבר עם
הרשימה שאתה רוצה.

268
00:12:39,970 --> 00:12:43,320
>> אז אם אתה מצייר את התמונה ולעשות את זה
צעד אחר צעד, בתקווה, תוכל לראות

269
00:12:43,320 --> 00:12:46,840
הסדר הנכון של דברים במונחים של
עדכון המצביעים כדי לוודא

270
00:12:46,840 --> 00:12:48,830
כי הרשימה מגיעה ביחד.

271
00:12:48,830 --> 00:12:51,240
הכנס הוא פשוט יחסית.

272
00:12:51,240 --> 00:12:55,210
אחד מסובך יותר יהיה
כניסה לתוך רשימה ממוינת.

273
00:12:55,210 --> 00:12:59,980
פונקציה מסובכת יותר היא למחוק
ותמצא, ולכן מחפש דרך רשימה

274
00:12:59,980 --> 00:13:03,030
לראות אם יש שם משהו.

275
00:13:03,030 --> 00:13:07,220
אולי אתה עשית את זה בpset6 כאשר אתה
נכנס לטבלת הגיבוב שלך ואתה אמר,

276
00:13:07,220 --> 00:13:10,460
כן, הוא המילה התפוח
ברשימה המקושרת שלי?

277
00:13:10,460 --> 00:13:11,440
>> אז ייתכן שכבר עשה את זה.

278
00:13:11,440 --> 00:13:15,530
אבל בהחלט, לרענן את זכרונך
ולנסות reimplement חיפוש ו

279
00:13:15,530 --> 00:13:19,150
reimplement למחוק לרשימה מקושרת.

280
00:13:19,150 --> 00:13:22,850
הערה צדדית כיף, יש גם כפליים צמוד
רשימות, שבו יש לך

281
00:13:22,850 --> 00:13:27,490
מצביעים שמצביעים הן לפנים והן
אחורה, כך שאתה יכול ללכת ל

282
00:13:27,490 --> 00:13:29,270
הצומת הבאה ולצומת הקודמת.

283
00:13:29,270 --> 00:13:33,860
ולא הייתה שאלה בשנה שעברה
חידון מסוג זה, מדבר

284
00:13:33,860 --> 00:13:36,190
על כפליים צמוד רשימות.

285
00:13:36,190 --> 00:13:40,070
>> עכשיו, זה מבנה שאתה
מוכר יחסית עם, משום שרוב

286
00:13:40,070 --> 00:13:42,520
שלך כנראה השתמש בהם על pset6.

287
00:13:42,520 --> 00:13:45,680
הנה אחד שזה קצת פחות מוכר.

288
00:13:45,680 --> 00:13:51,020
בתור הערה צדדית, אני חושב ש1 חידון הוא
בעיקר קשה יותר מחידון 0, כי

289
00:13:51,020 --> 00:13:54,600
הדברים שאתה עושה, אתה
לא עשה כל כך הרבה.

290
00:13:54,600 --> 00:13:58,100
כדי לשים את זה בדרך אחרת, לחידון 0,
אתה כתב הרבה ואנחנו ג

291
00:13:58,100 --> 00:13:58,880
שאלתי אותך על ג

292
00:13:58,880 --> 00:14:02,310
>> עבור 1 חידון, אנחנו הולכים לשאול אותך על
PHP ו-JavaScript, שבו אתה

293
00:14:02,310 --> 00:14:03,490
לא כפי שנכתב הרבה.

294
00:14:03,490 --> 00:14:07,590
אנחנו הולכים לשאול אותך על C-קוד ש
אתה לא כתבת כמה שיותר,

295
00:14:07,590 --> 00:14:09,130
דברים C מתקדמים זו.

296
00:14:09,130 --> 00:14:11,520
אז בהחלט, לתרגל אותנו הדברים
דיבר עליו בהרצאה שאתה

297
00:14:11,520 --> 00:14:15,260
לא עשיתי בהכרח
על הבעיה להגדיר.

298
00:14:15,260 --> 00:14:17,870
>> ואם כבר מדבר, אתה לא כתבת
ערימה על בעיה להגדיר.

299
00:14:17,870 --> 00:14:19,610
אבל זה היה בהרצאה.

300
00:14:19,610 --> 00:14:22,530
הנה התמונה ברמה הגבוהה של
ערימות שאנו מציגים בכל שנה.

301
00:14:22,530 --> 00:14:26,180
זה הערימה של מגשים
חדר אוכל מאת'ר.

302
00:14:26,180 --> 00:14:30,570
ברמה גבוהה, הן הערימות האחרונות
ב, הראשון מתוך מבנה הנתונים.

303
00:14:30,570 --> 00:14:32,040
זה אומר שאתה הולך
כדי לשים את הדברים ב--

304
00:14:32,040 --> 00:14:36,400
1, 3, 7, 12, 14, 0 שליליים.

305
00:14:36,400 --> 00:14:39,180
דבר אחד אני לא יכול יש לי
אמר - שלילי 3, 0.

306
00:14:39,180 --> 00:14:40,250
אתה שם את כל הדברים האלה פנימה

307
00:14:40,250 --> 00:14:42,940
והאחרון אתה מכניס הוא ראשון
אחד שהולך לצאת.

308
00:14:42,940 --> 00:14:44,170
>> אז יש לך שתי פעולות -

309
00:14:44,170 --> 00:14:45,260
לדחוף ופופ.

310
00:14:45,260 --> 00:14:49,180
כל לשים שבהייתי
מחווה כזה הוא דחיפה.

311
00:14:49,180 --> 00:14:52,020
ואז כשאני מגיע לגזל
משהו או להגיע למעלה כדי לתפוס

312
00:14:52,020 --> 00:14:53,940
משהו, זה פופ.

313
00:14:53,940 --> 00:14:55,540
אז אנחנו הולכים ליישם את הערימות.

314
00:14:55,540 --> 00:14:57,870
והראיתי להם בהרצאה
שימוש במערכים.

315
00:14:57,870 --> 00:14:59,550
אבל אתה יכול לעשות אותם
באמצעות רשימות מקושרות.

316
00:14:59,550 --> 00:15:01,770
ערימה היא נתונים רעיוניים
מבנה, לא אוהב

317
00:15:01,770 --> 00:15:03,760
אחד יישום ספציפי.

318
00:15:03,760 --> 00:15:06,420
>> אז מה שהייתי נראה?

319
00:15:06,420 --> 00:15:07,970
זה היה נראה כמו סוג של זה.

320
00:15:07,970 --> 00:15:10,840
שתהיה לך בגודל של מספרים שלמים.

321
00:15:10,840 --> 00:15:16,000
ושתהיה לך מערך של ערכים ש
אנחנו קוראים מגשים, כי זה

322
00:15:16,000 --> 00:15:18,570
מה התמונה הייתה עבור
שלנו - int מגשים -

323
00:15:18,570 --> 00:15:21,740
ולאחר מכן כמה קיבולת המקסימלית.

324
00:15:21,740 --> 00:15:27,100
אז מה היה דוחף את נראה?

325
00:15:27,100 --> 00:15:33,250
ובכן, אם יש לנו של מחסנית, ואז לדחוף את
משהו על ים, היינו מקבל

326
00:15:33,250 --> 00:15:34,620
גודלו של ים.

327
00:15:34,620 --> 00:15:42,270
וזה יהיה הבא
נקודה פתוחה של המערך שלנו.

328
00:15:42,270 --> 00:15:50,510
אז אם יש לנו שלושה דברים בערימה שלנו,
לאחר מכן מגשים 3 יהיה הבא

329
00:15:50,510 --> 00:15:54,290
מקום פתוח, כי 0, 1, ו
2 כבר התמלאו.

330
00:15:54,290 --> 00:16:01,790
>> אז אנחנו שמים את הערך לתוך
s.trays [s.size], המקום השלישי.

331
00:16:01,790 --> 00:16:06,290
ואז להגדיל s.size לומר,
היי, היו לנו שלושה דברים לפני.

332
00:16:06,290 --> 00:16:07,400
עכשיו, יש לנו ארבעה.

333
00:16:07,400 --> 00:16:10,180
אז בפעם הבאה שאתה דוחף, אתה
הולך לשים משהו לתוך 4.

334
00:16:10,180 --> 00:16:15,560
או בפעם הבאה שאתה קופץ, אתה הולך
להסתכל על 3 במקום 4 או משהו כזה.

335
00:16:15,560 --> 00:16:18,000
ולאחר מכן נחזור נאמן ל
נניח, היי, הצלחנו.

336
00:16:18,000 --> 00:16:19,160
זה עבד.

337
00:16:19,160 --> 00:16:22,060
ככלל אצבע, אם פונקציה זו
אמור לחזור אמיתי או

338
00:16:22,060 --> 00:16:26,370
השקר תמיד מחזיר אמת, ייתכן
עשה משהו לא בסדר.

339
00:16:26,370 --> 00:16:28,350
אז זה עובד?

340
00:16:28,350 --> 00:16:32,400
>> ובכן, זה עובד מצוין עבור 1, ו
2, ו 3, ו -4, וחמש.

341
00:16:32,400 --> 00:16:34,640
אבל בואו נגיד שאני מגיע לקיבולת שלי.

342
00:16:34,640 --> 00:16:38,750
אז אני כבר נתקלתי בבעיה, כי
אם הגודל זהה לקיבולת, אני

343
00:16:38,750 --> 00:16:43,340
עכשיו מנסה לשים משהו לתוך
מערך שבו אין לי מקום.

344
00:16:43,340 --> 00:16:46,980
אז בדיקה קצרה כדי לתקן את זה.

345
00:16:46,980 --> 00:16:51,630
אם s.size קיבולת ==, בתמורת שווא.

346
00:16:51,630 --> 00:16:54,130
אחרת, ללכת ולעשות את מה שעשינו.

347
00:16:54,130 --> 00:16:55,660
אז מה עוד אנחנו יכולים לבקש
על לערימות?

348
00:16:55,660 --> 00:16:56,460
מה עוד אתה צריך ללמוד?

349
00:16:56,460 --> 00:16:57,690
מה עוד אתה צריך להתאמן?

350
00:16:57,690 --> 00:17:01,030
>> ובכן, יישום פופ.

351
00:17:01,030 --> 00:17:02,370
אנחנו כבר עשינו את הדחיפה.

352
00:17:02,370 --> 00:17:04,280
אני אסדר את זה.

353
00:17:04,280 --> 00:17:08,180
יישום שאינו מערך, שבו
אתה משתמש ברשימה מקושרת, אולי.

354
00:17:08,180 --> 00:17:09,390
יישום שאינו int.

355
00:17:09,390 --> 00:17:10,940
עשינו ints כאן.

356
00:17:10,940 --> 00:17:11,880
אבל זה היה יכול להיות צף.

357
00:17:11,880 --> 00:17:13,010
היינו יכול להיות מחרוזות.

358
00:17:13,010 --> 00:17:14,290
זה היה יכול להיות כוכבי char.

359
00:17:14,290 --> 00:17:17,960
תראה חידוני העבר למינים
שאלות שכבר נשאלות על ערימות.

360
00:17:17,960 --> 00:17:20,000
>> אני אומר שאנחנו מכוסים ערימות סביב
אותו הדבר כמו שכבר כיסו אותם ב

361
00:17:20,000 --> 00:17:20,540
שנים האחרונות.

362
00:17:20,540 --> 00:17:24,400
אז שאלות החידון צריכה
להיות אינדיקציה טובה.

363
00:17:24,400 --> 00:17:27,010
במבט קדימה אפילו מהר יותר, תורים.

364
00:17:27,010 --> 00:17:28,200
הם כמו ערימות.

365
00:17:28,200 --> 00:17:29,960
אבל הם הראשונים, את הראשון.

366
00:17:29,960 --> 00:17:33,530
אם אתה בריטי, בתור המילה
כנראה עשיתי הרבה חוש לך.

367
00:17:33,530 --> 00:17:36,390
אחרת, ייתכן שיש לך
שמע על זה כעל קו.

368
00:17:36,390 --> 00:17:38,120
הם עובדים כמו הקו
בחנות של אפל.

369
00:17:38,120 --> 00:17:40,740
האדם הראשון להופיע בשעה 3:00
בבוקר הוא הראשון

370
00:17:40,740 --> 00:17:42,880
אדם לקנות iPad שלו.

371
00:17:42,880 --> 00:17:44,260
>> אז יש לנו שתי פעולות -

372
00:17:44,260 --> 00:17:45,720
הוסף לתור וdequeue.

373
00:17:45,720 --> 00:17:47,560
הוסף לתור מעמיד מישהו בקו.

374
00:17:47,560 --> 00:17:50,070
Dequeue מושך הראשון
אדם מן השורה.

375
00:17:50,070 --> 00:17:52,640
שוב, אנחנו יכולים ליישם
זה עם מערך.

376
00:17:52,640 --> 00:17:54,880
אז מה אנחנו struct
הראה בהרצאה?

377
00:17:54,880 --> 00:17:57,660
זה היה זה.

378
00:17:57,660 --> 00:17:59,300
שוב, מספרים.

379
00:17:59,300 --> 00:18:02,020
שוב, גודל ומול הדבר החדש הזה.

380
00:18:02,020 --> 00:18:04,880
מדוע יש משהו שנקרא חזית?

381
00:18:04,880 --> 00:18:07,050
זה המדד הבא
אלמנט לdequeue.

382
00:18:07,050 --> 00:18:12,210
זה רק באופן פנימי שמירה על המסלול של
הבחור הראשון להופיע, אז אנחנו ש

383
00:18:12,210 --> 00:18:15,005
יכול למשוך אותו החוצה כאשר אנחנו צריכים.

384
00:18:15,005 --> 00:18:19,322
>> בהחלט מסתכלים על סיכומי הרצאות ולנסות
ליישם Enqueue וdequeue

385
00:18:19,322 --> 00:18:21,700
כאשר לומדים לחידון.

386
00:18:21,700 --> 00:18:23,190
דברים חשובים שיש לחשוב עליו.

387
00:18:23,190 --> 00:18:27,260
גלישה מסביב אם החזית בתוספת
גודל סופו של דבר גדול יותר מקיבולת.

388
00:18:27,260 --> 00:18:32,670
שוב, אם המבנה שלך מלא,
אתה הולך יש לי בעיה.

389
00:18:32,670 --> 00:18:34,780
חשיש שולחנות שראיתם בעבר.

390
00:18:34,780 --> 00:18:39,820
רובכם כנראה מיושמים
אלה על pset6.

391
00:18:39,820 --> 00:18:44,210
זה מבנה שנועד לO (1)
החדרת זמן קבוע וO (1)

392
00:18:44,210 --> 00:18:46,430
בדיקת זמן קבועה.

393
00:18:46,430 --> 00:18:49,760
>> בCS50, יישמנו את זה כ
מערך של רשימות מקושרות.

394
00:18:49,760 --> 00:18:53,690
המרכיב המרכזי לשולחן חשיש
היא הפונקציה חד כיוונית.

395
00:18:53,690 --> 00:18:58,350
אז הוא ממיר את הקלט שלך, נניח,
מילה במילון, למספר,

396
00:18:58,350 --> 00:18:59,560
שהוא הולך להיות האינדקס שלנו.

397
00:18:59,560 --> 00:19:01,410
ואנו נשתמש מדד
למערך שלנו.

398
00:19:01,410 --> 00:19:05,374
אז הנה תמונה קטנה וחמודה
מstudy.50.net.

399
00:19:05,374 --> 00:19:08,060
אנחנו זורקים את כל המילים לתוך
פונקציית hash שלנו.

400
00:19:08,060 --> 00:19:10,950
ופונקציית hash אומרת לנו
איפה לשים את המילים האלה.

401
00:19:10,950 --> 00:19:15,650
>> כל זה הוא גדול בארץ שבה
יש רק מילה אחת לכל חריץ.

402
00:19:15,650 --> 00:19:20,480
אבל כפי שאתה זוכר מpset6, יש
יותר מילות מאשר חריצים.

403
00:19:20,480 --> 00:19:23,080
אז מה קורה כאשר אתה
תקבל התנגשות?

404
00:19:23,080 --> 00:19:26,730
במקום לאחסן ערך אחד ב,
נניח, חשיש טבלה 3, אתה

405
00:19:26,730 --> 00:19:27,990
לאחסן רשימה מקושרת.

406
00:19:27,990 --> 00:19:32,900
וכך במקום שיש מלון
כאן, יש לך רשימה מקושרת,

407
00:19:32,900 --> 00:19:34,190
שבו על הצומת הראשונה היא מלון.

408
00:19:34,190 --> 00:19:35,260
ואת הצומת הבאה היא חתול.

409
00:19:35,260 --> 00:19:38,970
ואת הצומת השלישית היא התנגשות, בוא
אומר, כי כל המילים האלה מתחילות

410
00:19:38,970 --> 00:19:41,110
עם ג

411
00:19:41,110 --> 00:19:42,700
>> אז רובכם עשה את זה לpset6.

412
00:19:42,700 --> 00:19:45,685
אם אתה לא עושה את שולחן חשיש בpset6
ואתה ניסית משהו כמו

413
00:19:45,685 --> 00:19:47,720
הגיבורים, בהחלט לסקור שולחנות חשיש.

414
00:19:47,720 --> 00:19:50,650
אם אתה עשית את זה בpset6, בהחלט
תסקור שולחנות חשיש.

415
00:19:50,650 --> 00:19:53,610
ואם עשה את זה בpset6 וזה לא
נסתדר לגמרי בסדר ואתה

416
00:19:53,610 --> 00:19:56,150
היה לי הרבה בעיות עם זה, בהחלט
תסקור שולחנות חשיש.

417
00:19:56,150 --> 00:20:01,610
אז את הלקח באמת הוא בהחלט
תסקור שולחנות חשיש.

418
00:20:01,610 --> 00:20:07,130
>> המיעוט העצום שלך ניסה
את מנסה בpset6.

419
00:20:07,130 --> 00:20:08,570
תמונה ברמה גבוהה.

420
00:20:08,570 --> 00:20:15,150
זה משהו כמו זה, שבו כל
יש צומת קבוצה של ילדים, שבו כל

421
00:20:15,150 --> 00:20:17,100
ילד מתאים למכתב.

422
00:20:17,100 --> 00:20:20,520
ובכל צומת גם אומרת,
היי, אני מילה.

423
00:20:20,520 --> 00:20:25,933
אז במקרה הזה, המילה מקסוול,
אם אתה מבין את M ל

424
00:20:25,933 --> 00:20:28,530
X-W-E-L-L ולאחר מכן בצעתי אותו לאחד יותר.

425
00:20:28,530 --> 00:20:32,800
ואתה מקבל סמל, דלתא, זה שבו
אנחנו מסמנים לפירוש זה הוא מילה.

426
00:20:32,800 --> 00:20:34,780
אז מקסוול הוא מילה.

427
00:20:34,780 --> 00:20:38,430
הד לתות אלו ברחבי מסמנים
שדברים הם מילים ובי

428
00:20:38,430 --> 00:20:40,360
דברים הם לא.

429
00:20:40,360 --> 00:20:46,400
>> אז בpset6, הנתונים שמאוחסנים
לצד כל אחד מצומת שלנו היה "אני

430
00:20:46,400 --> 00:20:52,630
מילה. "והדבר מגניב על ניסיונות
הוא שהם מדגימים הכנסה ו

431
00:20:52,630 --> 00:20:55,080
בדיקה בO (אורך של מילה).

432
00:20:55,080 --> 00:20:59,450
אז רק כדי לעבור את מקסוול, זה
M--X-W-E-L-L. אז שבע או שמונה -

433
00:20:59,450 --> 00:21:00,360
אני לא יכול לספור -

434
00:21:00,360 --> 00:21:03,920
צעדים כדי להגיע בסופו
ולבדוק את הדברים.

435
00:21:03,920 --> 00:21:06,800
יישום כל כך מהיר כאן.

436
00:21:06,800 --> 00:21:10,230
רוב עבר מקושר
רשימה בנתיחה שלאחר מותו.

437
00:21:10,230 --> 00:21:11,600
כדי לבדוק את זה.

438
00:21:11,600 --> 00:21:11,720
סליחה.

439
00:21:11,720 --> 00:21:13,240
עבר מלבלבים בנתיחה שלאחר מותו.

440
00:21:13,240 --> 00:21:14,260
כדי לבדוק את זה.

441
00:21:14,260 --> 00:21:24,410
>> אבל אתה בעצם יש יש כל צומת 27
מצביעים לצומת הבאים ואחד

442
00:21:24,410 --> 00:21:27,050
בוליאני עבור אני מילה.

443
00:21:27,050 --> 00:21:31,530
בדוק את הנתיחה שלאחר מותו של רוב לאיך
למעשה זה מיושם.

444
00:21:31,530 --> 00:21:34,750
המבנה הסופי שלנו, העצים שלנו
ועצי חיפוש בינארי.

445
00:21:34,750 --> 00:21:41,530
אז מסתכל על אלה, אלה היו מכוסים
לאחרונה שבוע 8, יום שני.

446
00:21:41,530 --> 00:21:46,960
עץ דומה לגיבורים, חוץ ממך
אין לי בהכרח 27 צמתים ב

447
00:21:46,960 --> 00:21:47,500
כל נקודה.

448
00:21:47,500 --> 00:21:52,820
ואין לך את הנתונים בכל
צעד שמסמן אם -

449
00:21:52,820 --> 00:21:54,030
הדרך לא משנה.

450
00:21:54,030 --> 00:22:00,870
ואילו הגיבורים, את הנתיב מלמעלה
תחתון, מקסוול, היה חשוב לנו.

451
00:22:00,870 --> 00:22:05,270
>> אבל יש כל צומת מרובה
ילדים, אולי.

452
00:22:05,270 --> 00:22:07,290
יש לנו כמה אוצר מילים יותר.

453
00:22:07,290 --> 00:22:09,530
השורש של העץ
הוא בחלקו העליון.

454
00:22:09,530 --> 00:22:12,520
ואנו אומרים כי מאוד תחתון
צמתים שאין להם

455
00:22:12,520 --> 00:22:14,530
ילדים הם עלים.

456
00:22:14,530 --> 00:22:18,040
אז כמו הגיבורים, עץ הוא
מבנה של צמתים.

457
00:22:18,040 --> 00:22:21,490
סוג נפוץ של עץ שאנחנו הולכים
לדבר עליו הוא עץ בינארי, שבו

458
00:22:21,490 --> 00:22:26,040
יש כל צומת אין ילדים או
ילד אחד או שני ילדים.

459
00:22:26,040 --> 00:22:28,890
אז התמונה הזאת כאן היא לא
עץ בינארי, כי

460
00:22:28,890 --> 00:22:32,890
יש צומת 3 לשלושה ילדים.

461
00:22:32,890 --> 00:22:38,140
>> אבל אם היינו להתעלם מאלו, שאר
שלו הוא עץ בינארי כי זה

462
00:22:38,140 --> 00:22:43,200
מדגים את הרכוש שכל צומת
יש אפס, אחד או שני ילדים.

463
00:22:43,200 --> 00:22:46,400
אז איך אנחנו יכולים להביע את זה בקוד?

464
00:22:46,400 --> 00:22:51,460
יש לנו יכול צומת שבו כל צומת יש
שלם בתוכו, כמו גם

465
00:22:51,460 --> 00:22:55,590
כמצביע לעץ בצד השמאל
ומצביע לעץ על

466
00:22:55,590 --> 00:22:59,510
בסדר, אז שני ילדים.

467
00:22:59,510 --> 00:23:00,880
איך זה שימושי?

468
00:23:00,880 --> 00:23:05,740
ובכן, אם אנחנו עושים את הכללים על איפה אנחנו
לשים צמתים, אנחנו יכולים לעשות חיפוש מהיר יותר.

469
00:23:05,740 --> 00:23:10,630
>> אז יש רעיון של חיפוש בינארי
עץ, שבו כל צמתים על

470
00:23:10,630 --> 00:23:14,420
יש עץ משנה עזב את ערך קטן יותר
מהצומת אנחנו מסתכלים.

471
00:23:14,420 --> 00:23:17,880
וכל צמתים בעץ המשנה תקין
יש ערך רב יותר

472
00:23:17,880 --> 00:23:18,660
מצומת השורש.

473
00:23:18,660 --> 00:23:20,670
עכשיו, זה נראה כמו הרבה מילות.

474
00:23:20,670 --> 00:23:23,770
אני הולך לשים אותו בתוך כפול
ציטוטים ולהראות לך תמונה.

475
00:23:23,770 --> 00:23:27,010
אז הנה דוגמא של
עץ חיפוש בינארי.

476
00:23:27,010 --> 00:23:28,770
רואה שאנחנו מתחילים עם 10.

477
00:23:28,770 --> 00:23:31,780
כל מה שמשמאל
10 הוא קטנים יותר ממה שהוא.

478
00:23:31,780 --> 00:23:33,130
והכל בצד הימין
הוא גדול יותר ממה שהוא.

479
00:23:33,130 --> 00:23:37,620
>> אבל יותר מזה, כל צומת ב
העץ מבטא את הנכס הזה.

480
00:23:37,620 --> 00:23:42,110
אז יש את הצומת 7 3 עד
על ימין ועל 9 בצד הימין.

481
00:23:42,110 --> 00:23:44,440
אז כל אלה הם קטנים יותר מאשר 10.

482
00:23:44,440 --> 00:23:50,470
אבל מסתכלים רק אלה, יש 7
3 לה השמאלי ו9 לזכותה.

483
00:23:50,470 --> 00:23:56,100
ובאופן דומה בצד הימין, יש 15 14
לה השמאלי ו50 לזכותה.

484
00:23:56,100 --> 00:24:03,770
אז שלושה צמתים שם, 15, 14,
ו50, גם עץ בינארי בתוקף

485
00:24:03,770 --> 00:24:05,480
או עץ חיפוש בינארי בתוקף.

486
00:24:05,480 --> 00:24:07,250
והם כולם גדולים יותר מ10.

487
00:24:07,250 --> 00:24:08,960
אז מותר להם להיות
בצד הימין שם.

488
00:24:08,960 --> 00:24:09,940
האם יש לך שאלה?

489
00:24:09,940 --> 00:24:12,580
>> קהל: איך אתם מתמודדים כאשר
יש לך שני שביעיות?

490
00:24:12,580 --> 00:24:12,850
>> R.J. אקינו: כן.

491
00:24:12,850 --> 00:24:16,550
איך אתה מתמודד עם שני ערכים
שהם אותו הדבר?

492
00:24:16,550 --> 00:24:21,465
כמה עצי חיפוש בינארי אומרים שאתה
להתעלם מכפילויות, כי המטרה היא

493
00:24:21,465 --> 00:24:24,280
רק כדי להגיד, שראיתי
הדברים האלה כל כך רחוקים.

494
00:24:24,280 --> 00:24:28,120
כמה עצי חיפוש בינארי שאפשר לומר
יש לספור בתוך הצומת.

495
00:24:28,120 --> 00:24:32,000
אחרים יכולים לומר כי הכל כדי
השמאל הוא פחות או שווה ל.

496
00:24:32,000 --> 00:24:33,470
והכל בצד הימין
גדול מ.

497
00:24:33,470 --> 00:24:36,520
>> זה פשוט תלוי במה
בעיה היא שאתה פותר.

498
00:24:36,520 --> 00:24:40,840
אז במילון, למשל, אתה
לא הייתי אכפת להם כפילויות.

499
00:24:40,840 --> 00:24:41,490
היית זורק אותם החוצה.

500
00:24:41,490 --> 00:24:44,719
אך ייתכן שאכפת איזו בעיה אחרת.

501
00:24:44,719 --> 00:24:49,242
>> קהל: האם זה אפשרי שיהיה לי
1 בצד השמאל של 15, אשר

502
00:24:49,242 --> 00:24:50,590
הוא פחות מ -10?

503
00:24:50,590 --> 00:24:51,885
>> R.J. אקינו: מס

504
00:24:51,885 --> 00:24:56,570
אם 14 כאן היו 1, היית עושה את זה
לא יהיה עץ חיפוש בינארי בתוקף,

505
00:24:56,570 --> 00:25:00,840
כי הכל בצד הימין של
10 צריך להיות גדול יותר ממה שהוא.

506
00:25:00,840 --> 00:25:02,300
ואנחנו תראו למה.

507
00:25:02,300 --> 00:25:07,960
אם בארץ חיפוש המטרה שלי היא
למצוא 14, אני מתחיל בשורש.

508
00:25:07,960 --> 00:25:08,500
אז אני מסתכל.

509
00:25:08,500 --> 00:25:08,710
על אישור.

510
00:25:08,710 --> 00:25:10,670
אנחנו הולכים להתחיל בשורש.

511
00:25:10,670 --> 00:25:12,500
תראה 10.

512
00:25:12,500 --> 00:25:16,050
>> ובכן, 14, היעד שלנו,
הוא גדול יותר מ10.

513
00:25:16,050 --> 00:25:17,370
אז זה חייב להיות בצד הימין.

514
00:25:17,370 --> 00:25:21,780
זה דומה מאוד לכל הטלפון
דבר ספר שעשינו, בינארי

515
00:25:21,780 --> 00:25:23,720
לחפש שם.

516
00:25:23,720 --> 00:25:26,430
אבל במקום לחפש בינארי
במערך, אנחנו ינארי

517
00:25:26,430 --> 00:25:28,490
חיפוש בעץ הזה.

518
00:25:28,490 --> 00:25:31,260
אז אנחנו עדיין מחפשים 14.

519
00:25:31,260 --> 00:25:32,480
ובכן, 14 הוא קטנים יותר מאשר 15.

520
00:25:32,480 --> 00:25:36,430
אז אם זה בעץ שלנו, הוא חייב
להיות בתחום זה כאן.

521
00:25:36,430 --> 00:25:39,680
זה חייב להיות בצד הימין של
10 ומשמאל 15.

522
00:25:39,680 --> 00:25:42,250
>> ואז אנחנו בודקים את הצומת הזה.

523
00:25:42,250 --> 00:25:45,790
וyay, מצאתי 14.

524
00:25:45,790 --> 00:25:46,760
אני לא מתכוון ללכת דרכו.

525
00:25:46,760 --> 00:25:48,090
אבל הנה הקוד.

526
00:25:48,090 --> 00:25:49,690
זה בעצם יחסית
פשוט,

527
00:25:49,690 --> 00:25:52,630
בגלל זה הוא רקורסיבית.

528
00:25:52,630 --> 00:25:55,420
מה שאנחנו יכולים לבקש ממך לעשות בחידון?

529
00:25:55,420 --> 00:25:57,000
אנחנו יכולים לבקש ממך לכתוב את הקוד הזה.

530
00:25:57,000 --> 00:25:59,170
אנחנו יכולים לשאול אותך להסתכל על הקוד הזה
ולשנות את הקוד הזה ולהסביר מה

531
00:25:59,170 --> 00:26:00,210
היא עושה.

532
00:26:00,210 --> 00:26:00,390
כן.

533
00:26:00,390 --> 00:26:00,770
שאלה?

534
00:26:00,770 --> 00:26:04,240
>> קהל: האם שקופיות אלה הולכים להיות
זמין כפי שהיו בפעם האחרונה?

535
00:26:04,240 --> 00:26:04,740
>> R.J. אקינו: כן.

536
00:26:04,740 --> 00:26:06,460
אז שקופיות אלה בהחלט
יפורסם.

537
00:26:06,460 --> 00:26:08,640
>> קהל: הם פורסמו דווקא
עכשיו באתר.

538
00:26:08,640 --> 00:26:10,020
דוד פשוט עשה את זה.

539
00:26:10,020 --> 00:26:12,720
>> R.J. אקינו: השקופיות
עכשיו באתר.

540
00:26:12,720 --> 00:26:16,420
אני בטח להטליא כמה
שגיאות הקלדה שציינתי ולתקן אותם.

541
00:26:16,420 --> 00:26:19,940
אבל יש נוכחית
גרסה באתר.

542
00:26:19,940 --> 00:26:21,820
אחרים דברים שאנחנו יכולים לבקש ממך לעשות -

543
00:26:21,820 --> 00:26:23,790
לכתוב להוסיף.

544
00:26:23,790 --> 00:26:27,490
לכתוב גרסה חוזרת ונשנית של
פונקציה רקורסיבית אנחנו רק הראיתי לך

545
00:26:27,490 --> 00:26:32,520
או לדבר על הדברים האלה, כמו ב
פסקאות, במילים, במשפטים.

546
00:26:32,520 --> 00:26:35,760
השוואה בין זמני ריצה ומסביר
מה שהיית רוצה להשתמש בינארי

547
00:26:35,760 --> 00:26:39,200
עץ חיפוש במקום
חשיש שולחן, למשל.

548
00:26:39,200 --> 00:26:43,580
>> אז מבין מבנים אלה
ברמה די עמוקה.

549
00:26:43,580 --> 00:26:47,440
להבין איך לכתוב אותם, איך
להשתמש בם, איך לדבר עליהם.

550
00:26:47,440 --> 00:26:50,270
ואתה תהיה מוכן.

551
00:26:50,270 --> 00:26:50,630
שאלה?

552
00:26:50,630 --> 00:26:55,070
>> קהל: כשאתה כותב
עץ חיפוש בינארי, איך אתה

553
00:26:55,070 --> 00:27:01,460
לקבוע מה ערך
לעשות את זה כמו השורש?

554
00:27:01,460 --> 00:27:06,120
>> R.J. אקינו: אז השאלה הייתה, מה
ערך אתם עושים כשורש?

555
00:27:06,120 --> 00:27:08,760
בהתאם לקוד שלך, אתה
ייתכן שיש לי שורש גלובלי.

556
00:27:08,760 --> 00:27:14,290
אז אתה יכול להיות סביר היה ב
pset6 שולחן חשיש עולמי.

557
00:27:14,290 --> 00:27:18,640
לחלופין, ייתכן שאתה עובר את השורש
כבטיעון.

558
00:27:18,640 --> 00:27:23,810
אז פונקצית חיפוש זה כאן
לוקח טיעון צומת *.

559
00:27:23,810 --> 00:27:27,420
ולכן כל מה שצומת יקרה לך להיות
מסתכל הוא אחד אתה מטפל

560
00:27:27,420 --> 00:27:31,510
כמו השורש שלך כאשר אתה עובר אותו פנימה

561
00:27:31,510 --> 00:27:32,320
ואני מסודר.

562
00:27:32,320 --> 00:27:33,480
אלה הם השקופיות שלי.

563
00:27:33,480 --> 00:27:35,940
האדם הבא יכול לבוא להחליף
במחשב נייד ומיקרופון.

564
00:27:35,940 --> 00:27:47,390

565
00:27:47,390 --> 00:27:49,760
>> ROB אודן: אני חושב שאולי יש לי
פירש את השאלה הזאת בצורה שונה.

566
00:27:49,760 --> 00:27:53,826
אבל אני פירשתי את זה כ, אם יש לך
המספרים 1, 2, ו -3, איך אנחנו

567
00:27:53,826 --> 00:27:56,720
לדעת לעשות 2 השורש
בניגוד ל1 או 3?

568
00:27:56,720 --> 00:27:59,480
אם אנחנו עושים את 2 השורש, אז זה יפה
1 ו -3 לשמאל וימין.

569
00:27:59,480 --> 00:28:04,610
אבל אם 1 הוא השורש, אז זה 1 ל
עליון, 2 מימין, 3 בצד הימין.

570
00:28:04,610 --> 00:28:10,880
אז כברירת מחדל, אתה לא יודע
מה לעשות שורש.

571
00:28:10,880 --> 00:28:15,400
ועבור כל אלגוריתם שאנחנו מצפים
לתת לך, רק הדבר הראשון שאתה

572
00:28:15,400 --> 00:28:16,680
הכנס יהיה השורש.

573
00:28:16,680 --> 00:28:19,890
או שאנחנו רוצים לתת לך עץ בינארי ש
כבר קיים שיש לו שורש.

574
00:28:19,890 --> 00:28:24,760
אבל אלגוריתמים אחרים קיימים כך ש
השורש יעדכן, כך שאם אתה

575
00:28:24,760 --> 00:28:28,370
בסופו של המצב שבו זה 1, 2,
3, זה יהיה באופן אוטומטי לעדכן את

576
00:28:28,370 --> 00:28:30,900
לעשות 2 השורש החדש, כך ש
זה עדיין יפה מאוזנת.

577
00:28:30,900 --> 00:28:33,750

578
00:28:33,750 --> 00:28:34,833
>> אנג'לה LI: מגניב.

579
00:28:34,833 --> 00:28:36,170
היי, חבר 'ה.

580
00:28:36,170 --> 00:28:37,810
אני אנג'לה.

581
00:28:37,810 --> 00:28:42,490
ואני הולך לסיים את C שלנו
ולאחר מכן להיכנס לכמה מהאתרים שלנו

582
00:28:42,490 --> 00:28:43,120
טכנולוגיות -

583
00:28:43,120 --> 00:28:46,570
HTTP, HTML, ו-CSS.

584
00:28:46,570 --> 00:28:49,610
אז הדבר הראשון הוא חיץ
התקפות בגלישה.

585
00:28:49,610 --> 00:28:53,070
אז בואו נסתכל על הקוד הזה.

586
00:28:53,070 --> 00:28:54,260
זה די פשוט.

587
00:28:54,260 --> 00:28:55,460
יש foo פונקציה.

588
00:28:55,460 --> 00:28:56,990
וזה לא מחזיר שום דבר.

589
00:28:56,990 --> 00:29:00,950
אבל זה לוקח במצביע
למחרוזת בשם בר.

590
00:29:00,950 --> 00:29:04,920
>> וזה הולך להכריז על זה
חיץ, שהוא דמות

591
00:29:04,920 --> 00:29:07,690
מערך שיש לי 12 חריצים.

592
00:29:07,690 --> 00:29:11,730
והיא משתמשת בה memcpy, שהוא רק
פונקציה שעותקים מכתובת אחת

593
00:29:11,730 --> 00:29:12,910
לאחר.

594
00:29:12,910 --> 00:29:19,400
אז זה הוא מנסה להעתיק לתוך
חיצנו מכל

595
00:29:19,400 --> 00:29:21,140
הבר מצביע.

596
00:29:21,140 --> 00:29:24,640
אז מושג מה לא בסדר
עם הקוד הזה?

597
00:29:24,640 --> 00:29:27,568

598
00:29:27,568 --> 00:29:30,830
>> קהל: אם הבר ארוך יותר
C, הם יחליפו.

599
00:29:30,830 --> 00:29:31,520
>> אנג'לה LI: כן, בדיוק.

600
00:29:31,520 --> 00:29:34,200
אין לנו שום ערובה לכך שבר
הולך להיות פחות מ 12.

601
00:29:34,200 --> 00:29:36,080
אנחנו פשוט עשינו כמה מספר שרירותי 12.

602
00:29:36,080 --> 00:29:38,380
ואנחנו היינו כמו, בואו נקווה ש
קלט המשתמש שלנו הוא פחות מ

603
00:29:38,380 --> 00:29:40,440
תווי 12 ארוך.

604
00:29:40,440 --> 00:29:46,320
אז בעולם אידיאלי, אם הקלט שלנו הוא
תמיד כצפוי, אז נגיע

605
00:29:46,320 --> 00:29:47,550
משהו כמו, הלו.

606
00:29:47,550 --> 00:29:48,920
זה פחות מ12 תווים.

607
00:29:48,920 --> 00:29:51,870
זה נהיה לקרוא לתוך char ג.

608
00:29:51,870 --> 00:29:53,280
ואז אנחנו עושים משהו עם זה.

609
00:29:53,280 --> 00:29:54,800
זה לא משנה באמת.

610
00:29:54,800 --> 00:29:59,740
>> אבל אדם זדוני יכול לעשות
משהו יותר כמו זה, שבו הם

611
00:29:59,740 --> 00:30:04,760
לתת לנו כל מה שהבר מצביע,
זה הולך להצביע למערך הענק הזה

612
00:30:04,760 --> 00:30:06,280
רק של.

613
00:30:06,280 --> 00:30:10,680
וזו הדרך ארוכה יותר מ12.

614
00:30:10,680 --> 00:30:13,830
אז זה הולך ללכת את כל הדרך
כאן למטה למקום שבי התמורה

615
00:30:13,830 --> 00:30:15,420
כתובת הייתה פעם.

616
00:30:15,420 --> 00:30:17,860
אז בואו נגיד שפונקציה זו
נקרא foo.

617
00:30:17,860 --> 00:30:20,970
אולי foo נקרא על ידי חלק אחר
פונקציה, שנקראה על ידי ראשי.

618
00:30:20,970 --> 00:30:24,890
לכן, כאשר foo פועל, שהוא צריך
לדעת לאן לחזור.

619
00:30:24,890 --> 00:30:29,130
>> אם foo נקרא על ידי כמה פונקציה בשם
באז, שיש לו יודע שזה

620
00:30:29,130 --> 00:30:30,250
צריך לחזור לאז.

621
00:30:30,250 --> 00:30:34,040
וזה מה שכתובה שולח זה
כאן אומר לנו.

622
00:30:34,040 --> 00:30:38,340
אבל אם להחליף אותו עם כמה אחר
כתובת, במקרה הזה, זה הוא

623
00:30:38,340 --> 00:30:42,650
ייצוג של הכתובת ב
מתחיל מאוד של חיץ זה, ולאחר מכן

624
00:30:42,650 --> 00:30:45,240
מה באמת הולך לקרות הוא ש
במקום לחזור בחזרה לאז,

625
00:30:45,240 --> 00:30:48,470
הנקרא הפונקציה שלנו, זה רק
הולך לחלק הקדמי של קוד זה.

626
00:30:48,470 --> 00:30:53,930
>> ואם זה היה שם כי
אחי האקר הזדוני בא ו

627
00:30:53,930 --> 00:30:56,820
הזריק את זה, אז אולי סכום זה
של שלו לא ממש של.

628
00:30:56,820 --> 00:31:02,030
וזה בעצם רק קוד שהפסקות
המחשב שלך או משהו.

629
00:31:02,030 --> 00:31:05,930
אז כדי להיות הגנתי על סוג זה של
דבר, יש לך אף פעם לא להניח כי

630
00:31:05,930 --> 00:31:09,120
קלט משתמש הוא מסוים
כמות התווים.

631
00:31:09,120 --> 00:31:13,310
לדוגמא, כאשר אתה עושה
המאית, שאמרו לך שדברים היו

632
00:31:13,310 --> 00:31:15,580
רק הולך להיות 40 תווים
לכל היותר ארוך.

633
00:31:15,580 --> 00:31:16,570
וזה היה טוב.

634
00:31:16,570 --> 00:31:20,150
>> אבל אם לא, אז אתה תצטרך
הקפד לקרוא רק ב45

635
00:31:20,150 --> 00:31:21,520
תווים בכל פעם.

636
00:31:21,520 --> 00:31:24,430
אחרת, אתה עלול לדרוס
החיץ שלך.

637
00:31:24,430 --> 00:31:26,140
כל שאלות על זה.

638
00:31:26,140 --> 00:31:26,733
כן.

639
00:31:26,733 --> 00:31:28,850
>> קהל: האם אתה יכול רק לדבר
קצת יותר על אלה?

640
00:31:28,850 --> 00:31:29,790
>> אנג'לה LI: מצטער.

641
00:31:29,790 --> 00:31:31,040
כן.

642
00:31:31,040 --> 00:31:32,813

643
00:31:32,813 --> 00:31:35,870
>> קהל: המיקרופון הוא רק לוידאו.

644
00:31:35,870 --> 00:31:37,640
אני אנסה ופרויקט.

645
00:31:37,640 --> 00:31:39,900
היי, חבר 'ה.

646
00:31:39,900 --> 00:31:40,920
Sup?

647
00:31:40,920 --> 00:31:45,330
אז בואו נעבור על כמה דברים ב
ספריית CS50, אתה שכבר משתמש

648
00:31:45,330 --> 00:31:49,072
כל הסמסטר, בעיקר
כדי לקבל קלט ממשתמש.

649
00:31:49,072 --> 00:31:53,140
כפי שאתה יודע, אתה כולל CS50
ספרייה על ידי פשוט עושה CS50.h, אשר

650
00:31:53,140 --> 00:31:55,660
מכיל את כל אבות הטיפוס של
פונקציות שאתה יכול להשתמש בו, כמו

651
00:31:55,660 --> 00:31:58,640
GetString וGetInt, ו
GetFloat, וכולי.

652
00:31:58,640 --> 00:32:02,870
ויש שורה אחת זה בCS50
ספרייה המגדירה מחרוזת, אשר

653
00:32:02,870 --> 00:32:05,380
אתם כולנו יודעים עד עכשיו
רק char *.

654
00:32:05,380 --> 00:32:07,900
>> אבל בואו להציץ
איך GetString עובד.

655
00:32:07,900 --> 00:32:10,010
זוהי גרסה מאוד מקוצרת.

656
00:32:10,010 --> 00:32:15,090
אתה יכול למשוך את הקבצים בספריית CS50
מ, אני חושב, manuals.CS50.net.

657
00:32:15,090 --> 00:32:16,750
ואתה יכול לקרוא דרך
התפקוד בפועל.

658
00:32:16,750 --> 00:32:19,330
אבל זה מכסה חלק
החלקים החשובים.

659
00:32:19,330 --> 00:32:23,870
אז יצרנו כמה חיץ
עם קצת יכולת.

660
00:32:23,870 --> 00:32:27,570
ומה שאנחנו עושים הוא שאנחנו מקבלים תו אחד
בכל פעם מn הסטנדרטי.

661
00:32:27,570 --> 00:32:30,910
זה מקום שבי תשומות המשתמשים
טקסט במסוף.

662
00:32:30,910 --> 00:32:33,430
>> וכך אנחנו הולכים לקרוא ב
כל עוד זה לא דמות חדשה

663
00:32:33,430 --> 00:32:37,220
קו וזה לא בסופו של קובץ, אשר
הסוף של קלט סטנדרטי.

664
00:32:37,220 --> 00:32:45,690
ועבור כל תו שאנו קוראים ב,
אם דמות שסופו של דבר הוספה

665
00:32:45,690 --> 00:32:50,120
למספר התווים שקראנו
ושבהוא יותר מהיכולת שלנו,

666
00:32:50,120 --> 00:32:53,490
אז מה שאנחנו עושים הוא שאנחנו פשוט לשנות את הגודל שלנו
חיץ, כך שזה זמן כפול.

667
00:32:53,490 --> 00:32:56,950
אז שוב, זה להגן מפני חיץ
התקפות על גדותיו, בגלל שאתה קורא ב

668
00:32:56,950 --> 00:32:58,315
אופי בכל פעם.

669
00:32:58,315 --> 00:33:02,290
ואם בכל נקודה שאתה קורא במדי
רבים, אתה פשוט להרחיב את המאגר שלך.

670
00:33:02,290 --> 00:33:03,330
אתה מכפיל אותו בשתיים.

671
00:33:03,330 --> 00:33:05,510
ואז יש לך יותר מקום.

672
00:33:05,510 --> 00:33:09,120
>> אחרת, אתה רק להוסיף
אופי לחיץ.

673
00:33:09,120 --> 00:33:15,080
ואחרי שקראתם בכל
תווים, היא תתכווץ החיץ

674
00:33:15,080 --> 00:33:18,510
בחזרה לגודל הנורמלי, להוסיף
שליחות קטלנית ריקה, ולאחר מכן לחזור.

675
00:33:18,510 --> 00:33:21,880

676
00:33:21,880 --> 00:33:24,960
עכשיו, בואו נסתכל על GetInt.

677
00:33:24,960 --> 00:33:27,700
אתם יכולים לקרוא את זה?

678
00:33:27,700 --> 00:33:30,710
אני יכול להתקרב קצת.

679
00:33:30,710 --> 00:33:33,410

680
00:33:33,410 --> 00:33:34,660
אני לא יודע איך מחשבים לעבוד.

681
00:33:34,660 --> 00:33:40,840

682
00:33:40,840 --> 00:33:41,270
אין דבר.

683
00:33:41,270 --> 00:33:42,520
אני לא יכול להגדיל את התצוגה כמו שצריך.

684
00:33:42,520 --> 00:33:47,500

685
00:33:47,500 --> 00:33:48,770
>> זה באמת קשה.

686
00:33:48,770 --> 00:33:49,180
אני מצטער.

687
00:33:49,180 --> 00:33:51,490
בואו רק נסתכל על זה.

688
00:33:51,490 --> 00:33:57,140
אז מה GetInt עושה זה קורא ראשון
במחרוזת מGetString, אשר

689
00:33:57,140 --> 00:33:59,250
אנחנו כבר יישמנו בעבר.

690
00:33:59,250 --> 00:34:02,945
והחלק החשוב לציין כאן
הוא אם שיתוף זה כי זה בסופו של

691
00:34:02,945 --> 00:34:06,400
קריאה היא כמו לא ממש מחרוזת,
אז אנחנו פשוט לחזור לINT_MAX

692
00:34:06,400 --> 00:34:09,409
מייצג כישלון.

693
00:34:09,409 --> 00:34:12,645
למה אנחנו חוזרים INT_MAX במקום
של 1 שלילי או 1?

694
00:34:12,645 --> 00:34:13,895
יש לך רעיונות?

695
00:34:13,895 --> 00:34:16,853

696
00:34:16,853 --> 00:34:19,350
>> קהל: [לא ברור]
שלילי 1 על אחד.

697
00:34:19,350 --> 00:34:20,070
>> אנג'לה LI: כן, בדיוק.

698
00:34:20,070 --> 00:34:24,560
אז אתה בדרך סביר יותר רק רוצה
לקלט 1 או 1 שלילי כאשר תתבקשו

699
00:34:24,560 --> 00:34:27,469
להמי יודע כמה ומה המי יודע כמה Maxes.

700
00:34:27,469 --> 00:34:27,969
זה ענק.

701
00:34:27,969 --> 00:34:29,690
אתה לא כנראה הולך להשתמש בו.

702
00:34:29,690 --> 00:34:32,690
אז זה כמו החלטת עיצוב
לוודא שאתה לא בטעות

703
00:34:32,690 --> 00:34:38,540
להחזיר שגיאה או שאתה לא חוזר
1, מה שעשוי להיות מנותח

704
00:34:38,540 --> 00:34:41,199
כמו תשובה נכונה.

705
00:34:41,199 --> 00:34:45,110
אז אם קו לא קיים,
אנחנו חוזרים INT-MAX.

706
00:34:45,110 --> 00:34:48,090
אחרת, אנו משתמשים sscanf,
שזה כמו scanf.

707
00:34:48,090 --> 00:34:49,449
אבל זה קורא ממחרוזת.

708
00:34:49,449 --> 00:34:54,310
>> ויש לנו את זה מעוצב
מחרוזת, המהווה%% i ג.

709
00:34:54,310 --> 00:34:57,440
ואנחנו מנסים ולהתאים את זה עם
כל מה שהמשתמש נתן לנו.

710
00:34:57,440 --> 00:35:01,420
אנחנו רוצים שמספר דברים מתאימים
להיות 1, מה שאומר שאנחנו רק

711
00:35:01,420 --> 00:35:04,940
באמת רוצה להתאים מספר שלם
מוקף אולי לבן

712
00:35:04,940 --> 00:35:06,840
חלל, ואולי לא.

713
00:35:06,840 --> 00:35:10,710
במקרה זה, אם אתה מכניס משהו
כמו הבר, הבר אינו תואם בכלל,

714
00:35:10,710 --> 00:35:14,400
משום ששם צריך להיות
שלם בהתחלה.

715
00:35:14,400 --> 00:35:17,060
אז sscan מעולם לא פנה 0.

716
00:35:17,060 --> 00:35:19,640
אז אתה לא מחזיר את זה.

717
00:35:19,640 --> 00:35:23,850
>> לחלופין, אם אתה מכניס משהו
כמו 1, 2, 3, A, B, C, שגפרורים

718
00:35:23,850 --> 00:35:27,180
שני המספרים השלמים, אלא גם
האופי אחריו.

719
00:35:27,180 --> 00:35:29,990
אז sscanf יחזיר 2, אשר
הוא גם לא אידיאלי.

720
00:35:29,990 --> 00:35:34,620
אתה לא רוצה 1, 2, 3,,
B, C להיות int בתוקף.

721
00:35:34,620 --> 00:35:36,990
אז זה גם לא עובד.

722
00:35:36,990 --> 00:35:38,530
אבל אומרים לך לשים במשהו כמו 50.

723
00:35:38,530 --> 00:35:42,460
שיתאים% i, מה שאומר
היא תקבל לקרוא לתוך n.

724
00:35:42,460 --> 00:35:44,790
ועכשיו, n יכיל המספר 50.

725
00:35:44,790 --> 00:35:46,110
ואז אתה יכול להחזיר אותו.

726
00:35:46,110 --> 00:35:49,270
>> אחרת, אתה מכה על נסה שנית.

727
00:35:49,270 --> 00:35:55,790
ואז זה פשוט הולך שוב עד
אתה מקבל קלט תקין מהמשתמש.

728
00:35:55,790 --> 00:35:56,891
כל שאלות על זה?

729
00:35:56,891 --> 00:36:02,182
>> קהל: אז אם היית להדפיס
את הערך של GetInt על [לא ברור]

730
00:36:02,182 --> 00:36:06,250
זה יהיה רק ​​המספר השלם והמקסימום?

731
00:36:06,250 --> 00:36:07,440
>> אנג'לה LI: כן.

732
00:36:07,440 --> 00:36:11,780
אז אם אתה משתמש GetInt, אתה צריך להניח
כי אתה לא רוצה מקסימום המי יודע כמה ל

733
00:36:11,780 --> 00:36:15,328
להיות קלט חוקי, בגלל שאתה הולך
להניח שזה היה רע.

734
00:36:15,328 --> 00:36:27,740
>> קהל: אם לא היה לנו char c ו
מישהו לשים 1, 2, 3, סם, היית עושה את זה

735
00:36:27,740 --> 00:36:29,430
עדיין עובד עבור 1, 2, 3?

736
00:36:29,430 --> 00:36:29,750
>> אנג'לה LI: אני חושב שזה יעבוד.

737
00:36:29,750 --> 00:36:33,340
אבל אתה לא רוצה 123Sam ל
להיות קלט חוקי על ידי משתמש.

738
00:36:33,340 --> 00:36:34,670
זה לא באמת int.

739
00:36:34,670 --> 00:36:36,840
אז זה לא נראה הוגן
כדי לנתח אותו כint.

740
00:36:36,840 --> 00:36:40,910

741
00:36:40,910 --> 00:36:42,160
על אישור.

742
00:36:42,160 --> 00:36:45,800
במקרה זה, בוא מהלך של
לאינטרנט.

743
00:36:45,800 --> 00:36:49,120
אז HTTP הוא לא שפה.

744
00:36:49,120 --> 00:36:56,060
HTTP הוא רק האוסף של תקנים ל
איך אתה שולח דברים מלקוחות,

745
00:36:56,060 --> 00:36:57,280
זה אתה, לשרתים.

746
00:36:57,280 --> 00:36:59,730
זה אנשים אחרים באינטרנט.

747
00:36:59,730 --> 00:37:02,900
>> אז עומד HTTP עבור Hypertext
העבר את הפרוטוקול.

748
00:37:02,900 --> 00:37:04,610
זה הלב והנשמה
של האינטרנט כולו.

749
00:37:04,610 --> 00:37:07,050
חלק היפרטקסט רק
מתייחס ל-HTML.

750
00:37:07,050 --> 00:37:10,690
ההעברה היא לקוחות כמו
תוכל לשלוח בקשות ל

751
00:37:10,690 --> 00:37:13,060
שרתים, אשר נותנים תשובות.

752
00:37:13,060 --> 00:37:16,380
והפרוטוקול הוא פשוט, איך לעשות
אתה מצפה שרת להתנהג?

753
00:37:16,380 --> 00:37:19,960
ואיך אתה אמור להתנהג
כזאת שאתה יכול לייעל את זה

754
00:37:19,960 --> 00:37:21,920
תהליך תקשורת?

755
00:37:21,920 --> 00:37:26,650
>> אז בקשות HTTP נראות הרבה כמו זה.

756
00:37:26,650 --> 00:37:28,070
מקבל הוא הסוג של בקשה.

757
00:37:28,070 --> 00:37:31,220
אתם ראיתם בקשות GET
ובקשות POST.

758
00:37:31,220 --> 00:37:36,690
כי דבר שני שיש, / לי, זה
רק URI או את כתובת האתר שבו אתה

759
00:37:36,690 --> 00:37:38,140
רוצה ללכת בתוך הפונדקאי.

760
00:37:38,140 --> 00:37:44,140
אז בקשה זו מבקשת
דף, כמו www.facebook.com /.

761
00:37:44,140 --> 00:37:45,300
וזה בקשת GET.

762
00:37:45,300 --> 00:37:51,020
ולאחר מכן HTTP/1.1 זה, זה פשוט
הגרסה של HTTP אתה משתמש.

763
00:37:51,020 --> 00:37:55,020
זה כמעט תמיד 1.1.

764
00:37:55,020 --> 00:37:56,880
>> ויש גם את חבורה
דברים אחרים יותר מדי.

765
00:37:56,880 --> 00:38:02,510
אתה ממש יכול לראות אלה אם אתה
לפתוח את הקונסולה שלך כשאתה

766
00:38:02,510 --> 00:38:03,770
גלישה באינטרנט.

767
00:38:03,770 --> 00:38:07,290
תגובות נראות משהו
יותר כמו זה.

768
00:38:07,290 --> 00:38:09,620
החלק העליון הוא, שוב,
סוג של HTTP אתה משתמש

769
00:38:09,620 --> 00:38:12,310
ואחריו קוד מצב.

770
00:38:12,310 --> 00:38:14,700
אז 200 אישור הוא הכל הסתדר.

771
00:38:14,700 --> 00:38:16,200
הנה התוכן שלך.

772
00:38:16,200 --> 00:38:17,390
התוכן שלך הולך אחריו.

773
00:38:17,390 --> 00:38:21,730
ואז הוא יגיד לך איזה סוג
של תוכן וגם דברים אחרים.

774
00:38:21,730 --> 00:38:24,620
>> קודי המצב, יש כמה
חשובים אלה שאתה צריך לדעת.

775
00:38:24,620 --> 00:38:26,460
200 אישור הוא כמו הזהב של כל דבר.

776
00:38:26,460 --> 00:38:28,490
הכל עובד.

777
00:38:28,490 --> 00:38:29,710
403 אסורים.

778
00:38:29,710 --> 00:38:32,910
זה בטח ראה אם ​​שכח
לchmod משהו כמו שצריך.

779
00:38:32,910 --> 00:38:34,510
זה אומר שאין לך
את ההרשאות המתאימות

780
00:38:34,510 --> 00:38:36,210
גישה שעל השרת.

781
00:38:36,210 --> 00:38:38,110
זה כמו, לא, אתה לא יכול לראות את זה.

782
00:38:38,110 --> 00:38:39,780
404 פירוש הדבר שאינו קיימים.

783
00:38:39,780 --> 00:38:40,400
לא נמצא.

784
00:38:40,400 --> 00:38:41,640
בטח כבר ראה את זה הרבה.

785
00:38:41,640 --> 00:38:45,510
>> 500 שגיאת שרת פנימית היא בדרך כלל
כמו משהו השתבש בצד

786
00:38:45,510 --> 00:38:46,460
של השרת.

787
00:38:46,460 --> 00:38:50,830
לכן, כאשר אתה מיישם pset7,
אם היה לך שגיאות PHP, אתה יכול

788
00:38:50,830 --> 00:38:53,890
בעצם לעבור לדף ותראה
כל מיני דברים שגיאת PHP.

789
00:38:53,890 --> 00:38:56,900
אבל זה בדרך כלל לא קורה,
כי אתרים לא באמת רוצים

790
00:38:56,900 --> 00:38:58,830
לך למה האתר שלהם נשבר.

791
00:38:58,830 --> 00:39:03,370
הם כנראה פשוט לחזור
500 שגיאת שרת פנימית.

792
00:39:03,370 --> 00:39:06,120
>> ואז יש 418 אני קומקום תה.

793
00:39:06,120 --> 00:39:07,910
יש סיפור שלם על
מדוע זה דבר.

794
00:39:07,910 --> 00:39:09,860
אבל אתה יכול לקרוא על זה
על הזמן שלך.

795
00:39:09,860 --> 00:39:11,450
יש חבורה שלמה
קודי מצב אחרים.

796
00:39:11,450 --> 00:39:12,700
אבל אלה הם אלה
אתה צריך לדעת.

797
00:39:12,700 --> 00:39:15,660

798
00:39:15,660 --> 00:39:18,610
אז בואו נדבר על ה-HTML.

799
00:39:18,610 --> 00:39:22,180
HTML, יש לזכור, אינו
שפת תכנות.

800
00:39:22,180 --> 00:39:23,510
זה שפת סימון.

801
00:39:23,510 --> 00:39:25,210
כלומר, זה מתאר את התוכן.

802
00:39:25,210 --> 00:39:30,440
זה אומר לך את מה שנראה מסמך HTML
כמו או לא מה שזה נראה

803
00:39:30,440 --> 00:39:32,230
אבל איך זה מובנה.

804
00:39:32,230 --> 00:39:36,110
>> אז זה מגדיר את מבנה ואת
סמנטיקה של דפי אינטרנט.

805
00:39:36,110 --> 00:39:37,830
זה כמו, זה פסק.

806
00:39:37,830 --> 00:39:40,060
זה ברשימה מסודרת.

807
00:39:40,060 --> 00:39:42,360
זה כמו קטע בדף שלי.

808
00:39:42,360 --> 00:39:43,260
הנה הכותרת.

809
00:39:43,260 --> 00:39:44,310
הוא עושה דברים כאלה.

810
00:39:44,310 --> 00:39:48,770
זה לא סגנון של כל זה, כי
זה מה שאתה עושה ב-CSS.

811
00:39:48,770 --> 00:39:50,270
וזה נראה כמו סדרה
תגים של מקוננים.

812
00:39:50,270 --> 00:39:54,720
אז להשתמש בדוגמה של ממש בסיסי
דף ה-HTML, יש לך DOCTYPE

813
00:39:54,720 --> 00:39:56,720
הכרזה שם למעלה.

814
00:39:56,720 --> 00:40:00,940
>> הצהרת DOCTYPE זה
אומר, אנחנו משתמשים HTML5.

815
00:40:00,940 --> 00:40:03,370
ואז יש לך את תג ה-HTML הגדול.

816
00:40:03,370 --> 00:40:05,230
הוא מכיל בראש ובגוף.

817
00:40:05,230 --> 00:40:06,970
בתוך הראש, יש לך את הכותרת.

818
00:40:06,970 --> 00:40:12,950
זה מה שהולך בכותרת
סרגל של הדפדפן שלך.

819
00:40:12,950 --> 00:40:15,810
יש לנו קישור תג שמקשר
בגיליון סגנונות חיצוני.

820
00:40:15,810 --> 00:40:19,880
ואז יש לנו תסריט שמושך
מJavaScript חיצוני גם כן.

821
00:40:19,880 --> 00:40:23,750
>> ואז בתוך הגוף שלנו הוא למעשה
מה מקבל המוצג בדף.

822
00:40:23,750 --> 00:40:28,210
יש לנו סעיף ולאחר מכן
תמונה בתוך פסקה זו.

823
00:40:28,210 --> 00:40:32,000
זה אחד הוא תמונה של גורי חתולים.

824
00:40:32,000 --> 00:40:35,840
שימו לב שהתמונה
תג סוגר את עצמו.

825
00:40:35,840 --> 00:40:41,760
אז במקום לפתוח עם תמונה
ולאחר מכן עושה עוד / תמונה, אתה

826
00:40:41,760 --> 00:40:47,500
רק צריך לוכסן הקטן הזה
כאן, מה שסוגר אותו.

827
00:40:47,500 --> 00:40:53,670
ותג התמונה יש גם מפתח זה
תכונת ערך שנקראת alt.

828
00:40:53,670 --> 00:40:56,970
זה הטקסט החלופי ש
קורה כאשר אתה מרחף מעליו.

829
00:40:56,970 --> 00:41:03,170
>> רוב האלמנטים של HTML כמה ערך מפתח
דברים שאתה יכול לתת לו, שונים

830
00:41:03,170 --> 00:41:04,420
התאמה אישית.

831
00:41:04,420 --> 00:41:06,230

832
00:41:06,230 --> 00:41:08,705
כן.

833
00:41:08,705 --> 00:41:09,955
>> קהל: [לא ברור].

834
00:41:09,955 --> 00:41:17,510

835
00:41:17,510 --> 00:41:19,680
>> אנג'לה LI: טוב, אז זה
תכונה של התג.

836
00:41:19,680 --> 00:41:25,320
אז אם אתה היה באמצעות jQuery, אתה יכול
לעשות image.getAttribute בחר.

837
00:41:25,320 --> 00:41:27,930
ואז אתה יכול לחפש את
לקבל את מאפיין alt.

838
00:41:27,930 --> 00:41:31,040
וזה ייתן לך גורים.

839
00:41:31,040 --> 00:41:37,400
אם אתה זוכר טפסים ב-HTML, קלט
אלמנטים יהיו שם תכונות.

840
00:41:37,400 --> 00:41:41,870
וזה מה שPHP משתמש לשלוח
בקשות כאשר טופס נשלח.

841
00:41:41,870 --> 00:41:44,762

842
00:41:44,762 --> 00:41:50,064
>> קהל: האם אתה מזכיר משהו
על איך אם אתה משתמש kittens.jpg או

843
00:41:50,064 --> 00:41:54,410
משהו שיש חסר
להגיש קבצים אחרים או תיקיות?

844
00:41:54,410 --> 00:41:54,750
>> אנג'לה LI: כן.

845
00:41:54,750 --> 00:41:57,010
אז זה מה שנקרא יחסי
נתיב, כי אני לא נותן

846
00:41:57,010 --> 00:41:58,740
שלך את הנתיב המלא.

847
00:41:58,740 --> 00:42:05,160
זה כמו כשבC אם אתה עושה fopen
כמה קובץ, אם אתה hi.txt fopen, כי

848
00:42:05,160 --> 00:42:09,190
hi.txt צפוי להיות באותה
ספרייה, אלא אם כן אתה נותן לו יותר

849
00:42:09,190 --> 00:42:11,530
דרך מורכבת.

850
00:42:11,530 --> 00:42:14,900
>> קהל: אז אתה יכול לציין
באיזו תיקייה [לא ברור]?

851
00:42:14,900 --> 00:42:17,660
>> אנג'לה LI: כן.

852
00:42:17,660 --> 00:42:19,370
ואתה יכול להסתכל למעלה איך לעשות את זה.

853
00:42:19,370 --> 00:42:23,480
אבל אם אני רוצה לקבל את kittens.jpg
של המדריך להורה, הייתי עושה

854
00:42:23,480 --> 00:42:24,730
.. / Kittens.jpg.

855
00:42:24,730 --> 00:42:29,680

856
00:42:29,680 --> 00:42:30,930
כן.

857
00:42:30,930 --> 00:42:32,960

858
00:42:32,960 --> 00:42:33,760
סליחה.

859
00:42:33,760 --> 00:42:34,045
כן.

860
00:42:34,045 --> 00:42:35,700
אה גבר, שכחתי את השאלה.

861
00:42:35,700 --> 00:42:36,460
מה הייתה השאלה?

862
00:42:36,460 --> 00:42:39,570
אה, השאלה הייתה הוא, kittens.jpg
צפוי להיות באותה הספרייה?

863
00:42:39,570 --> 00:42:40,630
ובמקרה הזה, זה הוא.

864
00:42:40,630 --> 00:42:44,030
אבל אתה גם יכול לתת לו בדרך מסוימת
כך שזה לא צריך להיות.

865
00:42:44,030 --> 00:42:47,100

866
00:42:47,100 --> 00:42:48,350
טוב?

867
00:42:48,350 --> 00:42:50,190

868
00:42:50,190 --> 00:42:51,350
>> ב-CSS.

869
00:42:51,350 --> 00:42:55,420
אז CSS, כמו HTML, אינו
שפת תכנות.

870
00:42:55,420 --> 00:42:58,250
CSS הוא רק סדרה של כללי הסטיילינג.

871
00:42:58,250 --> 00:43:00,130
מייצג גיליונות סגנון מדורג זה.

872
00:43:00,130 --> 00:43:03,910
ואתה משתמש בו בשיתוף
עם ה-HTML לדפי סגנון.

873
00:43:03,910 --> 00:43:08,140
אז יש שלוש דרכים
אתה יכול לכלול אותו.

874
00:43:08,140 --> 00:43:11,950
דרך אחת אתה יכול לעשות את זה היא בראש
חלק של ה-HTML שלך, אתה רק יכול

875
00:43:11,950 --> 00:43:15,410
לפתוח תג בסגנון ולאחר מכן מקל
כמה CSS שולט שם.

876
00:43:15,410 --> 00:43:16,759
זה די בסדר.

877
00:43:16,759 --> 00:43:17,228
כן.

878
00:43:17,228 --> 00:43:21,449
>> קהל: האם אתה יכול לשים אותם
תגי סגנון שביניהם, בואו

879
00:43:21,449 --> 00:43:22,860
למשל, גוף ו / גוף.

880
00:43:22,860 --> 00:43:27,400
ואז אתה יהיה סטיילינג
רק בגוף.

881
00:43:27,400 --> 00:43:28,840
>> אנג'לה LI: אתה יכול.

882
00:43:28,840 --> 00:43:29,590
זה יעבוד.

883
00:43:29,590 --> 00:43:33,990
אבל אתה לא צריך, כי הסטיילינג הוא
סוג של מטה שצריכה ללכת ב

884
00:43:33,990 --> 00:43:35,890
ראש המסמך.

885
00:43:35,890 --> 00:43:38,280
גוף באמת צריך להכיל רק
מה בעצם הולך

886
00:43:38,280 --> 00:43:39,420
להופיע בדף שלך.

887
00:43:39,420 --> 00:43:42,155
>> קהל: אז אתה הייתי שם בסגנון
בראש שלך לסגנון

888
00:43:42,155 --> 00:43:43,930
דף האינטרנט כולו, נכון?

889
00:43:43,930 --> 00:43:44,300
>> אנג'לה LI: כן.

890
00:43:44,300 --> 00:43:50,470
כדי לשים את הסגנון כאן, כללים אלה CSS
יחול על כל הדף המבוסס על

891
00:43:50,470 --> 00:43:52,100
הבוררים שלהם.

892
00:43:52,100 --> 00:43:57,090
לכן הדרך טובה יותר לעשות את זה היא במקום
שיש לו תג בסגנון בראש שלך,

893
00:43:57,090 --> 00:44:00,430
יש לך קישור זה לסגנון חיצוני
גיליון כמו שהראיתי לך ב

894
00:44:00,430 --> 00:44:01,980
דוגמא קודמת.

895
00:44:01,980 --> 00:44:05,920
מה שזה עושה הוא שהוא מנסה ומוצא
קובץ style.css ולאחר מכן מושך אותו

896
00:44:05,920 --> 00:44:08,470
ובמשתמש בזה כ
סגנונות עבור הדף.

897
00:44:08,470 --> 00:44:10,500
וstyle.css שלך היה
רק נראה ככה.

898
00:44:10,500 --> 00:44:13,330
זה יהיה חבורה של CSS פשוט.

899
00:44:13,330 --> 00:44:16,210
>> ולבסוף, יש דרך אחרת שאתה
יכול לכלול CSS, שבו אתה באמת

900
00:44:16,210 --> 00:44:17,480
לא צריך לעשות אי פעם.

901
00:44:17,480 --> 00:44:18,950
זה סגנון מוטבע שיחה.

902
00:44:18,950 --> 00:44:22,650
וכך כל אלמנט HTML יכול גם
לקחת תכונת סגנון.

903
00:44:22,650 --> 00:44:26,320
ולאחר מכן בכך שתכונת הסגנון,
אתה יכול לתת לו כללי ה-CSS.

904
00:44:26,320 --> 00:44:29,140
אז במקרה הזה, כל מה שאני div
הגדרה כאן, זה הולך

905
00:44:29,140 --> 00:44:32,580
יש להם רקע שחור ו
צבע טקסט לבן.

906
00:44:32,580 --> 00:44:35,620
אבל אתה לא צריך לעשות את זה, כי מה
המשמעות של זה הוא שזה מעמיד את הסטיילינג שלך

907
00:44:35,620 --> 00:44:36,850
בתוך ה-HTML שלך.

908
00:44:36,850 --> 00:44:40,530
>> ואני יודע שאנחנו כבר מדברים על HTML
הוא מבנה ו-CSS הוא סגנון.

909
00:44:40,530 --> 00:44:42,790
אם תעשה זאת, הוא מתערבב
אותם יחד.

910
00:44:42,790 --> 00:44:44,550
וזה לא מאוד נקי.

911
00:44:44,550 --> 00:44:45,800
אז אל תעשה את זה.

912
00:44:45,800 --> 00:44:47,690

913
00:44:47,690 --> 00:44:52,100
שימוש בדוגמה של CSS, שם למעלה, אנחנו
פשוט בחר את הגוף של ה-HTML

914
00:44:52,100 --> 00:44:52,380
סרט תיעודי.

915
00:44:52,380 --> 00:44:55,110
ואנחנו כמו, הכל
הולך להיות Sans קומיקס.

916
00:44:55,110 --> 00:44:57,290
אני גם לא ממליץ על זה.

917
00:44:57,290 --> 00:44:59,940
אבל אתה יכול לעשות את זה.

918
00:44:59,940 --> 00:45:03,140
>> הכלל השני כאן, זה הולך
כדי לבחור את האלמנט על

919
00:45:03,140 --> 00:45:04,880
דף עם עיקרי זהות.

920
00:45:04,880 --> 00:45:11,690
אז מה ה-HTML אלמנט, אמרתי זהות
= עיקרי, אני הולך לתת לי כי

921
00:45:11,690 --> 00:45:16,020
מרווח 20 פיקסל וליישר את הכל,
כל הטקסט, למרכז.

922
00:45:16,020 --> 00:45:19,030
הדבר האחרון שבוחר על פי מעמד CSS.

923
00:45:19,030 --> 00:45:24,450
אז כל אלמנט בעמוד שנתתי
כיתת קטע, אני הולך לעשות את זה

924
00:45:24,450 --> 00:45:26,602
צבע רקע של אור כחול.

925
00:45:26,602 --> 00:45:29,380

926
00:45:29,380 --> 00:45:30,040
כן.

927
00:45:30,040 --> 00:45:30,700
זה כל מה שיש לי.

928
00:45:30,700 --> 00:45:30,890
שאלה?

929
00:45:30,890 --> 00:45:34,020
>> קהל: מה עושה hashtag
לפני עיקרי לעשות?

930
00:45:34,020 --> 00:45:36,310
>> אנג'לה LI: השאלה היא, מה עושה
hashtag לפני המטלות עיקריות?

931
00:45:36,310 --> 00:45:40,770
במקרה זה, החשיש ב
CSS פירוש בחר לפי תעודת זהות.

932
00:45:40,770 --> 00:45:47,490
אז אם היה לי כמה רכיב HTML, כמו
= בוחר divid עיקרי, CSS זה כלל

933
00:45:47,490 --> 00:45:49,260
הדבר עיקרי בזהות.

934
00:45:49,260 --> 00:45:53,940
ובאופן דומה, בתקופה שלפני
סעיף הוא בחר על פי מעמד CSS או

935
00:45:53,940 --> 00:45:56,558
בחר על פי מעמד ה-HTML.

936
00:45:56,558 --> 00:46:00,940
>> קהל: מדוע יש לך עד היום
6 בצבע רקע?

937
00:46:00,940 --> 00:46:01,270
>> אנג'לה LI: כן.

938
00:46:01,270 --> 00:46:03,360
אז השאלה היא, מדוע יש
חשיש לפני 6?

939
00:46:03,360 --> 00:46:05,320
זה שונה מאשר חשיש ש.

940
00:46:05,320 --> 00:46:09,500
משמעות דבר היא כי אתה נותן
צבע הקסדצימלי.

941
00:46:09,500 --> 00:46:14,260
צבעים אז hex, זה פשוט
מייצג צבע.

942
00:46:14,260 --> 00:46:17,860
ואתה זוכר את משולשים RGB כאשר
עשית pset זיהוי פלילי?

943
00:46:17,860 --> 00:46:18,770
זה דומה.

944
00:46:18,770 --> 00:46:21,590
שתי הספרות הראשונות מייצגות
כמה אדום הוא בצבע.

945
00:46:21,590 --> 00:46:23,260
השניים מייצגים
כמה ירוק.

946
00:46:23,260 --> 00:46:25,450
והשלישי מייצג
כמה כחול.

947
00:46:25,450 --> 00:46:30,060
והחשיש הוא זה הולך
לייצג את צבע.

948
00:46:30,060 --> 00:46:35,660
>> אז כל דבר מ0, 0, 0, 0, 0, 0
עד F, F, F, F, F, F הוא תקף.

949
00:46:35,660 --> 00:46:39,550
זה קצת צבע שיכול חוקי
להיות מוצג על ידי הדפדפן שלך.

950
00:46:39,550 --> 00:46:39,790
שאלה?

951
00:46:39,790 --> 00:46:43,590
>> קהל: מה ההבדל בין
שימוש לפי תעודת זהות ועל ידי כיתה?

952
00:46:43,590 --> 00:46:46,470
>> אנג'לה LI: השאלה היא מה
ההבדל בין

953
00:46:46,470 --> 00:46:48,950
שימוש לפי תעודת זהות ומעמד?

954
00:46:48,950 --> 00:46:54,390
אתה יכול להיות רק מרכיב אחד ב
מסמך ה-HTML שיש לו זהות מסוימת.

955
00:46:54,390 --> 00:46:58,660
דבר אחד, כך שרק בדף שלי
מותר לי עיקרי זהות.

956
00:46:58,660 --> 00:47:02,580
אז אתה משתמש בו לכך הוא הכותרת.

957
00:47:02,580 --> 00:47:03,850
זה הניווט.

958
00:47:03,850 --> 00:47:05,230
זה תחתונה.

959
00:47:05,230 --> 00:47:09,070
חוגים שונים, כי אתה יכול
חלים שיעורים לכמה שיותר אלמנטים של HTML

960
00:47:09,070 --> 00:47:10,100
כמו שאתה רוצה.

961
00:47:10,100 --> 00:47:15,860
>> כך למשל, עשיתי את הקטע בכיתה,
בגלל שיש כנראה יותר מאחד

962
00:47:15,860 --> 00:47:17,540
סעיף בדף שלי.

963
00:47:17,540 --> 00:47:20,200
אתה פשוט אפשר לי רב
אלמנטים בעמוד עם אותו

964
00:47:20,200 --> 00:47:23,190
כיתה אבל רק אחד עם זהות מסוימת.

965
00:47:23,190 --> 00:47:25,600
>> קהל: אז הנקודה מייצגת
בכיתה?

966
00:47:25,600 --> 00:47:26,090
>> אנג'לה LI: כן.

967
00:47:26,090 --> 00:47:27,380
נקודה מייצגת כיתה.

968
00:47:27,380 --> 00:47:29,990

969
00:47:29,990 --> 00:47:31,540
מגניב.

970
00:47:31,540 --> 00:47:32,370
זה כל מה שיש לי, חבר 'ה.

971
00:47:32,370 --> 00:47:33,544
תודה.

972
00:47:33,544 --> 00:48:13,380
>> [מחיאות כפות]

973
00:48:13,380 --> 00:48:14,290
>> ZAMYLA צ'אן: היי, כולם.

974
00:48:14,290 --> 00:48:14,880
אני Zamyla.

975
00:48:14,880 --> 00:48:18,830
אני הולך להיות כיסוי PHP,
MVC, ו-SQL היום.

976
00:48:18,830 --> 00:48:22,350

977
00:48:22,350 --> 00:48:26,110
הרבה חומר שאני אהיה
כיסוי הולך להיות פחות או יותר

978
00:48:26,110 --> 00:48:29,100
היישר מpset7.

979
00:48:29,100 --> 00:48:29,700
בסדר.

980
00:48:29,700 --> 00:48:31,180
אז מה זה PHP?

981
00:48:31,180 --> 00:48:35,150
PHP הוא הקיצור של PHP Hypertext
Preprocessor.

982
00:48:35,150 --> 00:48:38,740
אז זה, בפני עצמו, הוא רקורסיבית
שם, וזה די מגניב.

983
00:48:38,740 --> 00:48:42,220
PHP היא שפת scripting בצד השרת,
והוא מספק את backend

984
00:48:42,220 --> 00:48:44,610
והיסודות הלוגיים
באתר שלנו.

985
00:48:44,610 --> 00:48:48,520
>> אז אנג'לה דיברה הרבה על ה-HTML
ו-CSS שיהפוך את המבנה

986
00:48:48,520 --> 00:48:49,530
של האתר.

987
00:48:49,530 --> 00:48:53,210
אבל מה אם אתה רוצה לשנות את זה
תוכן דינמי או אם זה משתנה

988
00:48:53,210 --> 00:48:55,240
המבוסס על המשתמש או
בתנאים מסוימים?

989
00:48:55,240 --> 00:48:57,060
זה מקום שבי PHP נכנס

990
00:48:57,060 --> 00:49:02,610
עכשיו, בדרך כלל, PHP עלול לקחת כמה
פחות קווים ליישם את אותו הדבר

991
00:49:02,610 --> 00:49:07,380
ב C. זה בגלל PHP מטפל בזיכרון
ניהול עבור המתכנת,

992
00:49:07,380 --> 00:49:11,170
בניגוד אלינו שיש לmalloc
ללא תשלום, כל מיני דברים כאלה.

993
00:49:11,170 --> 00:49:15,430
>> אבל מאז PHP היא פרשנית
שפה, בדרך כלל, זה יכול לבצע

994
00:49:15,430 --> 00:49:19,540
קצת לאט יותר מאשר C, ה
היא שפת הידור.

995
00:49:19,540 --> 00:49:23,150
מכיוון שאנחנו עוברים בתכנות
שפות, בואו נסתכל על איך

996
00:49:23,150 --> 00:49:24,570
תחביר יהיה שונה.

997
00:49:24,570 --> 00:49:28,770
בואו להיות זהיר מאוד שלא
להתבלבל עם זה.

998
00:49:28,770 --> 00:49:33,750
אז עם תחביר PHP, אם אתה
הטבעת PHP שלך בתוך ה-HTML

999
00:49:33,750 --> 00:49:40,430
קובץ או בתוך קובץ PHP. עצמו, אתה
צריך לתחום את הקוד בפתוח

1000
00:49:40,430 --> 00:49:45,270
PHP ואת תגי PHP הסגורים כמו
להלן, כמו על המסך.

1001
00:49:45,270 --> 00:49:46,660
>> משתנים ב-PHP.

1002
00:49:46,660 --> 00:49:51,490
כל משתנה אחד יתחיל עם
$ הסימן ואחריו את שמו של

1003
00:49:51,490 --> 00:49:53,150
המשתנה שלך.

1004
00:49:53,150 --> 00:49:56,530
עכשיו, משתנה ב-PHP מוקלדים באופן רופף,
מה שאומר שאתה לא צריך

1005
00:49:56,530 --> 00:50:00,030
כדי לציין מה סוג הנתונים
הוא כשאתה מצהיר על זה.

1006
00:50:00,030 --> 00:50:03,505
עם זאת, זה לא אומר שהם
אין לי שום סוגים בכלל.

1007
00:50:03,505 --> 00:50:09,370
אז אם אני מצהיר משתנה ופשוט להגדיר
זה שווה ל 1, ולאחר מכן אני מצהיר

1008
00:50:09,370 --> 00:50:15,140
משתנה אחר, להגדיר אותו שווה ל "1",
ואז עוד אחד 1.0, טוב,

1009
00:50:15,140 --> 00:50:19,410
תלוי בסוג של שוויון
מפעילים אני משתמש, אם אני רוצה להשוות

1010
00:50:19,410 --> 00:50:21,830
בכל הסוגים, ולאחר מכן
הם יהיו שווים.

1011
00:50:21,830 --> 00:50:25,570
אבל אם אני רוצה לוודא כי
סוגים שווים, PHP עדיין יכול לעשות

1012
00:50:25,570 --> 00:50:28,690
זאת, למרות שאנחנו לא מצביעים
איזה סוג זה הוא כאשר אנחנו

1013
00:50:28,690 --> 00:50:31,170
ראשון לעשות את הקובץ.

1014
00:50:31,170 --> 00:50:33,990
>> עכשיו, ב-PHP, למרות שאנחנו
מעבר מעל מתכנות

1015
00:50:33,990 --> 00:50:39,360
שפות מC, עדיין יש לנו שלנו
אמין אם מצב, בדיוק כמו זה.

1016
00:50:39,360 --> 00:50:43,270
עדיין יש לנו הלולאות בזמננו, רק
כמו זה, שבו אתה מכניס

1017
00:50:43,270 --> 00:50:47,300
מצב ולאחר מכן
גוף של הלולאה.

1018
00:50:47,300 --> 00:50:50,360
ולאחר מכן יש לנו גם שלנו ללולאה,
אשר בדרך כלל נראה כך.

1019
00:50:50,360 --> 00:50:55,330
אז אם אני רוצה לחזר על כל
תשע psets ולהגיש ולהתקשר

1020
00:50:55,330 --> 00:50:58,960
submitPset פונקציה, ואז אני יכול לעשות את זה
כאן, שאתם כולם

1021
00:50:58,960 --> 00:50:59,830
על ידי נקודה זו.

1022
00:50:59,830 --> 00:51:01,080
מזל טוב, דרך אגב.

1023
00:51:01,080 --> 00:51:04,560

1024
00:51:04,560 --> 00:51:07,550
>> למצלמה, אנשים
אמר, תודה לך.

1025
00:51:07,550 --> 00:51:11,220
עכשיו, אם אתה לא רוצה רק כדי להשתמש בזה
ללולאה, ואז PHP למעשה גם

1026
00:51:11,220 --> 00:51:13,580
יש דברים שנקראים לולאות foreach.

1027
00:51:13,580 --> 00:51:22,210
אז אם יש לי מערך של מספרים שלמים, 0
דרך 8, מאוחסן בpsets המערך,

1028
00:51:22,210 --> 00:51:27,290
אז יש לי יכולים לולאת foreach כי
סובב מעל כל מספר בpsets.

1029
00:51:27,290 --> 00:51:30,640
ואז אני יכול לקרוא את אותו
לתפקד שמונה פעמים,

1030
00:51:30,640 --> 00:51:31,910
בדיוק כמו שעשיתי בעבר.

1031
00:51:31,910 --> 00:51:36,480
אז זה עבור כל לולאה הוא נחמד, כי
אין לך אם אתה לא יודע

1032
00:51:36,480 --> 00:51:39,470
האורך של המערך המדויק שאתה
יש, ולאחר מכן באמצעות foreach לולאה זו

1033
00:51:39,470 --> 00:51:42,800
ידאג לזה בשבילך.

1034
00:51:42,800 --> 00:51:45,410
>> אז עשיתי psets כמערך.

1035
00:51:45,410 --> 00:51:46,700
בואו נסתכל על זה.

1036
00:51:46,700 --> 00:51:51,290
מערכים ב-PHP הם בדרך כלל זהים
אלה שהיו לנו ב-C, שבו

1037
00:51:51,290 --> 00:51:52,960
אתה יכול להצהיר על מערך.

1038
00:51:52,960 --> 00:51:59,200
וכאן, אני יכול להצהיר על מערך ריק
ולאחר מכן לבנות באופן דינמי באמצעות

1039
00:51:59,200 --> 00:52:00,850
מדדים כמספרים שלמים.

1040
00:52:00,850 --> 00:52:04,140
אז מדד 0, אני הולך לחנות
שלם בשם 1.

1041
00:52:04,140 --> 00:52:09,210
במדד 1 מתוך הרשימה שלי, אני הולך
כדי לאחסן את הערך 2.

1042
00:52:09,210 --> 00:52:12,670
ובמדד אך השלישי
מספר שני, אני הולך

1043
00:52:12,670 --> 00:52:14,870
לאחסן את המספר 12.

1044
00:52:14,870 --> 00:52:17,250
>> עכשיו, זה בסדר גמור שב
עובד זה עובד טוב.

1045
00:52:17,250 --> 00:52:21,310
אבל אומר שזה חשוב לי
מה כל מדד מחזיק.

1046
00:52:21,310 --> 00:52:24,500
בשבילי, מדד 0 פירושו איך
חתולים רבים שיש לי.

1047
00:52:24,500 --> 00:52:27,400
ומדד 1 פירושו איך
ינשופים רבים שיש לי.

1048
00:52:27,400 --> 00:52:29,450
והבא אומר כלבים כמה.

1049
00:52:29,450 --> 00:52:34,140
טוב, אז זה כדי לציין שבמקום
יש לזכור 0 מתייחסים ל

1050
00:52:34,140 --> 00:52:38,090
חתולים ו1 לינשופים, אני יכולים להשתמש
מערכים אסוציאטיביים, כלומר

1051
00:52:38,090 --> 00:52:42,260
במקום מספרים שלמים כמדדים שלי,
אני ממש יכול להשתמש במחרוזות.

1052
00:52:42,260 --> 00:52:43,290
>> אז זה די שימושי.

1053
00:52:43,290 --> 00:52:47,130
ויש לך בעצם רק החליף
המספרים השלמים עם מחרוזות.

1054
00:52:47,130 --> 00:52:50,074
ויש לך את
מערך אסוציאטיבי.

1055
00:52:50,074 --> 00:52:51,930
כן.

1056
00:52:51,930 --> 00:52:55,800
>> קהל: האם יש סיבה לכך שיש
קו תחתון לשני

1057
00:52:55,800 --> 00:52:58,750
חלק, משום שהרשימה שלי יש לו את המערך.

1058
00:52:58,750 --> 00:53:01,330
>> ZAMYLA צ'אן: השאלה הייתה, הוא
יש סיבה לכך שיש

1059
00:53:01,330 --> 00:53:03,320
מדגיש בין והרשימה שלי?

1060
00:53:03,320 --> 00:53:03,610
לא.

1061
00:53:03,610 --> 00:53:06,878
זה בדיוק איך אני מגדיר את
משתנה.

1062
00:53:06,878 --> 00:53:11,670
>> קהל: ביום הראשון
קו, שזה מילה אחת.

1063
00:53:11,670 --> 00:53:12,560
>> ZAMYLA צ'אן: אני מתנצל.

1064
00:53:12,560 --> 00:53:13,410
אני אסדר את זה.

1065
00:53:13,410 --> 00:53:13,620
כן.

1066
00:53:13,620 --> 00:53:15,460
הם צריכים להיות באותו השם משתנה.

1067
00:53:15,460 --> 00:53:16,710
לתפוס טוב.

1068
00:53:16,710 --> 00:53:19,640

1069
00:53:19,640 --> 00:53:19,950
על אישור.

1070
00:53:19,950 --> 00:53:22,610
אז בואו נעבור למחרוזת
שרשור.

1071
00:53:22,610 --> 00:53:27,500
אם אני רוצה לקחת את שתי מחרוזות,
אז אני יכול לשרשר אותם

1072
00:53:27,500 --> 00:53:28,550
עם מפעיל הנקודה.

1073
00:53:28,550 --> 00:53:32,440
אז אם יש לי מילוא כהשם פרטי
ובננה כמו שם משפחה, ולאחר מכן

1074
00:53:32,440 --> 00:53:35,430
שרשור עם המפעיל והנקודה
לאחר מכן לשים את החלל שביניהם

1075
00:53:35,430 --> 00:53:39,210
יהפוך את מחרוזת המכילה מילוא
בננה, אשר אז יכול להדהד או,

1076
00:53:39,210 --> 00:53:41,280
ולא, להדפיס.

1077
00:53:41,280 --> 00:53:44,465
>> אם כבר מדברים על הד, בואו נדבר
על כמה שימושי -

1078
00:53:44,465 --> 00:53:44,920
אופס.

1079
00:53:44,920 --> 00:53:46,030
אני מצטער.

1080
00:53:46,030 --> 00:53:52,920
כמה פונקציות PHP שימושיות.

1081
00:53:52,920 --> 00:53:56,240
אז יש לנו -

1082
00:53:56,240 --> 00:53:57,444
קשיים טכניים.

1083
00:53:57,444 --> 00:53:58,694
שנייה אחת.

1084
00:53:58,694 --> 00:54:16,960

1085
00:54:16,960 --> 00:54:19,550
אני שלחתי אותו.

1086
00:54:19,550 --> 00:54:22,320
בעיות ב-PowerPoint.

1087
00:54:22,320 --> 00:54:29,200
ואנחנו שוב עם פונקציות PHP.

1088
00:54:29,200 --> 00:54:32,010

1089
00:54:32,010 --> 00:54:35,150
ואנחנו שוב עם פונקציות PHP.

1090
00:54:35,150 --> 00:54:39,890
>> אז יש לנו דורשים פונקציה, שבו
אם אתה עובר בקובץ, הנה הוא רק

1091
00:54:39,890 --> 00:54:43,300
דוגמא של קובץ ש
אני עלול לעבור פנימה

1092
00:54:43,300 --> 00:54:47,605
ואז שיכלול את קוד PHP
מאותו הקובץ שאני מצביע.

1093
00:54:47,605 --> 00:54:49,940
וזה יהיה להעריך שבי

1094
00:54:49,940 --> 00:54:54,450
ואז יש לנו גם הד, אשר
הוא מקביל לprintf.

1095
00:54:54,450 --> 00:54:57,710
יציאה היא במקביל להפסקה,
שיוצא מהבלוק של

1096
00:54:57,710 --> 00:54:58,570
קוד שאתה נמצא בו

1097
00:54:58,570 --> 00:55:03,180
ולאחר מכן בדיקות ריקות אם ניתנו
משתנה הוא כמו ריק או אפס או

1098
00:55:03,180 --> 00:55:08,482
כל מה שהשווה עם להיות ריק.

1099
00:55:08,482 --> 00:55:09,438
כן.

1100
00:55:09,438 --> 00:55:15,341
>> קהל: לשרשור המחרוזת
מפעיל נקודה אחת, ב-PHP, הוא כי

1101
00:55:15,341 --> 00:55:20,158
אותו דבר כמו ב-JavaScript שבו הוא משתמש
הנקודה לשרשור פירושו תוספת?

1102
00:55:20,158 --> 00:55:27,440
אז לשם מלאים, יכול להיות לך דולר
סימן + ראשון ולאחר מכן + מעמד?

1103
00:55:27,440 --> 00:55:27,720
>> ZAMYLA צ'אן: כן.

1104
00:55:27,720 --> 00:55:32,150
אז השאלה הייתה האם ב-PHP אנחנו
ניתן להשתמש באותו שרשור המחרוזת

1105
00:55:32,150 --> 00:55:33,890
כמו בJavaScript עם הפלוסים.

1106
00:55:33,890 --> 00:55:35,410
ויוסף יקבל את זה מאוחר יותר.

1107
00:55:35,410 --> 00:55:36,620
אני חושב שיש לו להחליק על זה.

1108
00:55:36,620 --> 00:55:37,570
למעשה, זה שונה.

1109
00:55:37,570 --> 00:55:41,310
אז ב-JavaScript, אתה צריך להשתמש
בתוספת לשרשור מחרוזות.

1110
00:55:41,310 --> 00:55:43,280
וב-PHP, שיש לך
השתמש באופרטור הנקודה.

1111
00:55:43,280 --> 00:55:44,530
אז הם שונים.

1112
00:55:44,530 --> 00:55:46,680

1113
00:55:46,680 --> 00:55:46,910
>> על אישור.

1114
00:55:46,910 --> 00:55:49,500
אז עכשיו שאנחנו כבר כיסינו את כל
PHP זה, שבו עושה את זה

1115
00:55:49,500 --> 00:55:50,490
באמת שימושי?

1116
00:55:50,490 --> 00:55:54,470
ובכן, מדובר בהישג יד כאשר אנו
ניתן לשלב את זה עם ה-HTML שלנו.

1117
00:55:54,470 --> 00:55:59,550
אז PHP שלנו ייתן לנו את הכוח
לשנות את תוכן ה-HTML של דף לפני

1118
00:55:59,550 --> 00:56:00,000
הטעינה שלה.

1119
00:56:00,000 --> 00:56:04,270
כך שבהתבסס על תנאים שונים,
בדרך כלל המשתמש הספציפי זה

1120
00:56:04,270 --> 00:56:07,520
מחובר, אנחנו יכולים להציג
מידע שונה.

1121
00:56:07,520 --> 00:56:08,800
לינדה, האם יש לך שאלה?

1122
00:56:08,800 --> 00:56:15,510
>> קהל: אתה יכול לשרשר
שלם גם?

1123
00:56:15,510 --> 00:56:16,760
>> ZAMYLA צ'אן: כן, אתה יכול.

1124
00:56:16,760 --> 00:56:19,530

1125
00:56:19,530 --> 00:56:23,270
אז השאלה הייתה אם אתה יכול
לשרשר מספרים שלמים או אחרים

1126
00:56:23,270 --> 00:56:28,920
variable.s עכשיו, אנחנו עוברים לMVC, אשר
היא הפרדיגמה שהשתמשנו ב

1127
00:56:28,920 --> 00:56:33,380
pset7 והרבה מעצבי אינטרנט להשתמש עבור
ארגון הקוד בקבצים

1128
00:56:33,380 --> 00:56:34,490
באתר האינטרנט שלהם.

1129
00:56:34,490 --> 00:56:35,870
M עומד על דגם.

1130
00:56:35,870 --> 00:56:41,450
ובעצם, קבצי מודל יעסקו
עם אינטראקציות עם מסד הנתונים.

1131
00:56:41,450 --> 00:56:44,640
הצג את הקבצים, הם מתייחסים ל
אסתטיקה של האתר.

1132
00:56:44,640 --> 00:56:47,550
וידיות בקר
בקשות משתמשים, מנתח

1133
00:56:47,550 --> 00:56:49,230
הנתונים, עושה היגיון אחר.

1134
00:56:49,230 --> 00:56:52,520
>> בpset7, אנחנו בשילוב המודל
והבקר.

1135
00:56:52,520 --> 00:56:55,880
ואנחנו רק קראנו להם בקרים ו
לשים אותם בספרייה הציבורית.

1136
00:56:55,880 --> 00:57:01,730
וקבצי התצוגה, אנחנו משתמשים בם כ
תבניות בספריית התבניות.

1137
00:57:01,730 --> 00:57:07,260
אז תרשים זה כאן גם מייצג
שאותו סוג של חלוקה עם

1138
00:57:07,260 --> 00:57:10,510
מודל ואת הבקר בצבע סגול
כאן בצד השמאל ו

1139
00:57:10,510 --> 00:57:12,770
התצוגה בצד הימין.

1140
00:57:12,770 --> 00:57:16,020
אז זה סכמטית שכמה מכם
יכול להיות שראה בשעות או Office

1141
00:57:16,020 --> 00:57:19,130
דיאגרמות שאנחנו ציור כמו שאתה
ניסיתי להבין pset שלך.

1142
00:57:19,130 --> 00:57:25,030
>> אז הנה, בבקר נתון, מודל
בקר, יש לנו פונקציות

1143
00:57:25,030 --> 00:57:30,490
הנוגעים לביצוע שאילתות SQL
מסד הנתונים, ביצוע היגיון PHP.

1144
00:57:30,490 --> 00:57:32,370
אולי היית מסתכל למעלה
מניות ב-Yahoo!

1145
00:57:32,370 --> 00:57:34,590
האוצר.

1146
00:57:34,590 --> 00:57:37,390
או אולי, היית לבדוק רק כדי
לראות אם משתמש שהגיש

1147
00:57:37,390 --> 00:57:40,250
יוצר כבר לפני שיש
ביקר בדף שלך.

1148
00:57:40,250 --> 00:57:43,390
ואז אתה תהפוך
יוצר כאן.

1149
00:57:43,390 --> 00:57:48,210
אחרי הטופס שהוגש
על ידי המשתמש, הפעולה שהייתה

1150
00:57:48,210 --> 00:57:53,470
צוין בתג ה-HTML של הטופס
מצביע על כך שהדף שהוא היה

1151
00:57:53,470 --> 00:57:55,620
מחזיר את הנתונים ל.

1152
00:57:55,620 --> 00:57:59,460
>> אז כל מידע שיהיה
נשלח בחזרה לבקר שלך.

1153
00:57:59,460 --> 00:58:02,620
אז אתה כנראה הייתי עושה קצת יותר
היגיון ושבאולי לבצע כמה

1154
00:58:02,620 --> 00:58:06,510
יותר שאילתות בבסיס נתוני SQL ו
אז, סוף סוף, לבוא עם יפה

1155
00:58:06,510 --> 00:58:11,930
סט ארוז של מידע שהיית
לעבור בלתוך תבנית כלשהי אחרת

1156
00:58:11,930 --> 00:58:13,950
שמוצג במידע זה.

1157
00:58:13,950 --> 00:58:17,030
עכשיו, איך שאנחנו באמת לארוז
כי מידע למעלה?

1158
00:58:17,030 --> 00:58:23,980
ובכן, יש לנו פונקציה שנקראת לדקלם
זה היה בקובץ functions.php ב

1159
00:58:23,980 --> 00:58:29,950
pset7, שבו אתה עובר בשם
קובץ, את השם של תבנית.

1160
00:58:29,950 --> 00:58:32,160
>> ואז אתה גם עובר ב
מערך אסוציאטיבי.

1161
00:58:32,160 --> 00:58:37,150
וכדי שהמערך אסוציאטיבי מייצג
המידע שונה

1162
00:58:37,150 --> 00:58:39,040
כי אתה רוצה להעביר פנימה

1163
00:58:39,040 --> 00:58:43,460
עכשיו, מה הולך להיות קבוע ב
דוגמאות אלה היא כי המפתחות או,

1164
00:58:43,460 --> 00:58:47,070
ליתר דיוק, את המפתחות של אסוציאטיבי
מערכים, אלה הם מה הולך להיות

1165
00:58:47,070 --> 00:58:51,050
צפוי להיות קבוע על ידי התבנית,
משום שהוא יודע שהוא צריך

1166
00:58:51,050 --> 00:58:53,990
משהו שנקרא הודעה
או קרא בשמה.

1167
00:58:53,990 --> 00:58:56,940
ואז הדברים בצד הימין,
ערכים בפועל, ולכן במקרה זה, מי

1168
00:58:56,940 --> 00:59:00,750
ילד טוב ומילוא, אלה הולכים
להיות הערכים שמשתנים

1169
00:59:00,750 --> 00:59:05,610
כי הבקר משתנה בכל פעם
או על בסיס מצב מסוים ו

1170
00:59:05,610 --> 00:59:07,120
יעבור שבו

1171
00:59:07,120 --> 00:59:12,790
>> אז הנה בתבניות, אנו רואים שאנו
משתמשים בתווים מיוחדים של HTML,

1172
00:59:12,790 --> 00:59:16,370
אשר רק בעצם אומר שאנחנו רוצים
כדי לקבל את מחרוזת שהעמיתים

1173
00:59:16,370 --> 00:59:17,580
משתמשים מכניסים פנימה

1174
00:59:17,580 --> 00:59:20,880
ואנחנו רוצים להחליף
הודעה לשם.

1175
00:59:20,880 --> 00:59:26,110
אז כאשר אנו למעשה להציג
את הקובץ, ספציפי

1176
00:59:26,110 --> 00:59:28,700
מידע מועבר פנימה

1177
00:59:28,700 --> 00:59:33,850
שים לב שהמפתח כיצד לעבד יצירות הוא
שהמפתחות של אסוציאטיבי

1178
00:59:33,850 --> 00:59:37,170
מערכים, משתנה להיות אלה
שמות כאן.

1179
00:59:37,170 --> 00:59:40,720
וכן הערכים של מפתח שב
מערך אסוציאטיבי ואז הופך

1180
00:59:40,720 --> 00:59:41,970
ערך של המשתנה.

1181
00:59:41,970 --> 00:59:44,800

1182
00:59:44,800 --> 00:59:46,040
>> עכשיו, בואו נעבור לSQL.

1183
00:59:46,040 --> 00:59:48,010
זה עומד על מובנה
שפת שאילתות.

1184
00:59:48,010 --> 00:59:50,460
ואז זה רק תכנות
שפה נועדה

1185
00:59:50,460 --> 00:59:51,880
לניהול מסדי נתונים.

1186
00:59:51,880 --> 00:59:56,860
וזה הגיע שימושי עבורנו ב
אתר הפיננסים pset7 שלנו.

1187
00:59:56,860 --> 01:00:00,510
בעיקרו של דבר, זה פשוט דרך קלה
לעקוב ולנהל את אובייקטים ושולחנות

1188
01:00:00,510 --> 01:00:02,070
ולקשר אותם זה לזה.

1189
01:00:02,070 --> 01:00:06,860
עכשיו, לחשוב על מסד הנתונים SQL שלך
בעצם כקובץ Excel, אולי,

1190
01:00:06,860 --> 01:00:10,040
עם סדינים עם לשוניות מרובים.

1191
01:00:10,040 --> 01:00:13,820
>> אז אתה יכול להיות מספר רב של שולחנות,
אולי, שמקושר אחד לשני.

1192
01:00:13,820 --> 01:00:19,420
ועוד הרבה כמו Excel, יש לנו הרבה
פונקציונלי שאנחנו רוצים.

1193
01:00:19,420 --> 01:00:22,300
לדוגמא, אנחנו יכולים לבחור
שורות מסוימות.

1194
01:00:22,300 --> 01:00:24,110
אנחנו יכולים להוסיף מידע.

1195
01:00:24,110 --> 01:00:25,560
אנחנו יכולים לעדכן את השורות.

1196
01:00:25,560 --> 01:00:27,440
ואנחנו גם יכולים למחוק את הדברים.

1197
01:00:27,440 --> 01:00:30,920

1198
01:00:30,920 --> 01:00:36,560
>> SQL לבחור יצירות על ידי בחירת שורות
או שורת עמודים שצוינו

1199
01:00:36,560 --> 01:00:39,640
מסד הנתונים תואמים מסוים
קריטריונים שאתה מציין.

1200
01:00:39,640 --> 01:00:44,930
אז לכאן כשאני רואה בחר * מ
קוסמים שבו בית = רייבנקלו, ולאחר מכן

1201
01:00:44,930 --> 01:00:48,340
אני בחירה *, מה שאומר שאני
בחירה כל עמודה שב

1202
01:00:48,340 --> 01:00:56,340
שורה משולחן הקוסמים אבל רק אם
טור הבית שווה רייבנקלו.

1203
01:00:56,340 --> 01:00:57,840
עכשיו, זה טהור או SQL.

1204
01:00:57,840 --> 01:01:02,680
אז אם אני נכנסתי לphpMyAdmin, שהוא
דרך מסוימת שאנו משתמשים כדי לנהל

1205
01:01:02,680 --> 01:01:07,040
מסדי נתונים של SQL שלנו, אז אני יכול להכניס
כי לאתר האינטרנט של phpMyAdmin.

1206
01:01:07,040 --> 01:01:08,290
וזה יהיה ביצוע.

1207
01:01:08,290 --> 01:01:11,280
>> אבל אנחנו באמת רוצים לעשות
כי בצד ה-PHP.

1208
01:01:11,280 --> 01:01:12,580
אז איך אנחנו עושים את זה?

1209
01:01:12,580 --> 01:01:20,180
ובכן, אנו משתמשים בפונקצית השאילתה, אשר
בעצם מבצעת ששאילתא SQL.

1210
01:01:20,180 --> 01:01:21,830
משתמש?

1211
01:01:21,830 --> 01:01:25,850
כמציין מיקום, אנחנו יכולים לעבור במסוימים
ערכים למחרוזת שלנו שאנחנו

1212
01:01:25,850 --> 01:01:26,920
רוצה להחליף.

1213
01:01:26,920 --> 01:01:32,110
אז אולי אני אחסון שונה
ערכים בcurr_house, אשר

1214
01:01:32,110 --> 01:01:34,400
מייצג את הבית הנוכחי
שאני עובר.

1215
01:01:34,400 --> 01:01:39,040
אז אני יכול להעביר שכבמציין מיקום
עם סימן השאלה.

1216
01:01:39,040 --> 01:01:43,290
ואז אני בעצם לבצע את
אותו דבר כמו שעשיתי בעבר, למעט

1217
01:01:43,290 --> 01:01:45,550
עכשיו, אני ב-PHP.

1218
01:01:45,550 --> 01:01:51,300
>> ושאילתא תחזיר
מערך אסוציאטיבי.

1219
01:01:51,300 --> 01:01:53,470
ואני הולך לאחסן אותו בשורות.

1220
01:01:53,470 --> 01:01:56,880
עכשיו, שאילתה תמיד יכולה להיכשל.

1221
01:01:56,880 --> 01:02:02,870
אולי שאילתת SQL לא יוכל לבצע
כי השולחן לא היה קיים.

1222
01:02:02,870 --> 01:02:04,310
או אולי, הטור לא היה קיים.

1223
01:02:04,310 --> 01:02:05,400
משהו השתבש.

1224
01:02:05,400 --> 01:02:08,170
ובכן, במקרה זה, אתה רוצה לעשות
בטוח שאתה לבדוק אם

1225
01:02:08,170 --> 01:02:09,700
השאילתה חזרו שווא.

1226
01:02:09,700 --> 01:02:15,590
וזה על ידי שימוש במשולש
שווה פעולה שם.

1227
01:02:15,590 --> 01:02:19,660
>> ואז אני מתנצל, וזה עוד
פונקצית CS50, עוברת בהודעה.

1228
01:02:19,660 --> 01:02:23,435
ואם אתה מסתכל לתוך להתנצל, כל זה
באמת עושה הוא לדקלם apology.php.

1229
01:02:23,435 --> 01:02:26,100

1230
01:02:26,100 --> 01:02:26,410
כן.

1231
01:02:26,410 --> 01:02:29,630
>> קהל: האם אתה יכול להסביר מה זה
כוכב עושה בין נבחרים ומ?

1232
01:02:29,630 --> 01:02:30,710
>> ZAMYLA צ'אן: כן, בהחלט.

1233
01:02:30,710 --> 01:02:35,220
אז את הכוכב שבבין נבחרת ומן
פירוש הדבר כי אני רוצה לבחור את כל

1234
01:02:35,220 --> 01:02:37,440
שורה שלמה מהשולחן שלי.

1235
01:02:37,440 --> 01:02:41,900
אני יכול כבר צוין בחר
שם, שנה, בית.

1236
01:02:41,900 --> 01:02:46,160
ואני אקבל את שלושה אלה בלבד
עמודות בטבלה שלי.

1237
01:02:46,160 --> 01:02:51,560
אבל אם אני אומר * בחר, אז אני
לקבל הכל באותה עמודה.

1238
01:02:51,560 --> 01:02:53,760
ואז אני הולך ללכת לך
בחלק האחורי הראשון.

1239
01:02:53,760 --> 01:02:57,656
>> קהל: אז זה עדיין
ב-SQL, נכון?

1240
01:02:57,656 --> 01:02:59,610
האם שאילתה זו או זה PHP זה?

1241
01:02:59,610 --> 01:03:00,550
>> ZAMYLA צ'אן: אנחנו בשאילתא.

1242
01:03:00,550 --> 01:03:01,940
אז זה ב-PHP.

1243
01:03:01,940 --> 01:03:06,280
זאת באמצעות שאילתת פונקצית PHP,
אנחנו ביצוע שאילתת SQL.

1244
01:03:06,280 --> 01:03:11,988

1245
01:03:11,988 --> 01:03:15,364
>> קהל: האם כל דבר ב-SQL
מקרה רגיש, כמו לבחור

1246
01:03:15,364 --> 01:03:17,834
או קוסמים או בבית?

1247
01:03:17,834 --> 01:03:20,050
>> ZAMYLA צ'אן: האם כל דבר
ב-SQL מקרה רגיש?

1248
01:03:20,050 --> 01:03:21,760
אני מאמין שכן, כן.

1249
01:03:21,760 --> 01:03:24,620
אני מאמין כי כך בחר מ
ואיפה הם תלויים רישיות.

1250
01:03:24,620 --> 01:03:25,535
לא?

1251
01:03:25,535 --> 01:03:27,500
>> ROB אודן: אז, זה הפוך.

1252
01:03:27,500 --> 01:03:32,030
שמות העמודות ואמצעי השולחן,
כל אלה הם תלויים רישיות.

1253
01:03:32,030 --> 01:03:35,470
אבל כל אחת ממילות המפתח של MySQL, כמו
לבחור,, והיכן, אלה הם לא

1254
01:03:35,470 --> 01:03:36,140
מקרה רגיש.

1255
01:03:36,140 --> 01:03:36,420
על אישור.

1256
01:03:36,420 --> 01:03:37,780
אז ההפך ממה שאמרתי.

1257
01:03:37,780 --> 01:03:40,420
אז את כל מילות המפתח MySQL -

1258
01:03:40,420 --> 01:03:42,670
בחר, מ, שבו - אלו
אינם תלוי רישיות.

1259
01:03:42,670 --> 01:03:44,630
אבל כל דבר אחר הוא.

1260
01:03:44,630 --> 01:03:45,210
על אישור.

1261
01:03:45,210 --> 01:03:46,500
אתה בחלק הקדמי.

1262
01:03:46,500 --> 01:03:52,041
>> קהל: אם יש לי $ שורות במונחים של
יותר משורה אחת, האם זה אומר שהיא

1263
01:03:52,041 --> 01:03:53,640
פשוט הופך להיות מערך אסוציאטיבי?

1264
01:03:53,640 --> 01:03:59,550
>> ZAMYLA צ'אן: אז השאלה הייתה אם שורות
יש יותר משורה אחת בו, אין

1265
01:03:59,550 --> 01:04:01,800
זה הפך למערך אסוציאטיבי?

1266
01:04:01,800 --> 01:04:05,680
אז זה הוא מערך של אסוציאטיבי
מערכים כבר.

1267
01:04:05,680 --> 01:04:10,730
אז גם אם יש רק שורה אחת
חזרתי, אז היית צריך ללכת ל

1268
01:04:10,730 --> 01:04:12,690
מדד 0 של התוצאה.

1269
01:04:12,690 --> 01:04:15,316
ואז היית צריך שהשורה ראשונה.

1270
01:04:15,316 --> 01:04:17,482
כן, בלינדה?

1271
01:04:17,482 --> 01:04:21,258
>> קהל: כשאתה משתמש ב===,
זה המקרה היחיד?

1272
01:04:21,258 --> 01:04:22,210
או שיש לאחרים?

1273
01:04:22,210 --> 01:04:26,815
>> ZAMYLA צ'אן: אז במקרה הזה, ===
הוא השוואה בין סוגים.

1274
01:04:26,815 --> 01:04:29,870

1275
01:04:29,870 --> 01:04:34,050
סליחה. === היא השוואה
שמשווה את הסוגים.

1276
01:04:34,050 --> 01:04:37,620
ולאחר מכן == משווה בין כל הסוגים.

1277
01:04:37,620 --> 01:04:41,620
>> קהל: אתה יכול להסביר מה
שורות היא במצב הזה?

1278
01:04:41,620 --> 01:04:45,120
האם זה בשורה של נתונים?

1279
01:04:45,120 --> 01:04:48,100
>> ZAMYLA צ'אן: בשקופית הבאה, אני
הולך להסביר מה הוא שורות.

1280
01:04:48,100 --> 01:04:49,890
אז אם לא אכפת לך מחזיק
הנחה על זה.

1281
01:04:49,890 --> 01:04:50,620
ואז אתה בחלק האחורי?

1282
01:04:50,620 --> 01:04:54,699
>> קהל: לפונקציות כמו שאילתה,
להבהיר ולהתנצל [לא ברור]?

1283
01:04:54,699 --> 01:04:59,050

1284
01:04:59,050 --> 01:05:03,050
>> ZAMYLA צ'אן: השאלה הייתה האם
פונקציות אלה - השאילתה, להתנצל,

1285
01:05:03,050 --> 01:05:04,510
ולהבהיר -

1286
01:05:04,510 --> 01:05:05,930
הם נפוצים ברחבי ה-PHP.

1287
01:05:05,930 --> 01:05:09,460
אלה הם אלה שCS50
כתבתי לpset7.

1288
01:05:09,460 --> 01:05:09,910
וג'יי?

1289
01:05:09,910 --> 01:05:15,333
>> קהל: כאשר אתה צריך לומר
_SESSION $, הוא שרק לתעודות זהות?

1290
01:05:15,333 --> 01:05:17,310
או אפשר שיש לך אמר את זה כאן?

1291
01:05:17,310 --> 01:05:23,440
>> ZAMYLA צ'אן: אז השאלה הייתה, כאשר
אנו משתמשים _SESSION $, שהיה המבוקש

1292
01:05:23,440 --> 01:05:25,290
משתנה הגלובלי שבו אנו משתמשים.

1293
01:05:25,290 --> 01:05:32,080
כאן משתנים זה הולך
להיות מקומי לתפקוד שלנו.

1294
01:05:32,080 --> 01:05:36,588
אז אנחנו רק מכריזים
משתנה חדש.

1295
01:05:36,588 --> 01:05:38,460
>> קהל: איך הוא מתנצל
מיושם?

1296
01:05:38,460 --> 01:05:40,960
>> ZAMYLA צ'אן: השאלה הייתה,
איך הוא להתנצל מיושם?

1297
01:05:40,960 --> 01:05:44,180
ואני חושב שזה דווקא די
אימון טוב בשבילכם להיכנס

1298
01:05:44,180 --> 01:05:49,260
סעיף functions.php ומסתכלים על
מתנצל ולראות איך אתה יכול להיות

1299
01:05:49,260 --> 01:05:50,670
עשיתי את זה בעצמך.

1300
01:05:50,670 --> 01:05:55,620
אז אני יכול להשאיר לך את זה, אבל רק
אומר שאם אתה מסתכל על להתנצל,

1301
01:05:55,620 --> 01:06:02,110
אז זה לוקח את המסר שאתה
הוגש להתנצל, ואז זה

1302
01:06:02,110 --> 01:06:06,570
הופך את המסר הזה.

1303
01:06:06,570 --> 01:06:08,240
עוד שאלות?

1304
01:06:08,240 --> 01:06:08,710
אני אוהב שאלות.

1305
01:06:08,710 --> 01:06:09,555
אז לשמור אותם הקרובים.

1306
01:06:09,555 --> 01:06:11,888
>> קהל: [לא ברור]

1307
01:06:11,888 --> 01:06:13,840
הד או להדפיס לשם?

1308
01:06:13,840 --> 01:06:15,900
>> ZAMYLA צ'אן: השאלה הייתה,
אנחנו יכולים לא רק יש לשים

1309
01:06:15,900 --> 01:06:17,000
הד או להדפיס לשם.

1310
01:06:17,000 --> 01:06:19,710
אז זה היה עושה משהו
שונה במקצת.

1311
01:06:19,710 --> 01:06:23,750
זה היה מודפס שאילתה
נכשל בזה -

1312
01:06:23,750 --> 01:06:27,420
כן, ממש עכשיו, אנחנו בעצם
בבקר שלנו.

1313
01:06:27,420 --> 01:06:30,350
אז לא ממש יש לנו
HTML להגדיר כאן.

1314
01:06:30,350 --> 01:06:34,946
מתנצל על ידי טיוח apologize.php
מפנה אותך דווקא לapology.php.

1315
01:06:34,946 --> 01:06:39,560

1316
01:06:39,560 --> 01:06:42,200
על אישור.

1317
01:06:42,200 --> 01:06:45,880
>> אז עכשיו, בואו נלך על כדי לטפל
שאלה מקודם על מה

1318
01:06:45,880 --> 01:06:47,330
באמת שורות.

1319
01:06:47,330 --> 01:06:51,960
ובכן, שאילתה תחזיר
מערך של שורות.

1320
01:06:51,960 --> 01:06:55,020
וכל שורה מיוצגת
על ידי מערך אסוציאטיבי.

1321
01:06:55,020 --> 01:07:02,840
אז אם אני כבר ביצע כמה שאילתה ו-SQL
אני כבר מאוחסן התוצאה בשורות, ולאחר מכן

1322
01:07:02,840 --> 01:07:07,850
באמצעות לולאת foreach, ולאחר מכן את המערך
שם הוא הראשון יש אחד - השורות.

1323
01:07:07,850 --> 01:07:13,170
ולאחר מכן אני הולך לקרוא
כל שורה בשורה $ שם.

1324
01:07:13,170 --> 01:07:20,060
>> אז iterating על זה, אז אני יכול
גישה של השורה קבלה את שם טור,

1325
01:07:20,060 --> 01:07:22,340
טור שנה, ועמודה בית.

1326
01:07:22,340 --> 01:07:28,010
שים לב שאני לא היה מסוגל
לעשות את זה עם שורות, כי מדד שורות

1327
01:07:28,010 --> 01:07:29,290
שם לא קיימים.

1328
01:07:29,290 --> 01:07:31,970
שורות היא רק מערך של
מערכים אסוציאטיביים.

1329
01:07:31,970 --> 01:07:34,870
אז יש לך שתי רמות שם.

1330
01:07:34,870 --> 01:07:37,170
ברגע שיש לך את המערך של שורות,
יש לך להיכנס לזה.

1331
01:07:37,170 --> 01:07:39,110
ואז אתה יכול לגשת לעמודים.

1332
01:07:39,110 --> 01:07:41,636
האם זה עושה את זה ברור?

1333
01:07:41,636 --> 01:07:42,520
כן, בחזית?

1334
01:07:42,520 --> 01:07:45,490
>> קהל: [לא ברור] לפתוח
בסוגריים עבור [לא ברור]?

1335
01:07:45,490 --> 01:07:46,220
>> ZAMYLA CHAN: סלח לי?

1336
01:07:46,220 --> 01:07:49,740
>> קהל: סוגריים הפתוחים.

1337
01:07:49,740 --> 01:07:52,420
>> ZAMYLA צ'אן: אלה כאן?

1338
01:07:52,420 --> 01:07:58,520
זה מאפשר לי כולל
משתנה זה.

1339
01:07:58,520 --> 01:07:58,670
כן.

1340
01:07:58,670 --> 01:08:01,900
>> קהל: כאשר אתה מדפיס, אתה
מדפיס את קוד ה-HTML?

1341
01:08:01,900 --> 01:08:03,110
>> ZAMYLA צ'אן: כן.

1342
01:08:03,110 --> 01:08:07,720
כאשר אני מדפיס, זה כאן הוא בתוך
התבנית שלי עכשיו, אז

1343
01:08:07,720 --> 01:08:10,310
המבט שלי של שיטת MVC.

1344
01:08:10,310 --> 01:08:12,750
אז אני מדפיס לתוך ה-HTML.

1345
01:08:12,750 --> 01:08:16,670
>> קהל: אז אם נכנסנו למפתחים
כלים לאחר ההפעלה זו, שיכולנו

1346
01:08:16,670 --> 01:08:17,160
כי בעצם בקוד?

1347
01:08:17,160 --> 01:08:18,410
>> ZAMYLA צ'אן: זה נהדר
שאלה, כן.

1348
01:08:18,410 --> 01:08:22,359
כך שאם אתה נכנס לכלי הפיתוח
ב-Firefox באמצעות Firebug או

1349
01:08:22,359 --> 01:08:26,109
כרום, אז כן, אתה יכול
לראות את ה-HTML הספציפי.

1350
01:08:26,109 --> 01:08:28,470
כדי שלא להראות שורת $ ["שם"].

1351
01:08:28,470 --> 01:08:32,524
זה יראה לפי
שם הוא באותה שורה.

1352
01:08:32,524 --> 01:08:36,268
>> קהל: רק נושא כללי,
מה tr וTD מוגדר כ?

1353
01:08:36,268 --> 01:08:37,672
למה לנו [לא ברור]?

1354
01:08:37,672 --> 01:08:41,850

1355
01:08:41,850 --> 01:08:44,814
>> ZAMYLA צ'אן: TR שורת טבלה,
שולחן אז TD עמודה.

1356
01:08:44,814 --> 01:08:48,060

1357
01:08:48,060 --> 01:08:49,310
על אישור.

1358
01:08:49,310 --> 01:08:55,771

1359
01:08:55,771 --> 01:08:56,835
>> קהל: כן, זה נתוני טבלה.

1360
01:08:56,835 --> 01:08:58,770
>> ZAMYLA צ'אן: נתוני טבלה.

1361
01:08:58,770 --> 01:08:59,894
כן.

1362
01:08:59,894 --> 01:09:08,670
>> קהל: זה שורה שבה
הוא מטופל כמו עמודת שורה?

1363
01:09:08,670 --> 01:09:08,910
>> ZAMYLA צ'אן: מצטער.

1364
01:09:08,910 --> 01:09:10,570
האם אתה יכול לחזור על זה?

1365
01:09:10,570 --> 01:09:14,450
>> קהל: איך היית
לדמיין שורות?

1366
01:09:14,450 --> 01:09:16,310
>> ZAMYLA צ'אן: איך היית לדמיין
שורות באיזה סוג של דרך?

1367
01:09:16,310 --> 01:09:21,796
אתה מדבר על אלה
שורות כאן או שורות TR?

1368
01:09:21,796 --> 01:09:22,630
>> קהל: השורות.

1369
01:09:22,630 --> 01:09:25,229
>> ZAMYLA צ'אן: שורות אלו כאן?

1370
01:09:25,229 --> 01:09:28,620
הייתי לדמיין את זה כ
אני מבצע השאילתה שלי.

1371
01:09:28,620 --> 01:09:38,729
וזה אומר, בסדר, יש לי גם 0 עד n
כמות השורות התואמות את הקריטריונים

1372
01:09:38,729 --> 01:09:40,510
שיש לך שאילתה.

1373
01:09:40,510 --> 01:09:43,740
אז יש לי כמה מספר השורות.

1374
01:09:43,740 --> 01:09:51,450
אז שורות, שורות $, חנויות כל
אחד מאותם שורות במערך.

1375
01:09:51,450 --> 01:09:58,110
אז גם אם זה רק אחד מהם, זה
עדיין מערך של שורות התואמות את זה.

1376
01:09:58,110 --> 01:10:03,010
>> אז, למשל, זה הוא
דומה כאשר אתה הביא

1377
01:10:03,010 --> 01:10:05,390
המטמון ממשתמשים.

1378
01:10:05,390 --> 01:10:10,810
והקריטריונים לא היו שם
מזהה שווה מזהה הפעלה.

1379
01:10:10,810 --> 01:10:14,250
יש באמת רק היא שורה אחת
שיכול להתאים לזה.

1380
01:10:14,250 --> 01:10:18,960
אבל עדיין שורות פשוט חזרו לשורה אחת.

1381
01:10:18,960 --> 01:10:22,620
אז היית צריך ללכת לשורות,
מדד 0, מטמון אינדקס

1382
01:10:22,620 --> 01:10:26,195
למעשה להגיע למטמון שלך.

1383
01:10:26,195 --> 01:10:29,650
>> קהל: האם פונקצית ההדפסה
בהד את אותו הדבר?

1384
01:10:29,650 --> 01:10:30,670
>> ZAMYLA צ'אן: כן.

1385
01:10:30,670 --> 01:10:31,190
כן.

1386
01:10:31,190 --> 01:10:33,304
הדפס הד של אותו.

1387
01:10:33,304 --> 01:10:42,400
>> קהל: האם foreach הלולאה
רק דרך לאינדקס לתוך שורות?

1388
01:10:42,400 --> 01:10:46,110
>> ZAMYLA צ'אן: האם לולאת foreach
האופן שבו אתה יכול רק

1389
01:10:46,110 --> 01:10:47,030
לחזר דרך שורות?

1390
01:10:47,030 --> 01:10:47,180
לא.

1391
01:10:47,180 --> 01:10:51,000
אתה יכול גם להשתמש בלולאה, ובלבד
כי אתה יודע את האורך

1392
01:10:51,000 --> 01:10:53,024
של המערך של השורה.

1393
01:10:53,024 --> 01:10:58,500
>> קהל: האם אתה יכול לגשת אליו
באמצעות שורה כמו [לא ברור]?

1394
01:10:58,500 --> 01:11:01,640
>> ZAMYLA צ'אן: אז אתה לא יכול לגשת אליו
רק באמצעות שורה אם אין לך

1395
01:11:01,640 --> 01:11:05,160
foreach לולאה ובלבד ש
אתה לא הכריז רציפות.

1396
01:11:05,160 --> 01:11:08,150

1397
01:11:08,150 --> 01:11:09,660
כן.

1398
01:11:09,660 --> 01:11:10,810
כן, בלבן.

1399
01:11:10,810 --> 01:11:13,990
>> קהל: אז מה TR ו TD עושים?

1400
01:11:13,990 --> 01:11:16,790
>> ZAMYLA צ'אן: אז TR ו
TD הם תגי HTML.

1401
01:11:16,790 --> 01:11:19,590
TR מציין את תחילתה
של שורה בטבלה.

1402
01:11:19,590 --> 01:11:26,625
וכל אחד td מציין
עמודת נתונים חדשה שולחן.

1403
01:11:26,625 --> 01:11:32,275
>> קהל: לראייה של מה שורה
זה כמו, רק לדמיין SQL, איך

1404
01:11:32,275 --> 01:11:33,510
יש להם בשורה.

1405
01:11:33,510 --> 01:11:35,980
[לא ברור].

1406
01:11:35,980 --> 01:11:36,390
>> ZAMYLA צ'אן: כן.

1407
01:11:36,390 --> 01:11:37,630
זו נקודה גדולה.

1408
01:11:37,630 --> 01:11:41,510
אתה יכול לדמיין את השורות כמו סתם
כמו בטבלת Excel, רק

1409
01:11:41,510 --> 01:11:44,540
הרשימה של השורות.

1410
01:11:44,540 --> 01:11:46,870
על אישור.

1411
01:11:46,870 --> 01:11:47,230
בסדר.

1412
01:11:47,230 --> 01:11:50,740
אז עכשיו שאנחנו כבר דברנו על בחירה, אם
אין עוד שאלות, אנחנו

1413
01:11:50,740 --> 01:11:52,970
לעבור על גבי להוסיף.

1414
01:11:52,970 --> 01:11:58,220
אז אם אני רוצה להכניס לתוך כמה
שולחן ולהכניס עמודה מסוימת

1415
01:11:58,220 --> 01:12:02,320
ערכים, אני יכול להכניס את עצמי
לרייבנקלו ב -7 שנה.

1416
01:12:02,320 --> 01:12:07,245
אבל לפעמים אולי יש כפול
ערכים, כפי שראינו בpset7 כש

1417
01:12:07,245 --> 01:12:09,240
היו מעדכנים את תיק העבודות שלנו.

1418
01:12:09,240 --> 01:12:15,610
>> אז במקרה הזה, אנחנו רוצים להשתמש ON
DUPLICATE לעדכן את המפתח, כדי שלא

1419
01:12:15,610 --> 01:12:18,280
לאחסן שורות מרובות עם אותו
מעריך אלא לעדכן אותו.

1420
01:12:18,280 --> 01:12:21,780

1421
01:12:21,780 --> 01:12:25,560
אז בעצם יש לנו עדכון,
שלא להוסיף.

1422
01:12:25,560 --> 01:12:30,100
זה פשוט עדכון שבו אתה מעדכן
בטבלה מסוימת עם נתון

1423
01:12:30,100 --> 01:12:34,403
קריטריונים ואז, סוף סוף, למחוק,
שעושה דבר דומה מאוד.

1424
01:12:34,403 --> 01:12:40,200
>> קהל: האם אתה יכול בקצרה
לעבור על מפתח הכפול?

1425
01:12:40,200 --> 01:12:40,850
>> ZAMYLA צ'אן: כן.

1426
01:12:40,850 --> 01:12:48,340
בעיקרו של דבר כאן, יש לי INSERT INTO
גרינגוטס, היא, אוניות, ערכים אלה.

1427
01:12:48,340 --> 01:12:56,900
אבל זיהוי, ככל הנראה, הוא מפתח ייחודי
להגדיר את הערך בטבלת MySQL.

1428
01:12:56,900 --> 01:13:06,750
אז אם יש לי כבר להגדיר את הזהות ש,
אז אני לא יכול להוסיף שורה חדשה.

1429
01:13:06,750 --> 01:13:10,961
אז אם הוא לא קיים כבר,
אז אני צריך לעדכן אותו.

1430
01:13:10,961 --> 01:13:16,040

1431
01:13:16,040 --> 01:13:17,722
באמצע בלבן.

1432
01:13:17,722 --> 01:13:21,570
>> קהל: אז הוספה, עדכון, מחיקה,
ובחר, הם אלה כולם זמינים

1433
01:13:21,570 --> 01:13:22,875
מקומי [לא ברור]?

1434
01:13:22,875 --> 01:13:27,320

1435
01:13:27,320 --> 01:13:29,630
>> ZAMYLA צ'אן: אז להוסיף,
עדכון, מחיקה ו

1436
01:13:29,630 --> 01:13:31,120
בחר כל שאילתות SQL.

1437
01:13:31,120 --> 01:13:34,970
בכל פעם אז אתה באמצעות SQL,
יהיה לך אלה זמינים.

1438
01:13:34,970 --> 01:13:38,226

1439
01:13:38,226 --> 01:13:40,706
>> קהל: חזרה לחידוני העבר -

1440
01:13:40,706 --> 01:13:44,178
לא הייתה שאלה שעסקה ב
אם היה לך שולחן ורציתי

1441
01:13:44,178 --> 01:13:52,610
הכנס ציוני מבחנים באחד ואתה מכניס
השם שלך, כך שהוא לא ייתן לך

1442
01:13:52,610 --> 01:13:54,594
הציון במבחן [לא ברור] של החבר שלך.

1443
01:13:54,594 --> 01:13:59,060
איך אתה הייתי עושה את זה עם הוספה?

1444
01:13:59,060 --> 01:14:02,490
>> ZAMYLA צ'אן: אז השאלה הייתה על
שאלת אמצע הקדנציה קודמת.

1445
01:14:02,490 --> 01:14:04,320
אני לא מודע לאשר
אחד שהוא עכשיו.

1446
01:14:04,320 --> 01:14:06,790
אז אולי אחר כך, אם אתה רוצה
לבוא ולהראות לי, אז אני יכול

1447
01:14:06,790 --> 01:14:08,155
בהחלט לתת לך טיפים.

1448
01:14:08,155 --> 01:14:11,250

1449
01:14:11,250 --> 01:14:15,460
אבל אם כבר מדבר על דברים הכנסה, כמו
לוקח ציון של מישהו כשאתה

1450
01:14:15,460 --> 01:14:18,800
לא צריך, בואו נדבר על
התקפות הזרקת SQL.

1451
01:14:18,800 --> 01:14:22,050
אז התקפת הזרקת SQL היא למעשה
שבו מישהו לוקח

1452
01:14:22,050 --> 01:14:27,680
יתרון של הביטחון הנמוך של
דרך שאתה לוקח בנתונים.

1453
01:14:27,680 --> 01:14:35,660
>> אז כאן, בדיוק כמו במימון CS50,
כאשר אנחנו מחוברים, אנחנו יכולים להיכנס ב

1454
01:14:35,660 --> 01:14:39,510
שם משתמש בטופס ההתחברות,
תיבת הטקסט הראשונה, ו

1455
01:14:39,510 --> 01:14:41,570
לאחר מכן להזין בסיסמא.

1456
01:14:41,570 --> 01:14:45,610
אולי קוד PHP שלנו עשוי להיראות
משהו כזה, את שם משתמש של $ שבו

1457
01:14:45,610 --> 01:14:51,410
הוא שם המשתמש של הודעה הנתונים וסיסמא
הוא סיסמא שלאחר הנתונים.

1458
01:14:51,410 --> 01:14:55,110
ואז אנחנו פשוט לבצע השאילתה שלנו, למשל,
בסדר, ובכן, השאילתה שלנו הולכת

1459
01:14:55,110 --> 01:14:57,990
בחר מהמשתמשים שלנו, שבו
שם המשתמש הוא

1460
01:14:57,990 --> 01:14:58,970
אחד שהם הגישו.

1461
01:14:58,970 --> 01:15:06,870
והסיסמה היא הסיסמה,
כלומר, סיסמאות תואמות.

1462
01:15:06,870 --> 01:15:12,670
>> עכשיו, מה אם במקום באמת
הגשת סיסמא בפועל, כמו

1463
01:15:12,670 --> 01:15:16,850
12345 ומנחשים בשיניים שאומר
סיסמא וניסיתי לפרוץ להם

1464
01:15:16,850 --> 01:15:21,460
חשבון, מה אם במקום
הם הגישו את זה.

1465
01:15:21,460 --> 01:15:24,380
הם יכולים להקליד אולי
ניחוש בסיסמא.

1466
01:15:24,380 --> 01:15:30,480
ואז הם היינו מסיימים את
ציטוט לאחר מכן הקלד באו 1 = 1.

1467
01:15:30,480 --> 01:15:35,160
זה יהיה קצב ישירות לתוך SQL
שאילתה לנראה משהו כזה.

1468
01:15:35,160 --> 01:15:38,200
בחר ממשתמשים בו את שם המשתמש
= שיניים וסיסמא

1469
01:15:38,200 --> 01:15:41,450
שווה שושן או 1 = 1.

1470
01:15:41,450 --> 01:15:45,450
>> אז או שיש הסיסמה
להיות נכון או 1 = 1,

1471
01:15:45,450 --> 01:15:47,870
וזה תמיד נכון.

1472
01:15:47,870 --> 01:15:52,780
אז במקרה הזה, בעצם, יכולים משתמשים
לנצל את זה ופשוט להיכנס

1473
01:15:52,780 --> 01:15:55,240
את עצמם ובגרזן
חשבונו של מישהו.

1474
01:15:55,240 --> 01:15:58,950
אז בגלל זה אנחנו רוצים למנוע
מישהו יצטרך לעשות את זה.

1475
01:15:58,950 --> 01:16:03,890
אבל למזלנו, פונקצית השאילתה על ידי
עובר במציינים ייקח

1476
01:16:03,890 --> 01:16:04,800
תטפל בזה בשבילך.

1477
01:16:04,800 --> 01:16:08,570
כמו כן, אתה בדרך כלל לא רוצה
להגיש למעשה את סיסמאות

1478
01:16:08,570 --> 01:16:09,310
את עצמם.

1479
01:16:09,310 --> 01:16:14,115
בגלל זה אנחנו מרוסקים או מוצפנים
שלהם במימון CS50.

1480
01:16:14,115 --> 01:16:17,553
>> קהל: חידון העבר דיבר
על מיתרי בריחת MySQL.

1481
01:16:17,553 --> 01:16:21,800
האם אנחנו צריכים לדאוג לזה?

1482
01:16:21,800 --> 01:16:22,670
>> ZAMYLA צ'אן: זו שאלה טובה.

1483
01:16:22,670 --> 01:16:29,050
מחרוזות בריחת MySQL היא בהחלט
פונקציה שהיה בשימוש בשאילתה שלנו.

1484
01:16:29,050 --> 01:16:30,420
אבל בהחלט לבדוק את זה.

1485
01:16:30,420 --> 01:16:32,950
אני הייתי אומר שזה משחק הוגן לדעת
שהיית צריך לקרוא לזה

1486
01:16:32,950 --> 01:16:34,370
לתפקד על חוט.

1487
01:16:34,370 --> 01:16:35,245
כן, בלינדה?

1488
01:16:35,245 --> 01:16:38,606
>> קהל: איך אתה יודע מתי זה
גרשיים בודדים או במרכאות כפולות?

1489
01:16:38,606 --> 01:16:43,516
וגם, אני מרגיש בהרצאה כמוך
הזכיר משהו על כך שלא

1490
01:16:43,516 --> 01:16:48,426
[לא ברור] או משהו או
ציטוט הסינגל שני בסוף.

1491
01:16:48,426 --> 01:16:56,407

1492
01:16:56,407 --> 01:17:00,825
אני חושב שהוא ציין בהרצאתו כי
אתה אמור להיות גרש 1

1493
01:17:00,825 --> 01:17:04,290
ואז לא צריכים גרשיים
או משהו.

1494
01:17:04,290 --> 01:17:05,540
>> קהל: [לא ברור].

1495
01:17:05,540 --> 01:17:14,860

1496
01:17:14,860 --> 01:17:18,657
>> קהל: הדבר הוא הסינגל האחרון
ציטוט שם שבתיבה השנייה

1497
01:17:18,657 --> 01:17:19,391
לא צריך להיות שם.

1498
01:17:19,391 --> 01:17:21,840
[לא ברור]

1499
01:17:21,840 --> 01:17:26,730
כי כשאתה לוקח שעברת אחת
לצטט את ולהתאים אותם לתוכן

1500
01:17:26,730 --> 01:17:30,522
שם הסיסמה היא, אם יש לך את זה
שאילתה, יש ציטוט אחד ב

1501
01:17:30,522 --> 01:17:31,340
הסוף כבר.

1502
01:17:31,340 --> 01:17:36,580
אתה רוצה להשתמש שבגרשיים
כאחד שעומד בפני אחד

1503
01:17:36,580 --> 01:17:37,574
[לא ברור].

1504
01:17:37,574 --> 01:17:42,820
אז מה זה בעצם בטקסט ה
תיבה לא צריכה את זה.

1505
01:17:42,820 --> 01:17:44,070
>> ZAMYLA צ'אן: אני ישנה את זה.

1506
01:17:44,070 --> 01:17:56,490

1507
01:17:56,490 --> 01:17:56,880
על אישור.

1508
01:17:56,880 --> 01:18:00,435
אם אין שאלות, אז אני
להעביר אותו מעל ליוסף לדבר

1509
01:18:00,435 --> 01:18:04,332
על JavaScript, וכולי.

1510
01:18:04,332 --> 01:18:09,540
>> [מחיאות כפות]

1511
01:18:09,540 --> 01:18:11,660
>> יוסף אונג: אז אנחנו פועלים
קצת מאחור.

1512
01:18:11,660 --> 01:18:13,280
אז אם אתה חייב לעזוב, זה בסדר.

1513
01:18:13,280 --> 01:18:16,540
אבל אנו מבקשים שתורידו את הראשים
אם אתה באמצע, כך שאתה

1514
01:18:16,540 --> 01:18:19,560
לא לחסום את המצלמה ואתה משתמש
היציאה חזרה אם יש לך.

1515
01:18:19,560 --> 01:18:25,010

1516
01:18:25,010 --> 01:18:26,306
אני ג'וזף דרך אגב.

1517
01:18:26,306 --> 01:18:27,556
היי.

1518
01:18:27,556 --> 01:18:37,910

1519
01:18:37,910 --> 01:18:38,630
מבחן, מבחן.

1520
01:18:38,630 --> 01:18:39,630
דן, האם זה טוב?

1521
01:18:39,630 --> 01:18:40,880
מגניב.

1522
01:18:40,880 --> 01:18:44,460

1523
01:18:44,460 --> 01:18:47,600
>> אז הווידאו יהיה גם פורסם
באינטרנט עבור אלה ש

1524
01:18:47,600 --> 01:18:48,850
צריך לעזוב עכשיו.

1525
01:18:48,850 --> 01:18:51,350

1526
01:18:51,350 --> 01:18:52,600
מביך.

1527
01:18:52,600 --> 01:18:56,300

1528
01:18:56,300 --> 01:18:57,510
על אישור.

1529
01:18:57,510 --> 01:18:59,730
אז ביקורת חידון.

1530
01:18:59,730 --> 01:19:00,980
זה חתול.

1531
01:19:00,980 --> 01:19:03,150

1532
01:19:03,150 --> 01:19:07,170
עכשיו, JavaScript, שהוא אולי לא
כאאווו עבור חלק מכם חבר 'ה.

1533
01:19:07,170 --> 01:19:07,370
על אישור.

1534
01:19:07,370 --> 01:19:09,280
אז זה ראשון, זוכר מZamyla.

1535
01:19:09,280 --> 01:19:11,270
זכור כי PHP היא
לרוץ על השרת.

1536
01:19:11,270 --> 01:19:15,230
והרבה פעמים, אתם כתבו לולאות
ב-PHP כדי להדפיס את ה-HTML, נכון?

1537
01:19:15,230 --> 01:19:19,170
אז ברגע שהקוד שמבצע, כי
פלט ה-HTML שאתה להדפיס

1538
01:19:19,170 --> 01:19:20,500
מקבל נשלח למשתמש.

1539
01:19:20,500 --> 01:19:25,960
וברגע שזה קורה, יכול לא יותר PHP
לרוץ, אלא אם כן אתה לטעון מחדש את הדף, של

1540
01:19:25,960 --> 01:19:27,660
כמובן, שreexecutes PHP.

1541
01:19:27,660 --> 01:19:30,080
אבל ברגע שאתה להדפיס את ה-HTML ש,
אתה לא יכול ללכת לשום מקום.

1542
01:19:30,080 --> 01:19:33,580
>> אז ה-HTML שנשלחה אל המשתמש,
שהוא הדפדפן כאן, שבו

1543
01:19:33,580 --> 01:19:35,470
מילו באמצעות המחשב.

1544
01:19:35,470 --> 01:19:40,340
וכל כך טוב, יש כמה דברים
ברגע שאנו שולחים HTML למשתמש.

1545
01:19:40,340 --> 01:19:43,350
לפעמים אנחנו רוצים לעשות משהו כמו
כאשר אתה לוחץ על משהו, אנחנו רוצים

1546
01:19:43,350 --> 01:19:47,350
תיבות התראה לצוץ, אלה מיני
אינטראקציות, כמו בעת הלחיצה על

1547
01:19:47,350 --> 01:19:50,740
מפתח, כאשר אתה לוחץ על משהו
דף, אני רוצה שמשהו יקרה.

1548
01:19:50,740 --> 01:19:54,550
ובכן, אתה לא יכול reexecute PHP
קוד ה-HTML שפעם אחת מוגדרת.

1549
01:19:54,550 --> 01:19:55,900
אז איך אתה עושה את זה?

1550
01:19:55,900 --> 01:19:59,930
>> אנחנו מציגים את השפה חדשה בשם
JavaScript, אשר פועל בדפדפן

1551
01:19:59,930 --> 01:20:02,890
זה מאפשר לך לעשות דברים
ל-HTML לאחר שתקבל את

1552
01:20:02,890 --> 01:20:04,020
אותם מהשרת.

1553
01:20:04,020 --> 01:20:07,050
וזו הסיבה שאנחנו קוראים לזה בצד לקוח
שפת תכנות.

1554
01:20:07,050 --> 01:20:09,110
זה עובד על המחשב שלך -

1555
01:20:09,110 --> 01:20:11,400
הלקוח.

1556
01:20:11,400 --> 01:20:13,830
כל שאלות על זה עד כה?

1557
01:20:13,830 --> 01:20:15,650
הפרדיגמה שהגיונית לאנשים?

1558
01:20:15,650 --> 01:20:16,010
על אישור.

1559
01:20:16,010 --> 01:20:16,790
טוב.

1560
01:20:16,790 --> 01:20:17,340
בסדר.

1561
01:20:17,340 --> 01:20:20,850
אז הדבר הראשון שיש לשים לב
הוא JavaScript היא לא PHP.

1562
01:20:20,850 --> 01:20:23,010
>> יש להם כמה תחביר שונה,
שנלך אליו.

1563
01:20:23,010 --> 01:20:24,530
ויש להם שימושים שונים מאוד.

1564
01:20:24,530 --> 01:20:26,640
JavaScript, שוב, לך
דפדפן, עבור הלקוח.

1565
01:20:26,640 --> 01:20:30,640
שרת פועל איפשהו על מישהו אחר
מחשב ששולח מידע

1566
01:20:30,640 --> 01:20:31,720
אליך, נכון?

1567
01:20:31,720 --> 01:20:36,730
אז אם אנו מבקשים מכם לכתוב קוד PHP
בבחינת שאלה, לא לכתוב

1568
01:20:36,730 --> 01:20:38,710
JavaScript ולהיפך.

1569
01:20:38,710 --> 01:20:41,710
אתה פשוט תאבד נקודות,
וזה לא יהיה נכון.

1570
01:20:41,710 --> 01:20:43,690
>> אז בואו להיכנס כמה
הבדלי תחביר -

1571
01:20:43,690 --> 01:20:46,140
JavaScript בצד השמאל
ו-PHP בצד הימין.

1572
01:20:46,140 --> 01:20:48,670
הדבר הראשון שתבחין עם
JavaScript, להצהיר על משתנה עם

1573
01:20:48,670 --> 01:20:49,440
מילת המפתח var -

1574
01:20:49,440 --> 01:20:53,590
V--R. PHP משמש סימן הדולר,
כZamyla דן קודם לכן.

1575
01:20:53,590 --> 01:20:57,570
אם אתה רוצה להכריז אסוציאטיבי
מערך, שאנחנו רואים את התחביר המוכר על

1576
01:20:57,570 --> 01:20:59,030
בצד ימין עם PHP.

1577
01:20:59,030 --> 01:21:01,630
בצד השמאל, במקום
אתה משתמש בסוגריים מסולסלים.

1578
01:21:01,630 --> 01:21:03,280
ולאחר מכן את המפתחות שלך הם בצד השמאל.

1579
01:21:03,280 --> 01:21:04,670
אז יש לך מעי גס.

1580
01:21:04,670 --> 01:21:06,560
ואז יש לך את הערכים
שאתה רוצה.

1581
01:21:06,560 --> 01:21:09,840
>> אז ככה היית עושה את זה ב-PHP
בצד ימין עם שנייה כי

1582
01:21:09,840 --> 01:21:10,955
קו שמתחיל במיל.

1583
01:21:10,955 --> 01:21:14,540
וככה היית עושה את זה על
בצד שמאל ב-JavaScript אם אתה רוצה

1584
01:21:14,540 --> 01:21:16,110
מה שאנו מכנים אובייקט.

1585
01:21:16,110 --> 01:21:19,340
ואובייקטים ב-JavaScript הם
רק מערכים אסוציאטיביים.

1586
01:21:19,340 --> 01:21:23,710
אז אם אתה רוצה לגשת לשדות, ב
PHP אתה משתמש בתחביר סוגר זה.

1587
01:21:23,710 --> 01:21:27,170
ודרך זו, אתה יכול להקצות מחדש
שדה בעל זה ללורן.

1588
01:21:27,170 --> 01:21:30,150
>> ובכן, ב-JavaScript, אם אחד רוצה
לגשת לשדה ולשנות אותו, אתה יכול

1589
01:21:30,150 --> 01:21:31,370
להשתמש בתחביר הנקודה.

1590
01:21:31,370 --> 01:21:33,860
אתה יכול גם להשתמש בתחביר הסוגר.

1591
01:21:33,860 --> 01:21:35,550
אבל אתה לא יכול להשתמש
תחביר הנקודה ב-PHP.

1592
01:21:35,550 --> 01:21:36,525
זה לא יעבוד.

1593
01:21:36,525 --> 01:21:38,910
זה עובד רק ב-PHP.

1594
01:21:38,910 --> 01:21:42,060
ולבסוף, כדי להדפיס דברים
קונסולה, אתה משתמש console.log, אשר

1595
01:21:42,060 --> 01:21:43,720
אתם משתמשים הרבה בpset8.

1596
01:21:43,720 --> 01:21:45,260
אתה יכול console.log ש.

1597
01:21:45,260 --> 01:21:50,030
>> אם אתה רוצה להדפיס מערך ב
PHP, אתה צריך להשתמש r הדפסה.

1598
01:21:50,030 --> 01:21:53,240
ובצד ימין, אתה רואה שאני חשיש
שרשור מחרוזת שם.

1599
01:21:53,240 --> 01:21:54,070
מישהו שאל קודם לכן.

1600
01:21:54,070 --> 01:21:55,850
אני משתמש בתוספת ב-JavaScript.

1601
01:21:55,850 --> 01:21:59,800
אם אני רוצה לשרשר משהו
ב-PHP, אני משתמש בנקודה.

1602
01:21:59,800 --> 01:22:00,800
אלה הם שונים.

1603
01:22:00,800 --> 01:22:03,420
אם אתה כותב קוד PHP,
לא משתמש בתוספת.

1604
01:22:03,420 --> 01:22:06,810
אם אתה כותב JavaScript
קוד, לא כותב נקודה.

1605
01:22:06,810 --> 01:22:08,230
זה לא יהיה נכון.

1606
01:22:08,230 --> 01:22:09,640
ואתה תהיה עצוב.

1607
01:22:09,640 --> 01:22:11,000
>> הבדלים אז תחביר.

1608
01:22:11,000 --> 01:22:14,710
יודע התחביר שלך, כי אם יש לך
לכתוב שאלה ואתה משתמש בתחביר

1609
01:22:14,710 --> 01:22:16,890
מהשפה הלא נכונה,
זה לא יעבוד.

1610
01:22:16,890 --> 01:22:19,520
וזה יהיה בסדר.

1611
01:22:19,520 --> 01:22:22,420
אז בואו נדבר על שליטה מסוימת
לזרום הבדלים, איך אתה משתמש

1612
01:22:22,420 --> 01:22:24,040
לולאות בכל אחד מהם.

1613
01:22:24,040 --> 01:22:26,610
Zamyla ניגש בצד ימין.

1614
01:22:26,610 --> 01:22:27,780
דברים בצד ימין
צריך להיות מוכר.

1615
01:22:27,780 --> 01:22:29,670
בואו נסתכל בצד השמאל.

1616
01:22:29,670 --> 01:22:34,830
>> כאשר אתה משתמש עבור n לולאה ב-JavaScript,
משתנה לולאה, var שלך אני שם,

1617
01:22:34,830 --> 01:22:37,210
לולאה את המפתחות של המערך.

1618
01:22:37,210 --> 01:22:39,150
אז אתה רואה שם, בית, ותפקיד.

1619
01:22:39,150 --> 01:22:42,440
אם אני console.log i, אני מקבל
שם, בבית, ובתפקיד.

1620
01:22:42,440 --> 01:22:44,720
אלה הם את המפתחות.

1621
01:22:44,720 --> 01:22:50,080
ב-JavaScript, לולאת foreach הולכת
על הערכים של המערך הזה.

1622
01:22:50,080 --> 01:22:52,040
אז אתה שם לב שהם שניהם אני.

1623
01:22:52,040 --> 01:22:56,000
אבל כאן בצד PHP, היא מדפיסה
את המילוא, CS50, וקמע.

1624
01:22:56,000 --> 01:22:57,390
אלה הם הערכים ב-PHP.

1625
01:22:57,390 --> 01:23:00,180
>> אז אלה הם כיצד שני אלה שונים
בשפות השונות.

1626
01:23:00,180 --> 01:23:02,970
אז אם אתה משתמש בforeach
לולאה, אל תניח שזה

1627
01:23:02,970 --> 01:23:03,760
נותן לך את המפתחות.

1628
01:23:03,760 --> 01:23:08,010
ואם אתה משתמש עבור n לולאה, לא
מניח שזה נותן לך את הערכים.

1629
01:23:08,010 --> 01:23:10,420
האם זה הגיוני עד כה?

1630
01:23:10,420 --> 01:23:13,630
השקופית הבאה הולכת להראות לכם
איך אתה יכול לגשת את ההפך ב

1631
01:23:13,630 --> 01:23:15,160
כל אחד מהם.

1632
01:23:15,160 --> 01:23:18,550
>> ובכן, אם יש לך את המפתח ב-JavaScript
ואתה רוצה את הערך,

1633
01:23:18,550 --> 01:23:20,440
אתה רק מדד ל
מערך עם זה.

1634
01:23:20,440 --> 01:23:23,640
אז מילו של אני אשיג לך מה
אתה רוצה - את הערכים.

1635
01:23:23,640 --> 01:23:25,260
יש תחביר שונה זה ב-PHP.

1636
01:23:25,260 --> 01:23:28,140
אם אתה באמת רוצה לדעת את זה, אני לא
חושב שהראינו לך את זה עדיין.

1637
01:23:28,140 --> 01:23:31,740
אבל אם אתה מעוניין, אתה יכול להשתמש
תחביר נוסף זה בצד הימין

1638
01:23:31,740 --> 01:23:35,130
לוואי שבאמת יאפשר לך לקבל את
מקשים ב-PHP כאשר אתה משתמש

1639
01:23:35,130 --> 01:23:35,880
foreach לולאה.

1640
01:23:35,880 --> 01:23:39,640
אז רק קצת טריוויה
אם אתה מעוניין.

1641
01:23:39,640 --> 01:23:42,630
>> אז זה רק כדי להדגים את
הבדלים בין שתי הלולאות הללו.

1642
01:23:42,630 --> 01:23:47,060
אל תערבב אותם כשאתה
תכנות שאלה.

1643
01:23:47,060 --> 01:23:49,774
כל שאלות בקשר לזה.

1644
01:23:49,774 --> 01:23:50,770
מגניב.

1645
01:23:50,770 --> 01:23:51,310
בסדר.

1646
01:23:51,310 --> 01:23:52,250
JavaScript אובייקטים.

1647
01:23:52,250 --> 01:23:53,040
אני דיברתי עליהם.

1648
01:23:53,040 --> 01:23:54,650
הם כמו מערכים אסוציאטיביים.

1649
01:23:54,650 --> 01:23:57,730
דבר אחד אני רוצה שתשים לב
כאן הוא שערך באסוציאטיבי

1650
01:23:57,730 --> 01:23:59,540
מערך יכול להיות כל דבר ב-JavaScript.

1651
01:23:59,540 --> 01:24:02,240
>> זה אפילו יכול להיות פונקציה,
כמו שם.

1652
01:24:02,240 --> 01:24:04,600
יש לי פונקציה ש
הוא ערך של מפתח.

1653
01:24:04,600 --> 01:24:07,030
ואם אני רוצה לקרוא לפונקציה ש,
אני פשוט לגשת לקליפה.

1654
01:24:07,030 --> 01:24:08,490
ואז אני שם את הסוגריים
אחרי זה.

1655
01:24:08,490 --> 01:24:09,790
וזה עובד.

1656
01:24:09,790 --> 01:24:15,570
אז כל שאלות?

1657
01:24:15,570 --> 01:24:16,370
לא?

1658
01:24:16,370 --> 01:24:16,650
על אישור.

1659
01:24:16,650 --> 01:24:18,190
טוב.

1660
01:24:18,190 --> 01:24:20,130
JavaScript, כמו PHP,
הוא מודפס באופן רופף.

1661
01:24:20,130 --> 01:24:20,970
מה זה אומר?

1662
01:24:20,970 --> 01:24:22,380
>> זה עושה לי סוגים.

1663
01:24:22,380 --> 01:24:24,800
אבל כאשר אתה מצהיר על JavaScript
משתנה, אתה אומר אני var.

1664
01:24:24,800 --> 01:24:25,850
אתה לא אומר את זה.

1665
01:24:25,850 --> 01:24:26,460
זה לא דבר.

1666
01:24:26,460 --> 01:24:28,000
אתה פשוט אומר שזה משתנה.

1667
01:24:28,000 --> 01:24:31,590
ולאחר מכן JavaScript יטפל
סוגים מתחת למכסת המנוע בשבילך.

1668
01:24:31,590 --> 01:24:34,390
אנחנו יכולים להמיר באופן חופשי בין
סוגים בגלל זה.

1669
01:24:34,390 --> 01:24:37,360
אז אני מתחיל את דרכו כמספר
במקרה זה.

1670
01:24:37,360 --> 01:24:38,790
ואז יש לי מיתרים.

1671
01:24:38,790 --> 01:24:39,710
ואני מוסיף לי לזה.

1672
01:24:39,710 --> 01:24:41,810
ואני להקצות מחדש אותו בחזרה לתוך i.

1673
01:24:41,810 --> 01:24:43,640
>> אז שבשורה ראשונה,
הוא את המספר.

1674
01:24:43,640 --> 01:24:47,310
בשורה השנייה, אני הופך כעת
מחרוזת לאחר שאני עושה השינוי.

1675
01:24:47,310 --> 01:24:52,820
וכאן, אני רק שרשור
מספר שעל החוט.

1676
01:24:52,820 --> 01:24:56,210
אז אתה רואה שלמרות שהייתי
שלם בחלק הראשון, זה סוג

1677
01:24:56,210 --> 01:24:58,500
כמו להיות מומר
מחרוזת ולאחר מכן להתווסף

1678
01:24:58,500 --> 01:25:00,510
על שמחרוזת שלום.

1679
01:25:00,510 --> 01:25:02,340
ואז זה מה שאני מתכוון
על ידי ההקלדה רופפת.

1680
01:25:02,340 --> 01:25:04,760
זה שאתה להמיר בין
סוגים מאוד בקלות.

1681
01:25:04,760 --> 01:25:08,840
וזה לא לזרוק אזהרות
עליך כאילו C עושה.

1682
01:25:08,840 --> 01:25:12,420
>> אז אני עכשיו מכיל שלום
123 למחרוזת.

1683
01:25:12,420 --> 01:25:13,270
הבא.

1684
01:25:13,270 --> 01:25:15,610
אנחנו גם יכולים להשוות באופן חופשי
בין סוגים.

1685
01:25:15,610 --> 01:25:19,310
אז אם אתה פשוט להשתמש ==, מאוד
כמו ב-PHP, JavaScript

1686
01:25:19,310 --> 01:25:20,480
עושה דבר דומה.

1687
01:25:20,480 --> 01:25:24,780
המחרוזת 123 היא זהה למספר
123 כאשר אתה משתמש בשווים כפולים.

1688
01:25:24,780 --> 01:25:27,820
כאשר משתמשים בו שווים משולשים, זה גם
רוצה לוודא כי

1689
01:25:27,820 --> 01:25:29,240
הסוג הוא אותו הדבר.

1690
01:25:29,240 --> 01:25:31,960
אז בגלל שהיא מחרוזת וכי הוא
מספר, אף על פי ששניהם

1691
01:25:31,960 --> 01:25:35,280
123, כאשר אתה משתמש משולש
שווה, אתה מקבל שווא.

1692
01:25:35,280 --> 01:25:39,330
בפעמים שוות מקרה, אתה מקבל אמיתי,
כי שווים כפולים לא

1693
01:25:39,330 --> 01:25:40,020
אכפת סוג.

1694
01:25:40,020 --> 01:25:42,500
אכפת שווים לשלושה על סוג.

1695
01:25:42,500 --> 01:25:43,750
שאלות?

1696
01:25:43,750 --> 01:25:45,790

1697
01:25:45,790 --> 01:25:48,390
על אישור.

1698
01:25:48,390 --> 01:25:52,870
>> ועוד דבר על JavaScript הוא
היקף הוא סוג של גלובלי אלא אם כן אתה

1699
01:25:52,870 --> 01:25:53,460
בפונקציה.

1700
01:25:53,460 --> 01:25:55,660
וזה עובד באותה
דרך ב-PHP בפועל.

1701
01:25:55,660 --> 01:25:57,500
אז בואו נלך דרך דוגמא זו.

1702
01:25:57,500 --> 01:25:59,110
אני מגדיר את i 999.

1703
01:25:59,110 --> 01:26:00,900
ואז אני נכנסתי לזה ללולאה.

1704
01:26:00,900 --> 01:26:06,110
אז אם אני מדפיס אני בזה ל
לולאה, אני מצפה 0, 1, 2, 3, 4.

1705
01:26:06,110 --> 01:26:07,390
אני מקבל i = 4.

1706
01:26:07,390 --> 01:26:10,770
זה מגדיל לי עכשיו עד 5 ב
סוף ללולאה.

1707
01:26:10,770 --> 01:26:13,300
ואז זה פורץ את הלולאה,
משום שהיא אינה מקיימת את

1708
01:26:13,300 --> 01:26:14,550
להתנות יותר.

1709
01:26:14,550 --> 01:26:16,650
>> מה אתה חושב שבא
console.log מדפיס?

1710
01:26:16,650 --> 01:26:20,570

1711
01:26:20,570 --> 01:26:24,790
אז זה מה שהוא הייתי עושה בג ב C,
כי אם יש לך, גם אני כמו var מחוץ

1712
01:26:24,790 --> 01:26:28,855
ויש לך אני var בתוך לולאה, כמו
ללולאה, אז זה עושה את זה באופן ש

1713
01:26:28,855 --> 01:26:30,690
זה scoped ששני
i שלהם שונים.

1714
01:26:30,690 --> 01:26:34,630
ב-JavaScript, פשוט יעשה את זה
להתייחס אליו כזהה אני.

1715
01:26:34,630 --> 01:26:37,870
אני מקבל 5, משום שזה היה הערך
לאחר שיצא מחוץ לעניינים.

1716
01:26:37,870 --> 01:26:39,120
אז אני של אלה הם אותם אני.

1717
01:26:39,120 --> 01:26:42,620

1718
01:26:42,620 --> 01:26:44,130
האם זה הגיוני?

1719
01:26:44,130 --> 01:26:45,720
>> ובכן, זה הגיוני מ
נקודת מבט-JavaScript.

1720
01:26:45,720 --> 01:26:49,510
אבל באותה פרדיגמה לא
לשאת מעל לג יש להם

1721
01:26:49,510 --> 01:26:50,310
כללים לקביעת טווח שונים.

1722
01:26:50,310 --> 01:26:50,630
כן.

1723
01:26:50,630 --> 01:26:52,566
>> קהל: [לא ברור]

1724
01:26:52,566 --> 01:26:54,990
מחוץ לפונקציה [לא ברור]?

1725
01:26:54,990 --> 01:26:58,340
>> יוסף אונג: אז מחוץ שפונקציה?

1726
01:26:58,340 --> 01:27:00,810
אז אני אגיע לזה בעוד שני.

1727
01:27:00,810 --> 01:27:02,580
אז אנחנו קוראים foo (i).

1728
01:27:02,580 --> 01:27:06,920
זה עובר לי לfoo, מרווחים
אותו, ולאחר מכן נכנס בו.

1729
01:27:06,920 --> 01:27:07,750
אז זה היה 5.

1730
01:27:07,750 --> 01:27:09,210
אז זה הופך להיות 6.

1731
01:27:09,210 --> 01:27:11,670
אבל מה שאני מדבר עליו
i כי בפונקציה זו.

1732
01:27:11,670 --> 01:27:14,430
בגלל שזה פרמטר, זה
scoped לתפקיד זה.

1733
01:27:14,430 --> 01:27:17,800
אז ברגע שאני בעצם יוצא שמ
פונקציה, עכשיו זה הולך

1734
01:27:17,800 --> 01:27:19,860
חזרה לאני הישן.

1735
01:27:19,860 --> 01:27:23,000
i כי הוא scoped רק בגלל
שהוא בתפקיד.

1736
01:27:23,000 --> 01:27:24,200
ויש לנו היקפו ובפונקציות.

1737
01:27:24,200 --> 01:27:29,080
אבל אין לנו היקף מחוץ
פונקציות ב-JavaScript.

1738
01:27:29,080 --> 01:27:31,170
האם זה הגיוני?

1739
01:27:31,170 --> 01:27:31,320
כן.

1740
01:27:31,320 --> 01:27:31,660
שאלה.

1741
01:27:31,660 --> 01:27:34,030
>> קהל: אותו דבר [לא ברור]?

1742
01:27:34,030 --> 01:27:34,500
>> יוסף אונג: אז כן.

1743
01:27:34,500 --> 01:27:36,260
ב-PHP, זה אותו הסוג של דבר.

1744
01:27:36,260 --> 01:27:37,680
יש עידון קל בעצם.

1745
01:27:37,680 --> 01:27:40,130
אבל אתה יכול לשאול אותי על
כי לאחר הבדיקה.

1746
01:27:40,130 --> 01:27:43,930
אתה לא באמת צריך לדעת
עידון שלחידון.

1747
01:27:43,930 --> 01:27:47,600
לכל דבר ועניין, כמו
משתנים הגלובאליים ו-PHP, אלא אם כן

1748
01:27:47,600 --> 01:27:49,150
הם בתפקיד, אותו
דבר ב-JavaScript.

1749
01:27:49,150 --> 01:27:49,480
כן.

1750
01:27:49,480 --> 01:27:52,890
>> קהל: למה זה מותר ב
JavaScript ולא שם אחר?

1751
01:27:52,890 --> 01:27:55,010
>> יוסף אונג: אז למה זה מותר
ב-JavaScript ולא ב-C?

1752
01:27:55,010 --> 01:27:58,180
זה רק מי שבא עם
JavaScript החליט שזה היה בסדר ב

1753
01:27:58,180 --> 01:27:59,510
ב-JavaScript.

1754
01:27:59,510 --> 01:28:02,430
אז זה בדיוק כמו שפת תכנות
אמנה כפי שהיינו אומר.

1755
01:28:02,430 --> 01:28:02,580
כן.

1756
01:28:02,580 --> 01:28:04,480
>> קהל: אז למה עשה
זה הולך 6-5?

1757
01:28:04,480 --> 01:28:08,280
>> יוסף אונג: כך זה נמשך 6-5,
כי כשעברתי i לfoo, כי

1758
01:28:08,280 --> 01:28:13,420
אני פנימי של foo כעת scoped לfoo,
בגלל היקף קיים בפונקציות ב

1759
01:28:13,420 --> 01:28:15,050
ב-JavaScript.

1760
01:28:15,050 --> 01:28:18,720
אבל ברגע שאני יוצא מכאן, כי זה
היה scoped לפונקציה, אני פשוט

1761
01:28:18,720 --> 01:28:24,300
באמצעות אני הרגיל שהיה בפנים
שאר בקרת הזרימה.

1762
01:28:24,300 --> 01:28:25,210
הגיוני?

1763
01:28:25,210 --> 01:28:26,910
האם אני יכול להמשיך הלאה?

1764
01:28:26,910 --> 01:28:27,320
בסדר.

1765
01:28:27,320 --> 01:28:29,180
מגניב.

1766
01:28:29,180 --> 01:28:31,890
>> קבלה זו היא אובייקטים
הם עברו על דרך הפניה.

1767
01:28:31,890 --> 01:28:33,990
אתה יודע איך זה כשאתה עובר
מערך לתוך C אתה יכול

1768
01:28:33,990 --> 01:28:35,810
למעשה לשנות את המערך?

1769
01:28:35,810 --> 01:28:37,350
זה אותו הדבר ב-JavaScript.

1770
01:28:37,350 --> 01:28:42,960
אם אני עובר אובייקט, במקרה זה, אני
עבר מילוא לתפקיד catify זה.

1771
01:28:42,960 --> 01:28:44,490
המילוא מתחיל.

1772
01:28:44,490 --> 01:28:46,310
שמו הוא מילוא בננה.

1773
01:28:46,310 --> 01:28:51,670
אני עובר אובייקט שלתוך פונקציה
כי זה אובייקט, אסוציאטיבי

1774
01:28:51,670 --> 01:28:53,730
מערך ב-JavaScript.

1775
01:28:53,730 --> 01:28:57,110
>> כאשר אני מבצע פעולה
בתפקיד זה, שזה יהיה

1776
01:28:57,110 --> 01:28:58,560
למעשה לשנות את האובייקט.

1777
01:28:58,560 --> 01:29:01,720
אז זה יקרה רק לאובייקטים
ב-JavaScript, בדיוק כמו שזה קורה

1778
01:29:01,720 --> 01:29:09,230
עבור מערכים פנימיים של שמו של ג אז המילוא
יהיה למעשה להפוך לחתול עכשיו.

1779
01:29:09,230 --> 01:29:10,090
האם זה הגיוני?

1780
01:29:10,090 --> 01:29:11,840
אז זה עובד רק לאובייקטים.

1781
01:29:11,840 --> 01:29:13,090
אובייקטים מועברים על דרך הפניה.

1782
01:29:13,090 --> 01:29:13,400
כן.

1783
01:29:13,400 --> 01:29:16,850
>> קהל: אז אתה אומר ש
בניגוד לאני משתנה.

1784
01:29:16,850 --> 01:29:17,240
>> יוסף אונג: כן.

1785
01:29:17,240 --> 01:29:20,330
איזה משתנה אני פשוט היה
מספר, נכון?

1786
01:29:20,330 --> 01:29:25,280
זה כמו ב-C כאשר אתה עובר
integer, זה יוצר עותק.

1787
01:29:25,280 --> 01:29:28,130
וכאשר אתה עובר מערך, זה בעצם
משנה את המערך בפועל

1788
01:29:28,130 --> 01:29:32,870
ג קורה אותו הדבר עם
JavaScript במקרה זה.

1789
01:29:32,870 --> 01:29:34,070
בסדר.

1790
01:29:34,070 --> 01:29:38,134
ולמחרת, מילו הוא עצוב כי
הוא עכשיו חתול.

1791
01:29:38,134 --> 01:29:40,790

1792
01:29:40,790 --> 01:29:45,060
זה היה ממש אחרי המילוא
כמה נסיעה לווטרינר.

1793
01:29:45,060 --> 01:29:46,860
>> אז איך להשתמש ב-JavaScript
בדף אינטרנט?

1794
01:29:46,860 --> 01:29:47,790
אנחנו יכולים לכלול אותו.

1795
01:29:47,790 --> 01:29:50,090
זהו קוד ה-HTML עם תגי הרצועה.

1796
01:29:50,090 --> 01:29:51,300
אז יש לי תגי רצועה שם.

1797
01:29:51,300 --> 01:29:54,820
ואז לשים קצת JavaScript
קוד בתוך תגי התסריט.

1798
01:29:54,820 --> 01:29:56,390
ולאחר מכן הוא מבצע את זה.

1799
01:29:56,390 --> 01:29:58,830
כאשר אני רק עושה את זה ככה, זה
קרא JavaScript מוטבע.

1800
01:29:58,830 --> 01:30:02,400
זה סוג של מבולגן, כי
JavaScript היא בעצם ב-HTML.

1801
01:30:02,400 --> 01:30:07,010
>> דרך טובה יותר לעשות את זה, הרבה יותר נחמד,
הוא לכתוב JavaScript ב

1802
01:30:07,010 --> 01:30:10,920
קובץ חיצוני ולאחר מכן לספק
תג סקריפט עם מקור.

1803
01:30:10,920 --> 01:30:14,920
וזה ילך לזה קובץ JavaScript
ולקרוא את קוד JavaScript מ

1804
01:30:14,920 --> 01:30:15,960
שאגיש במקום.

1805
01:30:15,960 --> 01:30:18,820
ודרך זו, אין לך הרבה
JavaScript בתחילת שלך

1806
01:30:18,820 --> 01:30:20,760
קובץ HTML, מה שהופך
זה באמת מבולגן.

1807
01:30:20,760 --> 01:30:21,860
אתה פשוט לשים אותו במקום אחר.

1808
01:30:21,860 --> 01:30:24,310
ואז זה יהיה לקרוא אותו משם.

1809
01:30:24,310 --> 01:30:25,560
האם זה הגיוני?

1810
01:30:25,560 --> 01:30:27,990

1811
01:30:27,990 --> 01:30:29,640
>> ענייני מיקום.

1812
01:30:29,640 --> 01:30:32,620
במקרה הספציפי הזה,
תסריט הוא לפני הגוף.

1813
01:30:32,620 --> 01:30:36,090
לכן, כאשר אני מבצע את זה, אין
שום דבר בגוף עדיין.

1814
01:30:36,090 --> 01:30:39,920
אולי זה יעשה קצת יותר
לחוש מתי אני מראה זה חלק הבא.

1815
01:30:39,920 --> 01:30:43,210
במקרה זה, את התסריט
מגיע לאחר div.

1816
01:30:43,210 --> 01:30:46,620
אז div מופיע למעשה
בעמוד הראשון.

1817
01:30:46,620 --> 01:30:49,470
ממש כאן בעיגול האדום הקטן הזה,
אתה רואה את הטקסט מופיע.

1818
01:30:49,470 --> 01:30:51,810
ואז ההתראה מופיעה.

1819
01:30:51,810 --> 01:30:54,890
>> במקרה הראשון, כי את התסריט
היה לפני div,

1820
01:30:54,890 --> 01:30:56,170
ההתראה מופיעה ראשונה.

1821
01:30:56,170 --> 01:30:59,250
ולאחר מכן div מופיע לאחר
שלך לסגור את התיבה.

1822
01:30:59,250 --> 01:31:01,330
אז הביצוע חשוב.

1823
01:31:01,330 --> 01:31:02,290
אז אנחנו נשמור את זה בחשבון.

1824
01:31:02,290 --> 01:31:03,640
זה יהיה חשוב
בקצת.

1825
01:31:03,640 --> 01:31:08,730

1826
01:31:08,730 --> 01:31:09,540
על אישור.

1827
01:31:09,540 --> 01:31:12,750
כל כך טוב, איך אתה לחכות עד
כל הדף נטען אז לפני שאתה

1828
01:31:12,750 --> 01:31:13,580
ביצוע קצת קוד?

1829
01:31:13,580 --> 01:31:15,540
אנחנו נגיע לזה קצת
קצת מאוחר יותר מדי.

1830
01:31:15,540 --> 01:31:19,016
אבל רק לשמור על מיקום זה
עניינים במוח כאשר אנו

1831
01:31:19,016 --> 01:31:20,570
הגיע לשקופית אחרת.

1832
01:31:20,570 --> 01:31:22,030
>> אז אנחנו מגיעים לDOM עכשיו.

1833
01:31:22,030 --> 01:31:23,550
ומה הוא DOM?

1834
01:31:23,550 --> 01:31:26,830
אז אם אתה מסתכל על קוד ה-HTML, זה פשוט
חבורה של טקסט על המסך.

1835
01:31:26,830 --> 01:31:30,560
אז איך יודע שJavaScript
זה אלמנט ב-HTML?

1836
01:31:30,560 --> 01:31:33,410
אז יש לנו כמה זיכרון
ייצוג זה

1837
01:31:33,410 --> 01:31:34,930
מבנה שיש לנו.

1838
01:31:34,930 --> 01:31:40,240
ובכל פעם שיש לנו את זה בזיכרון
ייצוג ב-JavaScript, אנו קוראים

1839
01:31:40,240 --> 01:31:41,750
כי ה-DOM.

1840
01:31:41,750 --> 01:31:45,130
וזה רק בדרך שאנשים החליטו
שאנחנו צריכים לייצג את זה

1841
01:31:45,130 --> 01:31:46,400
מבנה HTML כ.

1842
01:31:46,400 --> 01:31:47,940
>> ומה DOM זה נראה?

1843
01:31:47,940 --> 01:31:50,460
ובכן, בייצוג זיכרון,
אנחנו לוקחים את הטקסט הזה.

1844
01:31:50,460 --> 01:31:52,870
ואנחנו הופכים אותו לזיכרון
ייצוג.

1845
01:31:52,870 --> 01:31:54,400
אז זה את ה-HTML.

1846
01:31:54,400 --> 01:31:58,090
אז אנחנו הראשונים לגלות כי כל
יש עץ DOM מסמך.

1847
01:31:58,090 --> 01:31:59,400
זה נראה כמו עץ.

1848
01:31:59,400 --> 01:32:03,550
והמסמך מכיל את ה-HTML
תג, ממש הכל

1849
01:32:03,550 --> 01:32:05,150
בתוך זה עכשיו.

1850
01:32:05,150 --> 01:32:06,970
יש תג HTML שני ילדים.

1851
01:32:06,970 --> 01:32:08,630
יש לו ראש.

1852
01:32:08,630 --> 01:32:12,380
הראש הזה, אם אתה מסתכל על כניסה
שם על איך זה מובנה

1853
01:32:12,380 --> 01:32:14,960
בין התגים הקרובים,
יש ראש ילד.

1854
01:32:14,960 --> 01:32:17,130
הילד הוא כותרת.

1855
01:32:17,130 --> 01:32:18,370
בדיוק.

1856
01:32:18,370 --> 01:32:21,000
>> עכשיו, יש לנו ילד בגוף.

1857
01:32:21,000 --> 01:32:24,870
ואז גוף שיש לו
ילד בשם משפחה.

1858
01:32:24,870 --> 01:32:27,950
ויש לו המשפחה כי שלושה ילדים -

1859
01:32:27,950 --> 01:32:29,550
העתיק ביותר, באמצע, וצעיר.

1860
01:32:29,550 --> 01:32:31,960
אז אתה צריך לדעת איך לצייר תרשים
ככה כשנשאל אותך איך

1861
01:32:31,960 --> 01:32:34,270
כדי לצייר תרשים כאשר אנו נותנים
שלך את ה-HTML בצד השמאל.

1862
01:32:34,270 --> 01:32:36,350
יודע איך לייצר את עץ DOM.

1863
01:32:36,350 --> 01:32:38,930
ובתוך הדברים האלה, יש רק
חלק מטקסט, שאני כבר מיוצג

1864
01:32:38,930 --> 01:32:40,180
קופסות קטנות כ.

1865
01:32:40,180 --> 01:32:42,750

1866
01:32:42,750 --> 01:32:47,980
>> האם מבנה עץ DOM זה לעשות
תחושה ומה DOM?

1867
01:32:47,980 --> 01:32:49,300
אז מה עושה את עמ 'לעמוד?

1868
01:32:49,300 --> 01:32:51,850
כאן, עמ 'שם
בתג שמייצג

1869
01:32:51,850 --> 01:32:54,510
תג פסקה ב-HTML.

1870
01:32:54,510 --> 01:32:57,080
אז אתה יכול לבדוק את זה.

1871
01:32:57,080 --> 01:32:59,290
אבל זה רק אומר שזה קצת
מקום לחלק מהטקסט.

1872
01:32:59,290 --> 01:33:02,910
ויש לו כמה סטיילינג CSS ברירת מחדל,
בגלל שזה תג פסקה.

1873
01:33:02,910 --> 01:33:05,130
אבל לא באמת לדאוג
שחלק גדול מדי.

1874
01:33:05,130 --> 01:33:07,510
רק יודע שזה מציין מיקום
עבור חלק מטקסט.

1875
01:33:07,510 --> 01:33:08,480
כן.

1876
01:33:08,480 --> 01:33:10,200
שאלה?

1877
01:33:10,200 --> 01:33:11,021
כן.

1878
01:33:11,021 --> 01:33:12,374
>> קהל: אתה פשוט הזכרת CSS.

1879
01:33:12,374 --> 01:33:15,492
משפחת החשיש והחשיש
כל הדברים האלה הוא בעצם

1880
01:33:15,492 --> 01:33:17,400
המייצג את תעודות הזהות ב-CSS?

1881
01:33:17,400 --> 01:33:18,440
>> יוסף אונג: כן, בדיוק.

1882
01:33:18,440 --> 01:33:20,380
אני אגיע למה שhashes אלה
מתכוון בשני.

1883
01:33:20,380 --> 01:33:23,480
כאשר אנג'לה ניגשה CSS, היא
דיבר על סלקטורים ב-CSS.

1884
01:33:23,480 --> 01:33:26,770
אלה הם סלקטורים ב-CSS כי
היא מדברת.

1885
01:33:26,770 --> 01:33:28,268
כן, רוב?

1886
01:33:28,268 --> 01:33:32,060
>> ROB אודן: הייתי גם להגיב
DOM שבתוך תג הכותרת

1887
01:33:32,060 --> 01:33:35,385
גם צומת טקסט.

1888
01:33:35,385 --> 01:33:36,070
>> יוסף אונג: נכון.

1889
01:33:36,070 --> 01:33:38,370
אז בתוך תג הכותרת,
יש לי כמה DOM טקסט.

1890
01:33:38,370 --> 01:33:42,730
אז באמת, התואר הזה צריך להיות כמו
קופסא קטנה יורדת ממנה גם כן.

1891
01:33:42,730 --> 01:33:45,740
אבל זה לא ממש משנה
יותר מדי במקרה הזה.

1892
01:33:45,740 --> 01:33:49,620
באמת לא אכפת לנו על בלוטות טקסט,
כפי שאנו קוראים להם, יותר מדי.

1893
01:33:49,620 --> 01:33:50,270
בסדר, אנחנו עושים.

1894
01:33:50,270 --> 01:33:51,520
ככל הנראה, שאנחנו עושים.

1895
01:33:51,520 --> 01:33:54,260

1896
01:33:54,260 --> 01:33:57,100
ואני אתקן את זה כש
אני מעלה את זה שוב.

1897
01:33:57,100 --> 01:33:59,830
האם זה הגיוני?

1898
01:33:59,830 --> 01:34:01,160
>> אז איך אנחנו עובדים עם DOM?

1899
01:34:01,160 --> 01:34:03,790
בכל פעם שאתם מתמודדים עם DOM ב
JavaScript, יש שני שלבים.

1900
01:34:03,790 --> 01:34:05,030
אתה בוחר אלמנט DOM.

1901
01:34:05,030 --> 01:34:06,580
ואז אתה עושה את הדברים אליו.

1902
01:34:06,580 --> 01:34:11,480
אז במקרה הזה, בצורה מופשטת, יש לי
נבחר אלמנט האמצע.

1903
01:34:11,480 --> 01:34:14,530
ולאחר מכן דוגמה לעושה דברים
כדי שזה יהיה לשנות את הטקסט.

1904
01:34:14,530 --> 01:34:16,020
שהיה אמורים להיות בוב.

1905
01:34:16,020 --> 01:34:19,930
עכשיו, מה שעשיתי לו היה לי השתנה
בוב למילוא במקרה זה.

1906
01:34:19,930 --> 01:34:22,130
>> אז איך אנחנו באמת עושים את זה?

1907
01:34:22,130 --> 01:34:23,440
איך עושה את הבחירה?

1908
01:34:23,440 --> 01:34:26,560
ואיך אנחנו עושים דברים ל
הדבר ברגע שלקחנו אותו?

1909
01:34:26,560 --> 01:34:30,470
ובכן, הדרך בה אתה חבר 'ה שלמדו את זה
בכיתה זו היא באמצעותנו משהו

1910
01:34:30,470 --> 01:34:32,420
נקרא jQuery.

1911
01:34:32,420 --> 01:34:33,910
אז מה זה jQuery?

1912
01:34:33,910 --> 01:34:37,220
jQuery היא ספרייה שעושה
JavaScript קל יותר לכתוב.

1913
01:34:37,220 --> 01:34:39,500
אז מישהו לקח את הזמן
וכתב jQuery.

1914
01:34:39,500 --> 01:34:41,530
>> jQuery היא למעשה כתב
ב-JavaScript.

1915
01:34:41,530 --> 01:34:44,550
ואז בגלל שהם עשו את זה, עכשיו אנחנו
יש חבורה של פונקציות שלמות ש

1916
01:34:44,550 --> 01:34:46,020
אנחנו יכולים להשתמש בזה עושה אותנו
גר ממש קל.

1917
01:34:46,020 --> 01:34:48,580

1918
01:34:48,580 --> 01:34:50,030
אז מה הם כמה מן
דברים שהיא עושה?

1919
01:34:50,030 --> 01:34:51,650
זה עושה את בחירת אלמנטים קלים יותר.

1920
01:34:51,650 --> 01:34:54,020
זה עושה שינוי HTML,
הוספת כיתות לקלה יותר.

1921
01:34:54,020 --> 01:34:55,360
זה עושה את אייאקס לקל יותר.

1922
01:34:55,360 --> 01:34:58,230
אנחנו נגיע לזה בשנייה.

1923
01:34:58,230 --> 01:35:00,630
>> וזה מקביל לספריות C.

1924
01:35:00,630 --> 01:35:03,090
אז אתה כולל string.h,
אתה מקבל strlen.

1925
01:35:03,090 --> 01:35:04,680
אתה מקבל strcpy, את כל הדברים האלה.

1926
01:35:04,680 --> 01:35:09,650
כאשר אתה כולל jQuery, אתה מקבל נחמד
דרכים לבחירת אלמנטים לשינוי

1927
01:35:09,650 --> 01:35:10,390
דברים, וכולי.

1928
01:35:10,390 --> 01:35:12,990
אתה מקבל פונקציונלי נוסף ש
JavaScript לא נותן לך.

1929
01:35:12,990 --> 01:35:15,310
אז jQuery היא לא ב-JavaScript.

1930
01:35:15,310 --> 01:35:18,660
jQuery היא ספרייה שכתובה ב
JavaScript שעושה JavaScript

1931
01:35:18,660 --> 01:35:20,440
קל יותר לכתוב.

1932
01:35:20,440 --> 01:35:23,170
>> אז jQuery היא לא תכנות
שפה.

1933
01:35:23,170 --> 01:35:24,540
אבל JavaScript היא.

1934
01:35:24,540 --> 01:35:27,420

1935
01:35:27,420 --> 01:35:27,590
לעשות.

1936
01:35:27,590 --> 01:35:30,420
בטוח שאתה מקבל את המינוח נכון.

1937
01:35:30,420 --> 01:35:32,490
כל שאלה?

1938
01:35:32,490 --> 01:35:33,882
כן.

1939
01:35:33,882 --> 01:35:35,132
האם זאת שאלה?

1940
01:35:35,132 --> 01:35:37,910

1941
01:35:37,910 --> 01:35:38,350
בסדר.

1942
01:35:38,350 --> 01:35:40,080
אז איך אתה להשתמש jQuery?

1943
01:35:40,080 --> 01:35:42,390
ובכן, כשאתה כותב כמה
קוד JavaScript ואתה כולל

1944
01:35:42,390 --> 01:35:45,570
jQuery בחלק העליון של הקובץ שלך, כמו
קובץ תסריט, אתה משתמש בסימן הדולר

1945
01:35:45,570 --> 01:35:47,310
עכשיו כדי לקבל גישה לjQuery.

1946
01:35:47,310 --> 01:35:49,860
וזה שונה מ
סימן הדולר ב-PHP.

1947
01:35:49,860 --> 01:35:51,590
>> זה אותו הסמל שאתה
מקליד במקלדת שלך.

1948
01:35:51,590 --> 01:35:52,780
אבל הם אומר דברים שונים מאוד.

1949
01:35:52,780 --> 01:35:56,090
דולר סימן ב-PHP פירוש זה
איך אני מצהיר על משתנה.

1950
01:35:56,090 --> 01:35:59,120
ב-JavaScript, כשאתה כבר כלול
jQuery, הוא עומד לjQuery.

1951
01:35:59,120 --> 01:36:01,280
אז לזכור את זה.

1952
01:36:01,280 --> 01:36:03,420
אז איך אנחנו יכולים לבחור אלמנטי DOM?

1953
01:36:03,420 --> 01:36:06,500
ובכן, כשאתה עושה את זה JavaScript המכוער
דרך אגב, אתה ניגש

1954
01:36:06,500 --> 01:36:08,240
לתעד משתנה גלובלי.

1955
01:36:08,240 --> 01:36:11,170
ואז אתה מקבל אלמנט על ידי בני משפחה מזהה.

1956
01:36:11,170 --> 01:36:15,270
זה באמת ארוך ומלל
ולא מאוד נחמד.

1957
01:36:15,270 --> 01:36:18,190
>> או שאתה יכול לקבל את כל האלמנטים
שתג p.

1958
01:36:18,190 --> 01:36:20,080
זה עובד גם ב-JavaScript.

1959
01:36:20,080 --> 01:36:22,470
אבל אנחנו אף פעם לא באמת הראיתי
אתה התחביר יותר מדי.

1960
01:36:22,470 --> 01:36:24,620
מה שהראינו לך היה jQuery.

1961
01:36:24,620 --> 01:36:28,720
כך שכל שם למעלה, כי הבורר
באו לידי ביטוי ב-JavaScript רק מקבל

1962
01:36:28,720 --> 01:36:33,320
תמצית לדולר מאוד נחמד זה
תחתום משפחת hashtag.

1963
01:36:33,320 --> 01:36:38,480
ועמ '$, בדיוק איפה שזה ככה.

1964
01:36:38,480 --> 01:36:41,690
אם ברצונך לבחור את כל תגי p
בתוך משפחה, אנחנו שמים את החלל

1965
01:36:41,690 --> 01:36:42,890
בין שתיים.

1966
01:36:42,890 --> 01:36:44,815
ועכשיו, אנחנו מקבלים את כל p
תגים בתוך משפחה.

1967
01:36:44,815 --> 01:36:48,740

1968
01:36:48,740 --> 01:36:50,380
>> ונראה מוכר?

1969
01:36:50,380 --> 01:36:52,880
ובכן, אנג'לה דיברה על
סלקטורים ב-CSS.

1970
01:36:52,880 --> 01:36:54,200
תן לי שנייה אחת.

1971
01:36:54,200 --> 01:36:57,230
ולכן על מנת לבחור אלמנט,
אתה פשוט להשתמש באותו הדבר כמוך

1972
01:36:57,230 --> 01:36:58,530
הייתי עושה עם בורר-CSS.

1973
01:36:58,530 --> 01:37:00,910
אם אתה שם את חשיש בחזית
שלו, הוא בוחר לפי תעודת זהות.

1974
01:37:00,910 --> 01:37:02,220
נקודה בוחרת בכיתות.

1975
01:37:02,220 --> 01:37:06,230
אם רק יש לך את הדבר ללא
hashes או נקודות, הוא בוחר תגים אלה.

1976
01:37:06,230 --> 01:37:07,140
שאלות.

1977
01:37:07,140 --> 01:37:07,470
כן?

1978
01:37:07,470 --> 01:37:11,510
>> קהל: כאשר אנו משתמשים בנקודה שלנו
HTML, הוא כי לא jQuery?

1979
01:37:11,510 --> 01:37:13,520
>> יוסף אונג: דוט ב-HTML שלנו
זה דבר-JavaScript.

1980
01:37:13,520 --> 01:37:14,750
זה לא דבר של jQuery.

1981
01:37:14,750 --> 01:37:17,620
הדרך בה אתה חבר 'ה למדה את זה עם
jQuery היא לשימוש. html.

1982
01:37:17,620 --> 01:37:21,510
ואז אתה העביר אותו מה
HTML הולך להיות.

1983
01:37:21,510 --> 01:37:23,480
אז אני אגיע לזה בסתם
שני דווקא.

1984
01:37:23,480 --> 01:37:27,800
אז איך אנחנו עושים דברים לאלמנט
ברגע שאנחנו שבחרתי אותו?

1985
01:37:27,800 --> 01:37:30,130
אז זה דוגמא של
בחירת אלמנט.

1986
01:37:30,130 --> 01:37:32,280
אז עכשיו, אנחנו רוצים לעשות את הדברים אליו.

1987
01:37:32,280 --> 01:37:35,730
>> אז במקרה הזה, תן לי לחזור
לשקופית הקודמת.

1988
01:37:35,730 --> 01:37:37,360
זה היה בוב לפני.

1989
01:37:37,360 --> 01:37:40,660
ואני רוצה לשנות את זה
בתוך ה-HTML למילו.

1990
01:37:40,660 --> 01:37:43,240
אז אני קורא לפונקצית ה-HTML
מהאלמנט.

1991
01:37:43,240 --> 01:37:45,580
שפונקצית ה-HTML היא
שיטה של ​​אלמנט.

1992
01:37:45,580 --> 01:37:47,430
ואז אני נותן לו את מה
אני רוצה את ה-HTML כדי להיות.

1993
01:37:47,430 --> 01:37:50,560
וזה פשוט מחליף את מה שיש בפנים של
תג שעם כל מה שאני נותן לו.

1994
01:37:50,560 --> 01:37:50,830
כן.

1995
01:37:50,830 --> 01:37:51,170
שאלה?

1996
01:37:51,170 --> 01:37:57,397
>> קהל: hashtag משמש
רק jQuery.

1997
01:37:57,397 --> 01:37:59,313
[לא ברור]

1998
01:37:59,313 --> 01:38:01,230
לא היינו משתמש בזה.

1999
01:38:01,230 --> 01:38:01,960
>> יוסף אונג: כן, בדיוק.

2000
01:38:01,960 --> 01:38:03,750
אבל אל תדאגו יותר מדי
JavaScript על טהור.

2001
01:38:03,750 --> 01:38:06,670
אני רק רוצה שחבר 'ה להתמקד באופן שבי
הייתי עושה את זה עם jQuery, כי

2002
01:38:06,670 --> 01:38:10,020
זה הולך להיות חשוב
חלק בחידון.

2003
01:38:10,020 --> 01:38:10,400
נכון.

2004
01:38:10,400 --> 01:38:10,880
בדיוק.

2005
01:38:10,880 --> 01:38:16,025
אז אתה רואה שhashtag, כך
מתאים כדי לבחור את האלמנט עם

2006
01:38:16,025 --> 01:38:18,310
האמצע מזהה בגלל hashtag ש.

2007
01:38:18,310 --> 01:38:19,670
Hashtag אומר זהות.

2008
01:38:19,670 --> 01:38:22,870
ויש את האלמנט הזה ID של אמצע.

2009
01:38:22,870 --> 01:38:24,366
אז זה האלמנט שאנחנו בוחרים.

2010
01:38:24,366 --> 01:38:27,160
>> קהל: [לא ברור].

2011
01:38:27,160 --> 01:38:31,090
hashtag סימן דולר [לא ברור]?

2012
01:38:31,090 --> 01:38:31,710
>> יוסף אונג: אז לא.

2013
01:38:31,710 --> 01:38:33,280
השאלה היא האם אתה יכול להשתמש בו. ערך.

2014
01:38:33,280 --> 01:38:36,445
ו. הערך עובד רק על אלמנטים
כי הם תשומות.

2015
01:38:36,445 --> 01:38:40,950

2016
01:38:40,950 --> 01:38:45,495
בjQuery, זה יהיה
. Val, לא. ערך.

2017
01:38:45,495 --> 01:38:49,080
אז אני אגיע לדוגמה קטנה ש
מדגים את כל זה בשילוב

2018
01:38:49,080 --> 01:38:49,850
בשני.

2019
01:38:49,850 --> 01:38:53,130
אבל אני חושב שזה משרת מעט קטע
הגיוני לאנשים עד כה.

2020
01:38:53,130 --> 01:38:55,450
רוצה לשנות את ה-HTML,
לקרוא את שיטת ה-HTML.

2021
01:38:55,450 --> 01:38:56,432
כן.

2022
01:38:56,432 --> 01:38:58,200
>> קהל: האם אתה יכול להסביר
השיטה שוב?

2023
01:38:58,200 --> 01:39:01,900
>> יוסף אונג: אז שיטה היא פשוט
פונקציה ששייכת לאחד, בזה

2024
01:39:01,900 --> 01:39:04,590
מקרה, אחד מאלמנטי DOM אלה,
כי אתה רואה שאני

2025
01:39:04,590 --> 01:39:05,940
נבחר האלמנט ראשון.

2026
01:39:05,940 --> 01:39:07,320
למעשה, תן לי להשתמש בעכבר.

2027
01:39:07,320 --> 01:39:09,330
אני בחרתי את האלמנט ראשון.

2028
01:39:09,330 --> 01:39:12,310
ולאחר מכן התקשרתי לHTML זה
פונקציה שהייתה לו.

2029
01:39:12,310 --> 01:39:15,710
ומכיוון שפונקציה זו שייכת ל
את הדבר הזה, אנחנו קוראים לזה שיטה.

2030
01:39:15,710 --> 01:39:19,480
זה פשוט שם מפואר לזה.

2031
01:39:19,480 --> 01:39:20,730
תגיד את זה שוב.

2032
01:39:20,730 --> 01:39:22,880

2033
01:39:22,880 --> 01:39:25,170
אז זכור, בחרנו
האלמנט עכשיו.

2034
01:39:25,170 --> 01:39:27,810
ואנחנו שמנו את זה בפנים של
משתנה האלמנט.

2035
01:39:27,810 --> 01:39:28,600
לתקן?

2036
01:39:28,600 --> 01:39:34,380
>> לכן, כאשר אנחנו רוצים לשנות את ה-HTML על
בפנים, בגלל שזה היה בוב לפני, אתה

2037
01:39:34,380 --> 01:39:36,420
רוצה לשנות את הטקסט שלמילו.

2038
01:39:36,420 --> 01:39:37,920
אז אנחנו קוראים ה-HTML.

2039
01:39:37,920 --> 01:39:41,610
ואנחנו אומרים לו מה HTML בתוך
אלמנט שצריך להיות עכשיו.

2040
01:39:41,610 --> 01:39:44,107
וכך הוא משנה אותו למילו,
כי אני נתתי את מילוא.

2041
01:39:44,107 --> 01:39:46,542
>> קהל: אז הם עובדים יחד.

2042
01:39:46,542 --> 01:39:47,030
[לא ברור]

2043
01:39:47,030 --> 01:39:47,390
>> יוסף אונג: כן, כן.

2044
01:39:47,390 --> 01:39:48,180
הם עובדים יחד.

2045
01:39:48,180 --> 01:39:50,210
אז אחד מהם בוחר
האלמנט ראשון.

2046
01:39:50,210 --> 01:39:52,863
והשנייה אחת עושה
משהו.

2047
01:39:52,863 --> 01:39:53,790
כן.

2048
01:39:53,790 --> 01:39:56,168
>> קהל: [לא ברור].

2049
01:39:56,168 --> 01:40:01,280
אם שיטה זו שונה מב-HTML
יש לך השיטה שווה בפועל.

2050
01:40:01,280 --> 01:40:01,560
>> יוסף אונג: כן.

2051
01:40:01,560 --> 01:40:03,370
זה הוא בשיטה שונה.

2052
01:40:03,370 --> 01:40:04,670
זה הוא בשיטה שונה.

2053
01:40:04,670 --> 01:40:07,860
ואנחנו יכולים לכסות את זה רק שני
כשנגיע לירושלים.

2054
01:40:07,860 --> 01:40:12,000
אני רוצה לוודא שאנחנו לזרז
כי אנחנו הולכים ואוזל זמן.

2055
01:40:12,000 --> 01:40:15,360
אבל יש לנו להפעיל דרך לאורך זמן עכשיו.

2056
01:40:15,360 --> 01:40:15,490
על אישור.

2057
01:40:15,490 --> 01:40:16,430
מגניב.

2058
01:40:16,430 --> 01:40:20,130
אז אם ברצונך להוסיף בכיתה, יש
גם שיטת כיתת תוספת.

2059
01:40:20,130 --> 01:40:24,300
זוהי רק דוגמא למה
אתה יכול לעשות עם jQuery.

2060
01:40:24,300 --> 01:40:25,950
זה רק מוסיף כיתה.

2061
01:40:25,950 --> 01:40:28,660
>> אם אתה רוצה להסיר אותו,
אתה יכול להתקשר להסרה.

2062
01:40:28,660 --> 01:40:32,280
זה פשוט עוד דבר שאתה יכול לעשות.

2063
01:40:32,280 --> 01:40:35,680
אז עוד דוגמאות של דברים שאתה יכול לעשות.

2064
01:40:35,680 --> 01:40:37,510
אז יכול פשוט שמתי את זה ב
הראש כזה?

2065
01:40:37,510 --> 01:40:38,760
הסרה צעירה.

2066
01:40:38,760 --> 01:40:42,470

2067
01:40:42,470 --> 01:40:45,930
אם אני רק לבצע JavaScript שב
החלק העליון של התיק שלי, האם זה עובד?

2068
01:40:45,930 --> 01:40:48,540

2069
01:40:48,540 --> 01:40:48,920
נכון.

2070
01:40:48,920 --> 01:40:50,530
בגלל אמצע אינו קיים עדיין.

2071
01:40:50,530 --> 01:40:51,840
אז זה לא הולך לעבודה.

2072
01:40:51,840 --> 01:40:52,800
צו הוצאה לפועל.

2073
01:40:52,800 --> 01:40:55,040
זה הולך לראש ראשון.

2074
01:40:55,040 --> 01:40:55,540
מה?

2075
01:40:55,540 --> 01:40:57,450
>> קהל: הצעיר עדיין אינו קיים?

2076
01:40:57,450 --> 01:40:57,810
>> יוסף אונג: כן.

2077
01:40:57,810 --> 01:40:58,710
צעיר עדיין אינו קיים.

2078
01:40:58,710 --> 01:40:59,600
בדיוק.

2079
01:40:59,600 --> 01:41:01,320
>> קהל: אתה אמר אמצע.

2080
01:41:01,320 --> 01:41:01,510
>> יוסף אונג: מצטער.

2081
01:41:01,510 --> 01:41:02,720
צעיר עדיין אינו קיים.

2082
01:41:02,720 --> 01:41:04,510
והדבר השני הוא שיש לי לא
כלל את jQuery

2083
01:41:04,510 --> 01:41:06,580
להגיש שואל src תסריט.

2084
01:41:06,580 --> 01:41:07,960
אז זה לא הולך לעבודה.

2085
01:41:07,960 --> 01:41:09,580
למעשה, אני לא עשיתי את זה ב
השקופית הבאה, שהוא

2086
01:41:09,580 --> 01:41:10,700
אמור לתקן גם את זה.

2087
01:41:10,700 --> 01:41:14,120
אבל הדרך בה אנו עושים זאת היא JavaScript
הוא אירוע מונע.

2088
01:41:14,120 --> 01:41:17,410
אז מה שאנו עושים זה להשתמש באירוע
מטפל כדי שזה יקרה.

2089
01:41:17,410 --> 01:41:19,510
וכך אני בוחר את המסמך
המערכה ראשונה.

2090
01:41:19,510 --> 01:41:23,810
אני אומר, בסדר, כאשר המסמך
מוכן, תן לי להפעיל פונקציה.

2091
01:41:23,810 --> 01:41:25,470
אז זה כל מה שאמצעי התחביר.

2092
01:41:25,470 --> 01:41:27,100
>> אני נבחר את המסמך.

2093
01:41:27,100 --> 01:41:29,530
עכשיו, כאשר המסמך הוא
מוכן, להפעיל את הפונקציה.

2094
01:41:29,530 --> 01:41:32,970
וכן כאן כאשר המסמך
מוכן, מה שאומר שיש את כל ה-HTML

2095
01:41:32,970 --> 01:41:36,140
טעון, ואז אני מפעיל את הפונקציה
שמסיר את האלמנט הזה.

2096
01:41:36,140 --> 01:41:40,270
וכך עכשיו, כאשר אני מפעיל פונקציה זו
שעברתי למוכן, אני

2097
01:41:40,270 --> 01:41:43,780
מובטח כי כל HTML על
הדף הולך להתקיים ראשון.

2098
01:41:43,780 --> 01:41:44,100
כן.

2099
01:41:44,100 --> 01:41:44,425
שאלה?

2100
01:41:44,425 --> 01:41:48,200
>> קהל: מה היא מילת המפתח האירוע
בתוך הפונקציה?

2101
01:41:48,200 --> 01:41:51,750
>> יוסף אונג: אז שמילת מפתח באירוע
פונקציה היא רק פרמטר ש

2102
01:41:51,750 --> 01:41:53,490
מקבל מועבר לפונקציה
לכל אירוע.

2103
01:41:53,490 --> 01:41:55,470
זה פשוט משהו ש
אתה מקבל בחינם.

2104
01:41:55,470 --> 01:41:59,320
כשאתה משתמש במפעילים מרכזיים ב
pset8, אירוע שיכול להגיד לך, עבור

2105
01:41:59,320 --> 01:42:01,350
למשל, שמפתח שאתה לחצת על.

2106
01:42:01,350 --> 01:42:05,540
במקרה זה, לאירוע מוכן,
זה ממש לא סופר שימושי.

2107
01:42:05,540 --> 01:42:08,640
אבל עבור למטה אירוע מרכזי, זה יותר
שימושי, כי אתה לומד להכיר בי

2108
01:42:08,640 --> 01:42:12,330
מפתח שאתה לחצת על ידי גישה למפתח
קוד הנחה שאובייקט אירוע.

2109
01:42:12,330 --> 01:42:13,530
לתקן?

2110
01:42:13,530 --> 01:42:15,160
האם זה הגיוני?

2111
01:42:15,160 --> 01:42:16,280
על אישור.

2112
01:42:16,280 --> 01:42:16,580
כן.

2113
01:42:16,580 --> 01:42:17,150
שאלה?

2114
01:42:17,150 --> 01:42:19,290
>> קהל: אז אתה יכול לשים
תג סקריפט נמוך יותר?

2115
01:42:19,290 --> 01:42:19,940
>> יוסף אונג: אז כן.

2116
01:42:19,940 --> 01:42:21,500
אתה יכול לשים את התסריט
לתייג יותר למטה.

2117
01:42:21,500 --> 01:42:23,090
אבל אז זה פשוט הופך להיות ממש מבולגן.

2118
01:42:23,090 --> 01:42:26,590
ואנחנו רוצים לרכז את כל
של הקוד שלנו במקום אחד.

2119
01:42:26,590 --> 01:42:28,290
וזה יאפשר לנו לעשות את זה.

2120
01:42:28,290 --> 01:42:32,010
זכור קודם לכן אמרתי שיש יותר נחמד
דרך להבטיח שאלמנטים הם

2121
01:42:32,010 --> 01:42:33,880
בעמוד לפני שאתה לבצע קוד?

2122
01:42:33,880 --> 01:42:36,079
וזו רק דרך נחמדה
היית להשיג את זה.

2123
01:42:36,079 --> 01:42:37,329
>> קהל: [לא ברור].

2124
01:42:37,329 --> 01:42:41,710

2125
01:42:41,710 --> 01:42:42,230
>> יוסף אונג: כן.

2126
01:42:42,230 --> 01:42:43,460
אתה עדיין תצטרך, נכון?

2127
01:42:43,460 --> 01:42:46,930
כי תזכור, אתה כלול
להגיש בחלק העליון של הדף.

2128
01:42:46,930 --> 01:42:49,890
אז זה הולך לבצע לראשונה לפני
אתה מגיע לתחתית הדף.

2129
01:42:49,890 --> 01:42:54,600

2130
01:42:54,600 --> 01:42:55,180
על אישור.

2131
01:42:55,180 --> 01:42:59,210
אז אתה יכול גם להוסיף שונה
סוג של מטפל באירועים.

2132
01:42:59,210 --> 01:43:00,640
אחד זה רק מעבד קליקים.

2133
01:43:00,640 --> 01:43:03,910
כאשר אני לוחץ על צעיר, ולאחר מכן
זה יצוץ עם התראה.

2134
01:43:03,910 --> 01:43:05,440
זוהי רק שונה
סוג של אירוע.

2135
01:43:05,440 --> 01:43:08,840
בניגוד לאירוע מוכן, אתה עכשיו
להשתמש באירוע הלחיצה בעת הקבלה

2136
01:43:08,840 --> 01:43:10,190
לוחץ על אלמנט.

2137
01:43:10,190 --> 01:43:13,860
>> ולכן במקרה זה, יש לזכור, לחץ
מטפל מחובר לצעיר.

2138
01:43:13,860 --> 01:43:16,080
אז זה קורה רק כאשר
אני לוחץ על צעיר.

2139
01:43:16,080 --> 01:43:19,510
ובשניית אחת, האירוע מוכן
מצורף למסמך.

2140
01:43:19,510 --> 01:43:23,750
אז הוא ממתין למסמך
כדי להיות מוכן.

2141
01:43:23,750 --> 01:43:25,120
הגיוני?

2142
01:43:25,120 --> 01:43:26,190
אני חושב שאני יכול להמשיך הלאה.

2143
01:43:26,190 --> 01:43:26,610
כן.

2144
01:43:26,610 --> 01:43:26,980
שאלה?

2145
01:43:26,980 --> 01:43:28,230
>> קהל: [לא ברור].

2146
01:43:28,230 --> 01:43:31,676

2147
01:43:31,676 --> 01:43:33,620
במקרה זה אתה משתמש [לא ברור].

2148
01:43:33,620 --> 01:43:36,650
>> יוסף אונג: הו, כן, כי בזה
מקרה, אני צריך לחכות לצעיר

2149
01:43:36,650 --> 01:43:40,740
אלמנט שיופיע במסך ראשון
לפני שאני יכול לצרף מטפל לחץ כדי

2150
01:43:40,740 --> 01:43:43,062
את זה, וזו הסיבה שאני שם את זה בתוך
של מסמך מוכן.

2151
01:43:43,062 --> 01:43:45,780

2152
01:43:45,780 --> 01:43:46,840
על אישור.

2153
01:43:46,840 --> 01:43:52,390
והבא, אז זה הוא דוגמא גדולה של
איך היית משלב את הכל.

2154
01:43:52,390 --> 01:43:55,930
זוהי רק דוגמא אימות טופס
שראית בהרצאה.

2155
01:43:55,930 --> 01:43:58,410
אז לקחת את זה צעד אחר צעד כמו
אתה עובר את זה.

2156
01:43:58,410 --> 01:43:59,590
וזה יהיה בסדר לגמרי.

2157
01:43:59,590 --> 01:44:01,400
רק לקרוא אותו מלמעלה למטה.

2158
01:44:01,400 --> 01:44:03,030
>> יש לי טופס בתחתית.

2159
01:44:03,030 --> 01:44:07,590
כאשר המסמך מוכן, אני מצרף
להגיש מטפל לטופס, כגון ש

2160
01:44:07,590 --> 01:44:12,910
כשאני מגיש את הטופס, אני מקבל את הערכים
בתוך כל אחד מתשומות אלה.

2161
01:44:12,910 --> 01:44:14,560
ואני בודק אם זה ריק.

2162
01:44:14,560 --> 01:44:17,090
אם זה ריק, אני חוזר שווא, כי
אני לא רוצה לשלוח את הטופס,

2163
01:44:17,090 --> 01:44:18,950
בגלל הצורה שגויה.

2164
01:44:18,950 --> 01:44:22,040
אם הסיסמה היא ריקה או שזה פחות
משמונה תווים, אני לא תגיש

2165
01:44:22,040 --> 01:44:24,470
את הטופס, כי זה גם לא נכון.

2166
01:44:24,470 --> 01:44:28,150
ושקר התמורה פשוט מונע
צורת הגשה ומ

2167
01:44:28,150 --> 01:44:30,150
הולך לדף חדש.

2168
01:44:30,150 --> 01:44:31,310
>> ובתקווה, זה הגיוני.

2169
01:44:31,310 --> 01:44:34,650
אני חושב שאתם צריכים ללכת דרך
צעד אחר צעד בקוד זה בעצמך.

2170
01:44:34,650 --> 01:44:38,350
וברגע שאתה מבין מה בחר
אלמנטים ולעשות את הדברים אליו

2171
01:44:38,350 --> 01:44:40,520
בעצם מחייב, זה יגרום לי
הרבה תחושה לך.

2172
01:44:40,520 --> 01:44:41,295
כן?

2173
01:44:41,295 --> 01:44:44,150
>> קהל: מה עושה
name = שם משתמש אומר?

2174
01:44:44,150 --> 01:44:48,530
>> יוסף אונג: אז name = שם המשתמש ו
name = סיסמא רק אומרת מסתכלת

2175
01:44:48,530 --> 01:44:50,730
תכונה של מה
אתה בוחר.

2176
01:44:50,730 --> 01:44:51,790
ולאחר מכן שיש להתאים.

2177
01:44:51,790 --> 01:44:53,870
אז אנחנו הולכים לרישום.

2178
01:44:53,870 --> 01:44:56,240
ואז אנחנו מסתכלים על כל התשומות
ורישום.

2179
01:44:56,240 --> 01:44:59,990
ואז אנחנו בוחרים בו שם אחד
התכונה שווה לשם משתמש.

2180
01:44:59,990 --> 01:45:04,040
כך שהבורר הראשון בוחר רק
קלט המשתמש.

2181
01:45:04,040 --> 01:45:08,220
וכי הבורר שני בוחר רק
הסיסמה אחת, כי יש לי אלה

2182
01:45:08,220 --> 01:45:12,240
שם את התכונות שלהם להגדיר כמו מה
הם אמורים להיות.

2183
01:45:12,240 --> 01:45:12,575
שאלה?

2184
01:45:12,575 --> 01:45:17,030
>> קהל: ביום ההגשה, איך עושה את
חלק תחתון לפתור את החלק העליון?

2185
01:45:17,030 --> 01:45:19,350
>> יוסף אונג: אז זה בגלל
של המטפל באירועים.

2186
01:45:19,350 --> 01:45:23,000
אז אנחנו מחכים לאירוע להגיש
שמקבל ירה מהטופס.

2187
01:45:23,000 --> 01:45:24,730
וזה כל מה שהוא שליחה.

2188
01:45:24,730 --> 01:45:26,080
למה אני קורא להגיש עד לשם?

2189
01:45:26,080 --> 01:45:28,870
זה אומר, כאשר הטופס שהוגש,
אני מקבל אירוע שליחה.

2190
01:45:28,870 --> 01:45:33,480
אז תן לי רק ליירט וש
לאחר מכן להפעיל את הקוד הזה במקום.

2191
01:45:33,480 --> 01:45:33,823
כן?

2192
01:45:33,823 --> 01:45:35,866
>> קהל: למה יש לך
יש אירוע פונקציה?

2193
01:45:35,866 --> 01:45:38,580
למה לא פשוט [לא ברור] אתה יכול?

2194
01:45:38,580 --> 01:45:41,140
>> יוסף אונג: כי ב-JavaScript, אתה
יש להכריז על הפונקציות.

2195
01:45:41,140 --> 01:45:42,910
זה בדיוק איך זה עובד
ב-JavaScript.

2196
01:45:42,910 --> 01:45:44,800
אתה חייב לומר שזה הולך
כדי להפעיל את פונקציה.

2197
01:45:44,800 --> 01:45:47,290
אז אתה אומר לו שאתה
מצפה פונקציה כאן במקום

2198
01:45:47,290 --> 01:45:48,260
רק סוגריים מסולסלים.

2199
01:45:48,260 --> 01:45:50,460
>> קהל: ואת הפונקציה
הוא מה שאחרי?

2200
01:45:50,460 --> 01:45:50,650
>> יוסף אונג: כן.

2201
01:45:50,650 --> 01:45:52,790
הפונקציה היא מה שבפנים
הסוגריים המסולסלים אחרי

2202
01:45:52,790 --> 01:45:53,630
שמילת מפתח הפונקציה.

2203
01:45:53,630 --> 01:45:54,045
כן?

2204
01:45:54,045 --> 01:45:55,295
>> קהל: [לא ברור].

2205
01:45:55,295 --> 01:46:00,180

2206
01:46:00,180 --> 01:46:00,660
>> יוסף אונג: להגשה?

2207
01:46:00,660 --> 01:46:03,520
>> קהל: לא, לפונקציה
ללא אירוע.

2208
01:46:03,520 --> 01:46:03,770
>> יוסף אונג: כן.

2209
01:46:03,770 --> 01:46:05,610
אז בלי האירוע,
אתה יכול לקבל את זה.

2210
01:46:05,610 --> 01:46:08,480
אם אתה לא צריך את האירוע,
אז אתה יכול פשוט להשמיט אותו.

2211
01:46:08,480 --> 01:46:12,220
אבל אם אתה עושה, אז אתה
פשוט לשים אותו שם.

2212
01:46:12,220 --> 01:46:12,520
כן.

2213
01:46:12,520 --> 01:46:13,190
שאלה מהירה?

2214
01:46:13,190 --> 01:46:14,440
>> קהל: [לא ברור].

2215
01:46:14,440 --> 01:46:21,170

2216
01:46:21,170 --> 01:46:21,440
>> יוסף אונג: כן.

2217
01:46:21,440 --> 01:46:24,550
כי מה שאתה צריך לעשות,
document.ready פשוט אומר לחכות לכל

2218
01:46:24,550 --> 01:46:26,540
HTML בדף לטעון ראשון.

2219
01:46:26,540 --> 01:46:30,510
ובדרך כלל, אתה רוצה האלמנטים שלך
במקום לפני שאתה מפעיל כל קוד.

2220
01:46:30,510 --> 01:46:31,030
בסדר.

2221
01:46:31,030 --> 01:46:32,180
אנחנו צריכים להגיע לאייאקס.

2222
01:46:32,180 --> 01:46:33,110
אין לנו הרבה זמן.

2223
01:46:33,110 --> 01:46:35,170
אז יתרונות וחסרונות.

2224
01:46:35,170 --> 01:46:37,450
JavaScript היא לנסות יותר קל
לכתוב עם jQuery.

2225
01:46:37,450 --> 01:46:38,930
אבל jQuery היא סוג של איטי.

2226
01:46:38,930 --> 01:46:42,290
>> זה כמו PHP היא איטית יותר מאשר C,
כי זה יתפרש.

2227
01:46:42,290 --> 01:46:45,690
וjQuery היא קצת איטית יותר מאשר
JavaScript, כי זה עושה הרבה

2228
01:46:45,690 --> 01:46:46,630
דברים מתחת למכסת המנוע.

2229
01:46:46,630 --> 01:46:48,660
ולכן אם אתה משתמש jQuery, זה
רק קצת איטי יותר מאשר

2230
01:46:48,660 --> 01:46:51,630
JavaScript, למרות שזה
נותן לך אלגנטיות נחמדה.

2231
01:46:51,630 --> 01:46:53,970
ולבסוף, אייאקס.

2232
01:46:53,970 --> 01:46:59,170
עד כה עם אייאקס, שלא ראה אייאקס
במונחים של pset7 עדיין, כי

2233
01:46:59,170 --> 01:47:01,150
כאשר אתה עושה, אתה שולח
טופס לציטוט.

2234
01:47:01,150 --> 01:47:02,350
הוא טוען דף חדש.

2235
01:47:02,350 --> 01:47:04,440
כך שאתה מקבל הבזק הלבן הגדול הזה
בעמוד בזמן ש

2236
01:47:04,440 --> 01:47:06,820
דף נטען שני, נכון?

2237
01:47:06,820 --> 01:47:08,780
>> זה יהיה ממש נחמד אם אתה
לא היה לי את זה פלאש.

2238
01:47:08,780 --> 01:47:11,600
כמו פייסבוק, אם אתה פשוט לגלול ל
בתחתית, זה מוסיף תוכן חדש

2239
01:47:11,600 --> 01:47:13,490
מבלי לרענן את הדף כולו.

2240
01:47:13,490 --> 01:47:15,420
אז משהו כזה יהיה נחמד.

2241
01:47:15,420 --> 01:47:17,370
זה קוד JavaScript
בצד השמאל.

2242
01:47:17,370 --> 01:47:19,390
אתה מקבל מה שהוא חלק פנימי של קלט זה.

2243
01:47:19,390 --> 01:47:21,340
אתה מקבל את מידע על המניה מ-Yahoo!

2244
01:47:21,340 --> 01:47:27,440
ואז אתה עושה מחרוזת גדולה כי
אומר, אוקיי, זה המסר שאני רוצה

2245
01:47:27,440 --> 01:47:28,400
כדי להראות על המסך.

2246
01:47:28,400 --> 01:47:32,280
ואז אתה שם את זה בתוך הודעה
של חלק רכיב HTML שמקבל

2247
01:47:32,280 --> 01:47:33,970
מוצג על המסך.

2248
01:47:33,970 --> 01:47:35,540
>> אז זה כל מה שקורה כאן.

2249
01:47:35,540 --> 01:47:39,410
אז בעצם, בגלל זה הוא כל
JavaScript ואתה לא צריך לרוץ

2250
01:47:39,410 --> 01:47:42,980
עוד PHP, זה יהיה לוודא
שהדף לא מתרענן.

2251
01:47:42,980 --> 01:47:47,470
אז זה רק רעיון מופשט
שאני אומר כאן לעת עתה.

2252
01:47:47,470 --> 01:47:50,630
הרעיון המופשט הוא שאם אתה עושה את זה
כל ב-JavaScript, אין לך

2253
01:47:50,630 --> 01:47:52,330
דף רענון.

2254
01:47:52,330 --> 01:47:53,800
אבל איך שאתה בעצם עושה את זה?

2255
01:47:53,800 --> 01:47:56,230
>> טוב, בעצם, בואו נדבר על
בעיה עם זה ראשון.

2256
01:47:56,230 --> 01:47:59,340
בעיה היא ב-JavaScript,
ביצוע הוא סינכרוני.

2257
01:47:59,340 --> 01:48:02,000
אז אתה צריך לחכות לאחד
קו כדי לסיים לפני שאתה

2258
01:48:02,000 --> 01:48:03,370
לבצע את השורה הבאה.

2259
01:48:03,370 --> 01:48:06,130
ומה אם אני הולך ליאהו,
והשרתים שלהם הם איטיים מאוד, ו

2260
01:48:06,130 --> 01:48:08,790
לוקח להם שלוש שניות כדי
תחזיר לי את שמידע על מניות?

2261
01:48:08,790 --> 01:48:12,620
כאשר אני מכה קו המחיר, שאם
ביצוע הוא סינכרוני, כפי שהוא על ידי

2262
01:48:12,620 --> 01:48:15,390
ברירת מחדל, מה שזה רק הולך לעשות הוא
הדפדפן שלך הולך לדוכן ל

2263
01:48:15,390 --> 01:48:15,930
שלוש שניות.

2264
01:48:15,930 --> 01:48:18,900
ואתה לא הולך להיות מסוגל לעשות
כל דבר בזמן שהוא מקבל את הנתונים האלה.

2265
01:48:18,900 --> 01:48:20,010
זה הולך להיות קפוא.

2266
01:48:20,010 --> 01:48:20,800
>> וזה רע.

2267
01:48:20,800 --> 01:48:23,390
אתה לא רוצה שמשתמש
יש דף אינטרנט קפוא.

2268
01:48:23,390 --> 01:48:24,170
לתקן?

2269
01:48:24,170 --> 01:48:25,480
זה פשוט רע.

2270
01:48:25,480 --> 01:48:26,770
כולם מסכים?

2271
01:48:26,770 --> 01:48:29,270
אם אתה גולש בפייסבוק וזה
קופא ואתה לא יכול לעשות כלום, אתה

2272
01:48:29,270 --> 01:48:31,920
מתוסכל באמת.

2273
01:48:31,920 --> 01:48:34,960
אז הפתרון הוא שאנחנו עושים משהו
אסינכרוני במקום.

2274
01:48:34,960 --> 01:48:38,910
אז כל דבר אסינכרוני זה אומר
הוא, אני הולך לשאול את זה

2275
01:48:38,910 --> 01:48:40,280
כתובת אתר לכמה נתונים.

2276
01:48:40,280 --> 01:48:41,610
ואז אני הולך להמשיך.

2277
01:48:41,610 --> 01:48:45,330
אני רק הולך לשמור על ביצוע
מה קוד שהיה אחרי זה.

2278
01:48:45,330 --> 01:48:49,290
>> ולאחר מכן בכל פעם שהנתונים, כי הוא מוכן,
אז אני נעבד אותו.

2279
01:48:49,290 --> 01:48:50,540
זה כל מה שזה אומר.

2280
01:48:50,540 --> 01:48:52,795

2281
01:48:52,795 --> 01:48:56,710
>> קהל: אייאקס פשוט עושה
אסינכרוני קוד?

2282
01:48:56,710 --> 01:48:58,560
>> יוסף אונג: זה אסינכרוני
דרך של נתונים מקסימים.

2283
01:48:58,560 --> 01:49:01,230
אז הדבר הראשון שעל אייאקס
זה מאפשר לי לקבל נתונים

2284
01:49:01,230 --> 01:49:03,170
מאתר חיצוני.

2285
01:49:03,170 --> 01:49:07,045
והדבר השני הוא שהוא מוודא
כי הדף שלי לא דוכן בזמן שאני

2286
01:49:07,045 --> 01:49:07,970
הבאת הנתונים.

2287
01:49:07,970 --> 01:49:09,600
זה חלק אסינכרוני שלו.

2288
01:49:09,600 --> 01:49:13,040
כי זה הולך למקום אחר,
משום שאני אומר אני שומר קורה בזמן

2289
01:49:13,040 --> 01:49:14,900
זה להביא את הנתונים, כי
הופך אותו לאסינכרוני.

2290
01:49:14,900 --> 01:49:17,170
אני כל זמן המבצע.

2291
01:49:17,170 --> 01:49:18,960
>> אז לשמור אסינכרוני כי
רעיון במוחו.

2292
01:49:18,960 --> 01:49:22,010
ואני אראה לך מה
ההבדל הוא.

2293
01:49:22,010 --> 01:49:23,920
גרסת סינכרוני
הוא בצד השמאל.

2294
01:49:23,920 --> 01:49:26,240
גרסת אסינכרוני
הוא בצד ימין.

2295
01:49:26,240 --> 01:49:29,170
תסתכל על המספרים כדי לראות אילו
צעדים מתאימות למה

2296
01:49:29,170 --> 01:49:30,610
מבצע בכל שורה.

2297
01:49:30,610 --> 01:49:32,730
שם, ההתראה מופיעה ראשונה.

2298
01:49:32,730 --> 01:49:34,590
מכיוון מקבל מידע על המניה מ-Yahoo!

2299
01:49:34,590 --> 01:49:37,250
לוקח שלוש שניות, שהוא מזדקר
למשך שלוש שניות.

2300
01:49:37,250 --> 01:49:39,880
ואז היא מודיעה המחיר
לאחר שלוש שניות האלה.

2301
01:49:39,880 --> 01:49:43,690
>> אז עכשיו, שמראה התראה
עד באותו זמן -

2302
01:49:43,690 --> 01:49:44,610
שלוש שניות פנימה

2303
01:49:44,610 --> 01:49:47,670
ואז זה מתריע על ידי אחרי זה.

2304
01:49:47,670 --> 01:49:48,930
אז זה רק הולך צעד אחר צעד.

2305
01:49:48,930 --> 01:49:51,200
זה כמו מה שאתה חבר 'ה
היה מוכן לקבל, נכון?

2306
01:49:51,200 --> 01:49:54,170
עם ביצוע אסינכרוני,
אתה להתריע ראשון.

2307
01:49:54,170 --> 01:49:57,410
ואז אתה הולך לכתובת זו.

2308
01:49:57,410 --> 01:49:59,530
ואתה אומר, אני הולך
פשוט לבקש את הנתונים.

2309
01:49:59,530 --> 01:50:01,170
ולאחר מכן אני הולך
לעבד אותו מאוחר יותר.

2310
01:50:01,170 --> 01:50:04,230
אז זה מייד מבצע
השורה הבאה לאחר שאני עושה

2311
01:50:04,230 --> 01:50:05,710
בקשת אסינכרוני.

2312
01:50:05,710 --> 01:50:08,920
>> אז 0.001 שניות, אתה רואה היי ערני.

2313
01:50:08,920 --> 01:50:10,960
לבצע פונקציה ש, ביי התראה.

2314
01:50:10,960 --> 01:50:14,240
ובגלל שהבטחתי שאני
יהיה לעבד את הנתונים מאוחר יותר, מה

2315
01:50:14,240 --> 01:50:17,920
קורה הוא כאשר הנתונים שחוזרים
שלוש שניות מאוחר יותר, ואז אני רץ כי

2316
01:50:17,920 --> 01:50:21,380
פונקציה שיש לי שם.

2317
01:50:21,380 --> 01:50:21,870
כן?

2318
01:50:21,870 --> 01:50:25,750
>> קהל: האם אתה יכול לציין או
להבהיר מה פירוש אייאקס?

2319
01:50:25,750 --> 01:50:30,460
>> יוסף אונג: אז אייאקס הוא דרך שאם אני
צריכים נתונים כשאני על אתר ואני

2320
01:50:30,460 --> 01:50:34,690
לא אז רוצה לרענן את הדף,
אני משתמש בטכנולוגיה זו קרוי אייאקס.

2321
01:50:34,690 --> 01:50:40,630
כי למעשה רק אומר, לך תביא
נתונים מהאתר אחר.

2322
01:50:40,630 --> 01:50:43,724
ולעשות את זה בצורה שרק
לא לעכב דף האינטרנט שלי.

2323
01:50:43,724 --> 01:50:46,650
>> קהל: אז הוא שטבוע
חלק מJavaScript או jQuery?

2324
01:50:46,650 --> 01:50:50,590
>> יוסף אונג: אז מישהו כתב את דרך לעשות
זה ב-JavaScript לפני זמן רב.

2325
01:50:50,590 --> 01:50:52,050
בשלב מסוים, זה לא היה קיים.

2326
01:50:52,050 --> 01:50:56,630
ואז מישהו המציא את הטכניקה הזו
כדי לאפשר לאנשים לבקש את הנתונים

2327
01:50:56,630 --> 01:50:57,680
בדרך זו.

2328
01:50:57,680 --> 01:50:59,550
והם כתבו כמה דברים
כדי לעשות את זה בשבילך.

2329
01:50:59,550 --> 01:51:01,605
וjQuery רק נותן לך את זה
דרך מאוד נחמדה לעשות את זה

2330
01:51:01,605 --> 01:51:03,112
עם דולרים. לקבל פונקציה.

2331
01:51:03,112 --> 01:51:07,200

2332
01:51:07,200 --> 01:51:09,480
שאלות?

2333
01:51:09,480 --> 01:51:11,560
אני יכול לענות על שאלות לגבי
אייאקס אחר כך יותר מדי.

2334
01:51:11,560 --> 01:51:13,870
אני אהיה כאן.

2335
01:51:13,870 --> 01:51:16,390
>> אז זה בוא להביא נתונים ללא
לרענן את הדף.

2336
01:51:16,390 --> 01:51:18,200
וזה בואו איתנו לעשות את זה ב
דרך אסינכרוני כי

2337
01:51:18,200 --> 01:51:19,450
לא להקפיא את הדף.

2338
01:51:19,450 --> 01:51:22,680

2339
01:51:22,680 --> 01:51:27,310
ארוך מדי, לא קרא, אם כי
ההסבר היה ארוך מדי עבורך.

2340
01:51:27,310 --> 01:51:29,430
אז סוף סוף, בין אתרים
תקיפות Scripting.

2341
01:51:29,430 --> 01:51:30,910
ראינו את זה עם Zamyla.

2342
01:51:30,910 --> 01:51:34,285
אם מישהו באתר שלי יש את השם הזה,
אשר תג זה תסריט, ואני

2343
01:51:34,285 --> 01:51:38,280
יש לי כמה קוד בדף שלי שמדפיס
את השמות של אנשים ברציפות, או שיש לי

2344
01:51:38,280 --> 01:51:43,310
כמה קוד JavaScript שמכניס
השם הזה לדף,

2345
01:51:43,310 --> 01:51:45,680
מה HTML מקבל הפיק?

2346
01:51:45,680 --> 01:51:47,290
ובכן, אני מדפיס את תג ה-HTML.

2347
01:51:47,290 --> 01:51:48,390
אני מדפיס את כל תגים אלה.

2348
01:51:48,390 --> 01:51:50,740
>> אני מגיע לחלק שבו אני הדפסה
עם החברים שלי.

2349
01:51:50,740 --> 01:51:52,980
אני מדפיס את לורן.

2350
01:51:52,980 --> 01:51:54,200
זה להדפיס את המילוא.

2351
01:51:54,200 --> 01:51:56,810
ולאחר מכן את השם שלי באתר
הוא פוסט סקריפט

2352
01:51:56,810 --> 01:51:58,060
סטטוס בפייסבוק לא מחמיא.

2353
01:51:58,060 --> 01:52:00,740

2354
01:52:00,740 --> 01:52:04,330
כי אני מוכנס זה לתוך הדף
כי הוא נראה כמו JavaScript, כאשר

2355
01:52:04,330 --> 01:52:07,930
דף זה מקבל נשלח למשתמש,
הוא מקבל להורג כ- JavaScript.

2356
01:52:07,930 --> 01:52:10,800
ואז זה מה שאנחנו קוראים
התקפת Scripting בין אתרים.

2357
01:52:10,800 --> 01:52:14,570
מישהו מכניס מידע זדוני
מסד הנתונים שלך שיכול מתאימות ל

2358
01:52:14,570 --> 01:52:17,080
כמה מחרוזת או נוספות
חלק המחרוזת ב-JavaScript.

2359
01:52:17,080 --> 01:52:20,130
>> וכאשר הוא מקבל הדפיס כדי
דף באופן זה, אז מה

2360
01:52:20,130 --> 01:52:22,580
שקורה הוא שהקוד רע מקבל להורג
שאני לא מתכוון

2361
01:52:22,580 --> 01:52:25,110
לזה כדי לקבל להורג.

2362
01:52:25,110 --> 01:52:28,230
וזה כל מה שבין אתרים
התקפת scripting היא.

2363
01:52:28,230 --> 01:52:31,790
ועל הדרך אתה מקבל סביב
זה כמו Zamyla אמר.

2364
01:52:31,790 --> 01:52:34,340
אתה פשוט לעטוף את הדברים ב
תווים מיוחדים ב-HTML.

2365
01:52:34,340 --> 01:52:39,460
ותווים מיוחדים של HTML זה PHP
פונקציה שתמנע סוג זה

2366
01:52:39,460 --> 01:52:42,000
של דבר לא יקרו לך
אם יש לך זדוני

2367
01:52:42,000 --> 01:52:43,830
מחרוזת במסד הנתונים שלך.

2368
01:52:43,830 --> 01:52:47,650
זה פשוט בורח זה, כך שזה לא
מקבל מתפרש כ-HTML.

2369
01:52:47,650 --> 01:52:50,960
הוא מחליף את סוגריים הקטנים
עם מה שאנו מכנים גופים.

2370
01:52:50,960 --> 01:52:52,250
והלכנו על זה בהרצאה מדי.

2371
01:52:52,250 --> 01:52:55,800
אז אני חושב שאתם צריכים
הבנה טובה על זה.

2372
01:52:55,800 --> 01:52:57,420
שאלות?

2373
01:52:57,420 --> 01:52:57,820
כן.

2374
01:52:57,820 --> 01:53:00,860
>> קהל: אז איך היית
[לא ברור]?

2375
01:53:00,860 --> 01:53:01,555
>> יוסף אונג: אומר את זה שוב.

2376
01:53:01,555 --> 01:53:02,500
>> קהל: איך היית לפקח -

2377
01:53:02,500 --> 01:53:02,860
>> יוסף אונג: נכון.

2378
01:53:02,860 --> 01:53:06,080
אז יש לך משהו שאומר, כש
שלי להירשם, להקליד את השם שלי.

2379
01:53:06,080 --> 01:53:09,390
אני פשוט הקלד בשדה זה, השם שלי הוא
פייסבוק הודעה לא מחמיא stript

2380
01:53:09,390 --> 01:53:11,570
תג סקריפט קרוב מצב.

2381
01:53:11,570 --> 01:53:15,690
וזה רק יכניס אותו ל
מסד הנתונים, מישהו, כי אני לא יכול להגיד

2382
01:53:15,690 --> 01:53:18,260
בעולם אין לו שם
עם חץ שמאלה בזה או

2383
01:53:18,260 --> 01:53:19,036
מילת תסריט בו.

2384
01:53:19,036 --> 01:53:21,330
זה לא ממש הגיוני.

2385
01:53:21,330 --> 01:53:24,560
אז אני רק צריך לוודא שאני
לטהר את החומר לפני שאדפיס אותו

2386
01:53:24,560 --> 01:53:25,420
לדף.

2387
01:53:25,420 --> 01:53:27,140
>> קהל: אז כרטיסים מיוחדים HTML
מונע את תגים הסקריפט?

2388
01:53:27,140 --> 01:53:28,710
>> יוסף אונג: כן.

2389
01:53:28,710 --> 01:53:29,960
אז זה לא מונע את תגי הסקריפט.

2390
01:53:29,960 --> 01:53:32,320
זה פשוט מוודא כי
תגי סקריפט לא מקבלים

2391
01:53:32,320 --> 01:53:35,120
מתפרש כ-HTML או -

2392
01:53:35,120 --> 01:53:35,400
כן.

2393
01:53:35,400 --> 01:53:38,470
זה פשוט עולה כמו מה
זה בעצם.

2394
01:53:38,470 --> 01:53:39,220
בסדר.

2395
01:53:39,220 --> 01:53:40,930
אז זה היה ביקורת החידון.

2396
01:53:40,930 --> 01:53:41,830
מגניב.

2397
01:53:41,830 --> 01:53:45,088
>> [מחיאות כפות]