1
00:00:00,000 --> 00:00:02,610
[Powered by Google Translate] [סעיף 8 - יותר נוח]

2
00:00:02,610 --> 00:00:04,910
[רוב אודן - אוניברסיטת הרווארד]

3
00:00:04,910 --> 00:00:07,070
[זה CS50. - CS50.TV]

4
00:00:11,520 --> 00:00:14,160
>> הערות סעיף בשבוע הבא הולכות להיות די קצר,

5
00:00:14,160 --> 00:00:19,070
אז אני פשוט הולך להמשיך לדבר, אתם הולכים להמשיך לשאול שאלות,

6
00:00:19,070 --> 00:00:22,720
ואנו ננסה למלא את כל זמן שאפשר.

7
00:00:22,720 --> 00:00:31,950
הרבה אנשים חושבים שpset זה לא בהכרח קשה, אבל זה מאוד ארוך.

8
00:00:31,950 --> 00:00:37,070
Pset המפרט עצמו לוקח שעה לקרוא.

9
00:00:40,530 --> 00:00:45,730
אנחנו נותנים לך הרבה SQL שאתה עשוי להזדקק לשימוש.

10
00:00:45,730 --> 00:00:50,520
אנחנו ננחה אותך בהרבה ממנו, כך שזה לא צריך להיות כל כך רע.

11
00:00:50,520 --> 00:00:54,560
האם מישהו התחיל או סיים?

12
00:00:55,380 --> 00:00:59,710
זה pset האחרון. הו, אלוהים שלי.

13
00:00:59,710 --> 00:01:05,400
בדרך כלל יש JavaScript אחת אחרי זה, אבל דברי שינוי הלוח

14
00:01:05,400 --> 00:01:09,560
הופך את הכל 1 שבוע קצר יותר, ואנחנו כבר לא צריכים pset-JavaScript.

15
00:01:09,560 --> 00:01:12,310
אני לא יודע איך זה משפיע על היכולת של JavaScript הולך להופיע בבחינה

16
00:01:12,310 --> 00:01:15,510
או חידון 1.

17
00:01:15,510 --> 00:01:22,260
אני מתאר לעצמי שזה יהיה משהו כמו שאתה צריך לדעת את הדברים ברמה גבוהה על JavaScript,

18
00:01:22,260 --> 00:01:26,460
אבל אני בספק אם אנחנו רק רוצים לתת לך קוד JavaScript ישר

19
00:01:26,460 --> 00:01:28,720
מאז לא היה לך pset בזה.

20
00:01:28,720 --> 00:01:33,000
אבל זה יהיה חומר לבדיקת בוחן בשבוע הבא.

21
00:01:33,000 --> 00:01:36,320
>> קטע של שאלות.

22
00:01:36,320 --> 00:01:43,870
הרבה מהדברים האלה הוא קצת גרוע מנוסחים, אבל נדונונו למה.

23
00:01:43,870 --> 00:01:50,220
שלא כמו C, PHP היא שפה "דינמית מודפסת". מה זה אומר, אתם שואלים?

24
00:01:50,220 --> 00:01:53,830
ובכן, אומר שלום לכל, אלה לצוף char, int, ומילות מפתח אחרות אתה צריך להשתמש

25
00:01:53,830 --> 00:01:56,190
כאשר הגדרה משתנית ופונקציות בג

26
00:01:56,190 --> 00:02:00,420
ב-PHP, הסוג של משתנה נקבע על ידי הערך שהיא מחזיקה כיום.

27
00:02:00,420 --> 00:02:04,990
אז לפני שאנחנו מקלידים את הקוד הזה לקובץ שנקרא dynamic.php,

28
00:02:04,990 --> 00:02:12,670
PHP היא הקלדה באופן דינמי. זה נכון.

29
00:02:12,670 --> 00:02:17,590
אני לא מסכים עם עובדה שזה אומר שאנחנו אומרים שלום לchar, float, int,

30
00:02:17,590 --> 00:02:20,620
ומילות מפתח אחרות.

31
00:02:20,620 --> 00:02:25,510
ההבדל המדויק בין דינמי מוקלד והחלופי,

32
00:02:25,510 --> 00:02:32,010
אשר הקליד באופן סטטי, הוא שהוקלד באופן דינמי, כל הבדיקה וכל מיני הדברים מהסוג שלך

33
00:02:32,010 --> 00:02:37,350
קורה בזמן ריצה, ואילו הקליד סטטי זה קורה בזמן הידור.

34
00:02:37,350 --> 00:02:43,030
המילה סטטית באופן כללי נראה שהתכוונה לדברים זמן לקמפל.

35
00:02:43,030 --> 00:02:48,170
אני מניח שיש שימושים אחרים לזה, אבל ב-C כאשר אתה מצהיר על משתנה סטטי,

36
00:02:48,170 --> 00:02:52,650
האחסון מוקצה בזמן הידור.

37
00:02:52,650 --> 00:02:59,260
כאן, הקליד באופן דינאמי רק אומר כי -

38
00:02:59,260 --> 00:03:04,350
ב C אם אתה מנסה להוסיף מחרוזת ומספר שלם, כאשר אתה מהדר אותו,

39
00:03:04,350 --> 00:03:11,000
זה הולך להתלונן כי זה יגיד שאתה לא יכול להוסיף int ומצביע.

40
00:03:11,000 --> 00:03:14,710
זה פשוט לא פעולה חוקית.

41
00:03:14,710 --> 00:03:21,170
זה עוד דבר שאנחנו נגיע לשניים.

42
00:03:21,170 --> 00:03:24,860
אבל זה סוג של בדיקה, עובדה שהיא מתלוננת בזמן הידור,

43
00:03:24,860 --> 00:03:29,220
היא סוג בדיקה סטטית.

44
00:03:29,220 --> 00:03:35,220
יש שפות שבו אתה לא צריך לומר, לצוף char, int, וכל הדברים האלה,

45
00:03:35,220 --> 00:03:40,940
אבל השפה יכולה לספר מההקשר של הדבר איזה סוג שהוא אמור להיות,

46
00:03:40,940 --> 00:03:43,980
אבל זה עדיין הוקלד באופן סטטי.

47
00:03:43,980 --> 00:03:49,000
אז אם אתה לוקח 51, OCaml, שלעולם לא תצטרכו להשתמש בכל אחד מסוגים אלה,

48
00:03:49,000 --> 00:03:58,700
אבל זה עדיין בזמן ההידור אומר שאתה לא יכול לעשות את זה בגלל שאתה מערבב int ומחרוזת.

49
00:03:58,700 --> 00:04:05,650
דינאמי הקליד רק אומר שמתישהו במהלך זמן ריצה שאתה הולך לקבל את תלונה.

50
00:04:05,650 --> 00:04:13,430
אם גם אתם השתמשתם Java לפני, באופן כללי, כמעט כל סוג C-שפה

51
00:04:13,430 --> 00:04:20,070
הולך להיות מוקלד באופן סטטי, כך C, C + +, ג'אווה, כל אלה בדרך מוקלדת באופן סטטי.

52
00:04:20,070 --> 00:04:22,910
ב-Java כאשר אתה מהדר משהו ואתה אומר

53
00:04:22,910 --> 00:04:26,670
מחרוזת של שווה משהו חדש שאינו מחרוזת,

54
00:04:26,670 --> 00:04:28,950
זה הולך להתלונן כי סוגים אלה פשוט לא מתאימים.

55
00:04:28,950 --> 00:04:31,180
זה הולך להתלונן בזמן הידור.

56
00:04:31,180 --> 00:04:36,750
אבל יש לו גם קצת זמן דינמי דברים כמו אם אתה מנסה להטיל משהו

57
00:04:36,750 --> 00:04:40,500
לסוג זה יותר ספציפי מסוגו הנוכחי,

58
00:04:40,500 --> 00:04:45,610
אין שום דבר שהוא יכול לעשות בזמן הידור כדי לבדוק אם שחקנים שהוא הולך להצליח.

59
00:04:45,610 --> 00:04:51,130
ג'אווה יש גם איזה סוג בדיקה דינמית שברגע שזה יגיע לשורת קוד

60
00:04:51,130 --> 00:04:54,130
כשזה באמת ביצוע, זה הולך לעשות יצוק,

61
00:04:54,130 --> 00:04:56,260
לבדוק אם השחקנים שהיו בתוקף במקום הראשון,

62
00:04:56,260 --> 00:04:59,890
ואם זה לא הייתי, אז זה הולך להתלונן שיש לך סוג לא חוקי.

63
00:04:59,890 --> 00:05:03,200
סוג הבדיקה דינמי.

64
00:05:03,200 --> 00:05:07,010
הקלד את זה לקובץ שנקרא dynamic.php.

65
00:05:10,130 --> 00:05:12,380
Dynamic.php.

66
00:05:14,580 --> 00:05:17,190
אני לפתוח עיצוב.

67
00:05:18,750 --> 00:05:21,880
יש לנו משתנה, אנחנו מגדירים את זה ל7 מספר השלמים,

68
00:05:21,880 --> 00:05:27,930
אז אנחנו הולכים להדפיס אותו ו% s -

69
00:05:27,930 --> 00:05:32,830
הו, אנחנו מדפיסים את הסוג זה, אז gettype הולך לחזור לסוג של המשתנה.

70
00:05:32,830 --> 00:05:35,720
אנחנו פשוט מדפיסים את הסוג שוב ושוב.

71
00:05:35,720 --> 00:05:39,440
אנחנו רק php.dynamic.php.

72
00:05:39,440 --> 00:05:45,920
נראים שהיא משתנית ממספר שלם למחרוזת לוליאני כמו שאנחנו עוברים.

73
00:05:45,920 --> 00:05:54,590
ב C אין טיפוס נתונים בוליאני, אין נתונים מסוג המחרוזת.

74
00:05:54,590 --> 00:06:00,500
יש * char ובוליאני פשוט נוטה להיות int או char או משהו.

75
00:06:00,500 --> 00:06:05,690
ב PHP הסוגים הללו אכן קיימים, וזה אחד היתרונות הגדולים של PHP מעל C -

76
00:06:05,690 --> 00:06:13,290
פעולות שמחרוזת הן לאין ערוך יותר קלות מאשר ב-PHP C. הם פשוט עובדים.

77
00:06:13,290 --> 00:06:18,290
>> אז אנחנו חוזרים לכאן.

78
00:06:18,290 --> 00:06:21,260
רצנו dynamic.php.

79
00:06:21,260 --> 00:06:26,710
זה אומר למתורגמן PHP, נקרא PHP, כדי להריץ את קוד PHP בdynamic.php.

80
00:06:26,710 --> 00:06:30,250
אם יש לך שגיאות בקובץ, המתורגמן יגיד לך!

81
00:06:30,250 --> 00:06:39,110
המתורגמן, זה עוד הבדל גדול בין PHP ו-C

82
00:06:39,110 --> 00:06:48,200
ב C אתה צריך לקמפל משהו ואז אתה מפעיל אותו קובץ הידור.

83
00:06:48,200 --> 00:06:50,490
ב PHP אתה לא לקמפל שום דבר.

84
00:06:50,490 --> 00:06:57,200
אז מתורגמן PHP הוא בעצם רק קריאת שורה זו על ידי קו.

85
00:06:57,200 --> 00:07:02,900
הוא פוגע var = 7 אז זה מכה printf אז זה מכה var אז זה מכה printf וכן הלאה.

86
00:07:02,900 --> 00:07:10,910
יש שם קטע של עריכה שהיא עושה, והיא מעבירה למטמון את התוצאות

87
00:07:10,910 --> 00:07:15,510
כך שאם אתה מפעיל את התסריט מאוחר יותר אתה יכול לעשות קצת,

88
00:07:15,510 --> 00:07:19,280
אבל בעצם זה קו לפי קו של דבר.

89
00:07:19,280 --> 00:07:25,280
זה אומר שהרבה באופטימיזציות שאנחנו מקבלים ב-C,

90
00:07:25,280 --> 00:07:31,920
כמו קומפילציה, זה רק באופן כללי את המהדר יכול לעשות הרבה טריקים בשבילך.

91
00:07:31,920 --> 00:07:36,110
זה יכול לקחת את משתנים שאינם בשימוש, זה יכול לעשות את כל דברים אלו,

92
00:07:36,110 --> 00:07:38,660
הוא יכול לעשות רקורסיה זנב.

93
00:07:38,660 --> 00:07:42,550
ב PHP אתה לא הולך לקבל את היתרון ש

94
00:07:42,550 --> 00:07:45,690
כי זה פשוט הולך להתחיל בביצוע השורה אחרת שורה אחרת שורה,

95
00:07:45,690 --> 00:07:49,950
וזה לא ממש מכיר את הדברים האלה בקלות

96
00:07:49,950 --> 00:07:54,440
מאז זה לא עובר 1 גדול הידור על הדבר ולאחר מכן ביצוע;

97
00:07:54,440 --> 00:07:56,860
זה רק שורה אחר שורה.

98
00:08:00,730 --> 00:08:02,750
אז זה המתורגמן.

99
00:08:02,750 --> 00:08:06,840
>> בחזרה להקלדה הדינמית שלנו: די מגניב, הא?

100
00:08:06,840 --> 00:08:08,640
אתה בהחלט לא יכול לעשות את זה בשלישי!

101
00:08:08,640 --> 00:08:11,860
עכשיו, תראה אם ​​אתה יכול להבין את הסוג של כל אחד מהערכים הבאים.

102
00:08:11,860 --> 00:08:14,760
ראה זה לעיון.

103
00:08:14,760 --> 00:08:19,420
אז 3.50. איזה סוג אתה חושב שזה הולך להיות?

104
00:08:24,480 --> 00:08:26,370
להלן סוגים שיש לנו.

105
00:08:26,370 --> 00:08:30,430
יש לנו bools, מספרים שלמים, נקודות צפות, מחרוזות, מערכים, אובייקטים,

106
00:08:30,430 --> 00:08:38,370
ואז משאבים, שהוא סוג של מעורפל.

107
00:08:38,370 --> 00:08:41,010
אני חושב שיש דווקא דוגמה כאן.

108
00:08:41,010 --> 00:08:43,740
אז יש NULL. NULL הוא סוג מיוחד.

109
00:08:43,740 --> 00:08:47,140
בניגוד לג בי NULL הוא רק מצביע עם כתובה 0,

110
00:08:47,140 --> 00:08:54,930
ב-PHP, NULL הוא הסוג בפני עצמו שבו הדבר התקף רק מסוג זה הוא NULL.

111
00:08:57,560 --> 00:09:00,670
זה הרבה יותר שימושי לבדיקת שגיאות.

112
00:09:00,670 --> 00:09:04,310
ב C שבו הייתי הנושא שבו אם אתה חוזר NULL,

113
00:09:04,310 --> 00:09:08,660
זה אומר שאתה חוזר מצביע NULL או באמצעות NULL כדי לסמן שגיאה

114
00:09:08,660 --> 00:09:12,380
או כל הבלבול שהיו לנו בשלב מסוים.

115
00:09:12,380 --> 00:09:18,440
כאן, חוזר NULL בדרך כלל אומר שגיאה.

116
00:09:20,860 --> 00:09:27,300
הרבה דברים גם בתמורת שווא לטעויות.

117
00:09:27,300 --> 00:09:33,140
אבל הנקודה היא סוג NULL, הדבר היחיד מסוג NULL הוא NULL.

118
00:09:33,140 --> 00:09:40,090
אז איתות היא כמו שאתה יכול להגדיר כמה פונקציות אנונימיות.

119
00:09:40,090 --> 00:09:46,420
אתה לא צריך לתת לפונקציה שם, אבל אתה לא צריך להתמודד עם זה כאן.

120
00:09:46,420 --> 00:09:53,940
כאשר מסתכלים על הסוגים שהם מצפים מאתנו יודעים,

121
00:09:53,940 --> 00:09:59,000
מה אתה חושב על הסוג של 3.50 הוא? >> [תלמיד] תהלוכה.

122
00:09:59,000 --> 00:10:00,370
כן.

123
00:10:00,370 --> 00:10:06,290
אז כאן, מה אתה חושב על הסוג זה? >> [תלמיד] מערך.

124
00:10:06,290 --> 00:10:09,890
כן. הראשון היה מצוף, השני הוא מערך.

125
00:10:09,890 --> 00:10:14,500
שימו לב שהמערך הזה הוא לא כמו מערך C

126
00:10:14,500 --> 00:10:19,610
שם יש לך מדד 0 יש ערך, 1 במדד יש ערך כלשהו.

127
00:10:19,610 --> 00:10:26,320
הנה את המדדים, B ו-C והערכים הם 1, 2, ו 3.

128
00:10:26,320 --> 00:10:33,980
ב PHP אין הבדל בין מערך אסוציאטיבי ורק מערך רגיל

129
00:10:33,980 --> 00:10:36,740
כפי שהיית חושב על זה בג

130
00:10:36,740 --> 00:10:43,040
יש רק את זה, ומתחת למכסת מנוע מערך רגיל הוא פשוט מערך אסוציאטיבי

131
00:10:43,040 --> 00:10:50,000
בי 0 מפות לשווי חלק אותו אופן מפות לשווי מסוים.

132
00:10:50,000 --> 00:11:00,410
מסיבה זו, PHP יכול להיות די רע לדברים ממש מהר קוד / השוואות

133
00:11:00,410 --> 00:11:07,930
מאז בC כאשר אתה משתמש מערך אתה יודע שגישת חברה היא זמן קבוע.

134
00:11:07,930 --> 00:11:11,860
ב PHP גישת חבר הוא מי יודע כמה זמן?

135
00:11:11,860 --> 00:11:18,970
זה כנראה קבוע אם זה hashes בצורה נכונה.

136
00:11:18,970 --> 00:11:21,620
מי יודע מה באמת עושה מתחת למכסת המנוע?

137
00:11:21,620 --> 00:11:25,600
אתה באמת צריך להסתכל על היישום כדי לראות איך זה הולך להתמודד עם זה.

138
00:11:25,600 --> 00:11:28,550
אז fopen.

139
00:11:28,550 --> 00:11:36,420
אני חושב שכאן בואו fopen מדריך פשוט PHP להסתכל על סוג התמורה.

140
00:11:36,420 --> 00:11:41,260
אנו רואים כאן שאתה יכול להסתכל למעלה כמעט כל פונקציה בPHP הידני

141
00:11:41,260 --> 00:11:47,540
וזה סוג של דף האיש של PHP.

142
00:11:47,540 --> 00:11:51,060
סוג ההחזרה הולך להיות משאב.

143
00:11:51,060 --> 00:11:56,050
בגלל זה אני נראה את זה, כי אנחנו לא באמת להגדיר משאבים.

144
00:11:56,050 --> 00:12:04,110
הרעיון של משאב, בC אתה סוג של לי * קובץ או כל דבר אחר!

145
00:12:04,110 --> 00:12:07,200
ב-PHP הוא המשאב * הקובץ שלך.

146
00:12:07,200 --> 00:12:10,360
זה מה שאתה הולך להיות קריאה, זה מה שאתה הולך לכתוב אל.

147
00:12:10,360 --> 00:12:20,710
זה בדרך כלל חיצוני, כך שזה משאב שיכול למשוך את דברים ומלזרוק דברים.

148
00:12:20,710 --> 00:12:26,520
ולבסוף, מה הוא הסוג של NULL? >> [תלמיד] NULL.

149
00:12:26,520 --> 00:12:30,650
כן. אז הדבר היחיד שהוא NULL הוא NULL.

150
00:12:30,650 --> 00:12:33,480
NULL הוא NULL.

151
00:12:35,490 --> 00:12:41,170
>> תכונה אחת של מערכת הסוג של PHP (לטוב ולרע) היא יכולתו לתמרן בין סוגים.

152
00:12:41,170 --> 00:12:44,390
כשאתה כותב שורת קוד PHP שמשלב ערכים מסוגים שונים,

153
00:12:44,390 --> 00:12:46,670
PHP ינסה לעשות את הדבר הנכון.

154
00:12:46,670 --> 00:12:48,920
נסה את כל אחת מהשורות הבאות של קוד PHP. מה יודפס?

155
00:12:48,920 --> 00:12:51,000
האם זה מה שציפית? למה או למה לא?

156
00:12:51,000 --> 00:12:58,600
עובדה זו על PHP היא מה שעושה את מה שאנו מכנים בחולשה מוקלדת.

157
00:12:58,600 --> 00:13:04,610
הקליד בחולשה והחזקה הקליד,

158
00:13:04,610 --> 00:13:06,840
ישנם שימושים שונים למונחים אלה,

159
00:13:06,840 --> 00:13:12,020
אבל רוב האנשים משתמשים הקליד בחולשה והחזקה הקליד לאומרים דברים מהסוג הזה

160
00:13:12,020 --> 00:13:15,920
שם ("1" + 2); שעובד.

161
00:13:15,920 --> 00:13:18,290
ב C זה לא יעבוד.

162
00:13:18,290 --> 00:13:22,490
אתה יכול לדמיין את זה לא עובד.

163
00:13:22,490 --> 00:13:29,200
הרבה אנשים מבלבל את ההקלדה דינמית והקלדה חלשה והקלדת סטטי והקלדה חזקה.

164
00:13:29,200 --> 00:13:34,050
פייטון הוא דוגמה נוספת לשפה ההקלידה באופן דינמי.

165
00:13:34,050 --> 00:13:41,770
אתה יכול לזרוק סביב סוגים במשתנים וזה הולך לקבוע בזמן הריצה

166
00:13:41,770 --> 00:13:44,680
כל checkings שגיאה.

167
00:13:44,680 --> 00:13:50,740
בפייתון זה הולך לבצע את זה וזה יהיה לראות ("1" + 2);

168
00:13:50,740 --> 00:13:55,920
וזה ייכשל, כי זה אומר שאתה לא יכול להוסיף מחרוזת ומספר שלם.

169
00:13:55,920 --> 00:14:00,860
ב-PHP, שהוא בדיוק כמו דינמי הקליד, זה לא להיכשל.

170
00:14:00,860 --> 00:14:04,220
הקלדה חלשה קשורה לעובדה שהיא עושה דברים בסוגים

171
00:14:04,220 --> 00:14:07,800
שלא באמת הגיוני בהכרח.

172
00:14:07,800 --> 00:14:17,420
אז ("1" + 2); אני יכול לדמיין שלהיות מחרוזת 12, אני יכול לדמיין אותו להיות מחרוזת 3,

173
00:14:17,420 --> 00:14:20,710
אני יכול לדמיין אותו להיות מספר השלם 3.

174
00:14:20,710 --> 00:14:24,530
זה לא בהכרח מוגדר היטב, ואנחנו כנראה הולכים לראות כאן

175
00:14:24,530 --> 00:14:29,140
כי כאשר אנו להדפיס ("1" + 2); זה כנראה הולך להיות בסופו שונה

176
00:14:29,140 --> 00:14:32,320
מהדפסה (1 + "2").

177
00:14:32,320 --> 00:14:39,700
וזה נוטה להיות, לדעתי, ליותר גרוע.

178
00:14:39,700 --> 00:14:44,240
כאן אנו יכולים לנסות אלה.

179
00:14:44,240 --> 00:14:48,740
טריק קטן נוסף על PHP הוא שאתה לא צריך ממש לכתוב את הקובץ.

180
00:14:48,740 --> 00:14:52,790
אכן יש להפעיל מצב פקודה זו.

181
00:14:52,790 --> 00:14:57,710
אז php-r, אז אנחנו יכולים לזרוק את הפקודה כאן:

182
00:14:57,710 --> 00:15:06,610
"הדפסה ('1 '+ 2);" ואני אזרוק את קו חדש.

183
00:15:19,550 --> 00:15:23,970
זה מודפס 3.

184
00:15:31,100 --> 00:15:35,330
זה נראה כאילו זה מדפיס 3 וזה 3 מספר השלמים.

185
00:15:35,330 --> 00:15:38,420
אז עכשיו בואו ננסה את הדרך ההפוכה:

186
00:15:38,420 --> 00:15:42,970
"הדפסה (1 + '2 ');

187
00:15:45,560 --> 00:15:50,490
אנחנו מקבלים 3, וזה גם הולך להיות 3 מספר שלם? אני באמת אין לי מושג.

188
00:15:50,490 --> 00:15:54,030
זה נראה כמו שעולה בקנה אחד.

189
00:15:54,030 --> 00:15:59,550
לעולם אין לכך שום סיכוי להיות 12 מחרוזת או משהו כזה

190
00:15:59,550 --> 00:16:08,080
כי PHP, שלא כמו JavaScript ו-Java גם

191
00:16:08,080 --> 00:16:11,670
יש מפעיל נפרד לשרשור.

192
00:16:11,670 --> 00:16:14,930
שרשור ב PHP הוא נקודה.

193
00:16:14,930 --> 00:16:22,950
אז הדפסה (1 '2 '.); הוא הולך לתת לנו 12.

194
00:16:25,790 --> 00:16:32,420
זה נוטה לגרום לבלבול שבו אנשים מנסים לעשות משהו כמו str = +

195
00:16:32,420 --> 00:16:37,840
איזה דבר אחר שהם רוצים להוסיף על לסוף המחרוזת שלהם, וזה הולך להיכשל.

196
00:16:37,840 --> 00:16:40,770
אתה צריך לעשות את str. =

197
00:16:42,000 --> 00:16:46,240
אז אל תשכחו בשרשור PHP הוא נקודה.

198
00:16:46,240 --> 00:16:52,100
דברים נוספים שכדאי לנסות: להדפיס ("CS" + 50);

199
00:16:55,750 --> 00:17:03,610
אמרתי לך שאין שום תקווה לכך וכתוצאה מכך CS50

200
00:17:03,610 --> 00:17:06,119
מאז השרשור הוא לא +.

201
00:17:06,119 --> 00:17:08,440
מה אתה חושב שזה הולך להיות בסופו?

202
00:17:10,359 --> 00:17:13,460
אני באמת יש לי שום מושג.

203
00:17:14,250 --> 00:17:16,460
זה נראה כאילו זה רק 50.

204
00:17:16,460 --> 00:17:21,490
היא רואה את המחרוזת, ואני בטוחה שאם אנחנו שמים 123CS -

205
00:17:21,490 --> 00:17:29,640
היא רואה את המחרוזת הראשונה, היא מנסה לקרוא ממנו שלמה או מספר ממנו.

206
00:17:29,640 --> 00:17:31,710
במקרה זה רואה 123CS.

207
00:17:31,710 --> 00:17:35,190
"זה לא הגיוני כמספר שלם, אז אני פשוט הולך לחשוב על 123."

208
00:17:35,190 --> 00:17:38,580
אז 123 + 50 הולכים להיות 173.

209
00:17:38,580 --> 00:17:40,740
והנה זה מתחיל לקרוא את זה כמספר שלם.

210
00:17:40,740 --> 00:17:45,690
הוא לא רואה משהו, כך שרק מתייחס אליו כ 0. אז 0 + 50 הולכים להיות 50.

211
00:17:45,690 --> 00:17:51,600
זה אני מניח שהוא הולך לעשות משהו דומה.

212
00:17:51,600 --> 00:17:54,310
אני חושב 99.

213
00:17:54,310 --> 00:17:57,580
כן, כי זה הולך לקחת 1 -

214
00:18:12,880 --> 00:18:15,730
אז 99.

215
00:18:15,730 --> 00:18:21,970
כאן (10/7), אם זה היה C, מה שיחזור?

216
00:18:23,700 --> 00:18:29,630
[תלמיד] 1. >> כן, זה יהיה 1 כי 10/7 הוא חלוקת 2 מספרים שלמים.

217
00:18:29,630 --> 00:18:32,910
שלם מחולק במספר שלם הולך להחזיר מספר שלם.

218
00:18:32,910 --> 00:18:37,750
זה לא יכול לחזור כל 1 נקודה שיהיה, אז זה רק הולך לחזור 1.

219
00:18:37,750 --> 00:18:46,120
הנה הדפסה (10/7); זה הולך בעצם לפרש את זה.

220
00:18:46,120 --> 00:18:53,760
וזה אומר שאם אתה באמת רוצה לעשות את העיגול ודברים שלמים ככה,

221
00:18:53,760 --> 00:18:59,950
אתה צריך לעשות הדפסה (רצפה (10/7));

222
00:18:59,950 --> 00:19:08,460
ב C זה כנראה מוזר, כי אתה יכול לסמוך על עיצור שלם באופן קבוע,

223
00:19:08,460 --> 00:19:12,260
אבל ב-PHP אתה לא יכול כי זה יהיה באופן אוטומטי להפוך אותו למספר עשרוני.

224
00:19:13,430 --> 00:19:17,610
ולאחר מכן (7 + נכון); מה אתה חושב שזה הולך להיות?

225
00:19:18,550 --> 00:19:23,640
אני מנחש 8 אם זה הולך לפרש כנכון 1.

226
00:19:23,640 --> 00:19:25,740
זה נראה כמו שזה 8.

227
00:19:25,740 --> 00:19:31,710
>> אז כל מה שעשינו ב 10 הדקות האחרונות אתה ממש לא צריך לעשות.

228
00:19:31,710 --> 00:19:39,870
אתה תראה קוד שעושה את זה.

229
00:19:39,870 --> 00:19:42,700
זה לא חייב להיות כך פשוט כמו שזה.

230
00:19:42,700 --> 00:19:47,240
יכול להיות לך 2 משתנה, ומשתנה 1 קורה להיות מחרוזת

231
00:19:47,240 --> 00:19:51,310
ומשתנה האחרים קורה להיות int, ואז אתה מוסיף המשתנים הללו יחד.

232
00:19:51,310 --> 00:20:00,120
מאז PHP יוקלד באופן דינמי וזה לא יעשה שום בדיקת סוג בשבילך

233
00:20:00,120 --> 00:20:03,640
ומכיוון שהקליד בחולשה ומאז זה יהיה באופן אוטומטי רק לזרוק הדברים האלה יחד

234
00:20:03,640 --> 00:20:11,490
והכל יהיה פשוט לעבוד, זה קשה אפילו לדעת שמשתנה זה חייב להיות מחרוזת עכשיו,

235
00:20:11,490 --> 00:20:14,930
אז אני לא צריך להוסיף אותו למשתנה זה, שהוא שלם.

236
00:20:18,780 --> 00:20:24,560
התרגול הטוב ביותר הוא אם למשתנה היא מחרוזת, לשמור אותו כמחרוזת לנצח.

237
00:20:24,560 --> 00:20:26,980
אם משתנה הוא int, לשמור אותו כint לנצח.

238
00:20:26,980 --> 00:20:30,770
אם אתה רוצה להתמודד עם מספרים שלמים ומחרוזות,

239
00:20:30,770 --> 00:20:36,970
אתה יכול להשתמש varsint - זה JavaScript.

240
00:20:36,970 --> 00:20:42,520
Intval. אני עושה את זה כל הזמן. PHP ו-JavaScript אני מערבב את הכל.

241
00:20:42,520 --> 00:20:47,600
אז intval הולך להחזיר את הערך השלם של משתנה.

242
00:20:47,600 --> 00:20:56,550
אם אנחנו עוברים ב" הדפסה (intval (123 ')); אתה מקבל 123.

243
00:21:06,820 --> 00:21:15,850
Intval עצמו היא לא הולך לעשות את הבדיקה עבורנו שזה אך ורק מספר שלם.

244
00:21:15,850 --> 00:21:20,460
המדריך של PHP, יש כל כך הרבה פונקציות פשוט זמינות,

245
00:21:20,460 --> 00:21:26,560
אז הנה מה שאני חושב שהייתי משתמש הוא is_numeric הראשון.

246
00:21:26,560 --> 00:21:32,590
אני מנחש שחזרתי שווא.

247
00:21:32,590 --> 00:21:35,780
זה עוד דבר שצריך לעבור עליו ===.

248
00:21:37,850 --> 00:21:44,020
אז is_numeric ('123df '), לא היית חושב על זה כis_numeric.

249
00:21:44,020 --> 00:21:46,720
ב C היית צריך לחזר על כל התווים

250
00:21:46,720 --> 00:21:50,410
ולבדוק אם כל תו הוא ספרה או משהו כזה.

251
00:21:50,410 --> 00:21:53,850
הנה is_numeric הולך לעשות את זה בשבילנו,

252
00:21:53,850 --> 00:21:56,520
וזה חוזר שווא.

253
00:21:56,520 --> 00:22:02,120
לכן, כאשר הדפסתי את אותו, אותו הדפיס דבר, אז הנה אני משווה אותו כדי לראות,

254
00:22:02,120 --> 00:22:05,490
לא קורה לך להיות כוזב? ואז עכשיו זה הדפסת 1.

255
00:22:05,490 --> 00:22:10,060
כנראה שזה מדפיס 1 כאמיתי במקום להדפיס נכון כנכון.

256
00:22:10,060 --> 00:22:15,790
אני תוהה אם אני עושה print_r. לא, זה עדיין עושה 1.

257
00:22:15,790 --> 00:22:26,760
>> חוזר ל===, == עדיין קיים,

258
00:22:26,760 --> 00:22:32,260
ואם אתה מדבר עם טומי הוא יגיד == הוא בסדר גמור.

259
00:22:32,260 --> 00:22:37,700
אני הולך להגיד את זה == הוא נורא ואתה לא צריך להשתמש ==.

260
00:22:37,700 --> 00:22:44,870
ההבדל הוא ש== משווה דברים

261
00:22:44,870 --> 00:22:48,450
איפה זה יכול להיות נכון גם אם הם לא מאותו הסוג,

262
00:22:48,450 --> 00:22:53,810
בעוד === משווה דברים וראשונים שהיא בודקת האם הם מאותו הסוג?

263
00:22:53,810 --> 00:22:58,010
כן. אוקיי, עכשיו אני הולך לראות אם הם באמת להשוות להיות שווים.

264
00:22:58,010 --> 00:23:08,890
אתה מקבל דברים מוזרים כמו 10 שווים - בואו תראו מה זה אומר.

265
00:23:08,890 --> 00:23:15,570
אז ('10 '== '1 E1');

266
00:23:15,570 --> 00:23:17,980
זה מחזיר את האמת.

267
00:23:17,980 --> 00:23:21,420
למישהו יש ניחושים למה זה מחזיר אמיתי?

268
00:23:25,180 --> 00:23:27,120
זה לא רק על זה. אולי זה רמז.

269
00:23:27,120 --> 00:23:33,170
אבל אם אני משנה את זה לו - לתקן את זה! אני שומר את השימוש במרכאות כפולות.

270
00:23:33,170 --> 00:23:38,780
הסיבה למרכאות הכפולות הם צועקות עליי בגלל שאני שמתי את זה במרכאות כפולות.

271
00:23:38,780 --> 00:23:43,850
כדי שאוכל להימלט מהמרכאות הכפולות בפה, אבל ציטוטים בודדים לעשות את זה יותר קל.

272
00:23:43,850 --> 00:23:49,120
אז ('10 '== '1 F1'); לא מדפיס אמיתי. ('10 '== '1 E1'); מדפיס אמיתי.

273
00:23:49,120 --> 00:23:56,330
[תלמיד] האם זה hex? >> זה לא קללה, אבל זה קרוב שזה כמו -

274
00:23:56,330 --> 00:24:01,060
, סימון מדעי 1e1.

275
00:24:01,060 --> 00:24:07,950
היא מכירה 1e1 כמו 1 * 10 ^ 1 או משהו כזה.

276
00:24:07,950 --> 00:24:11,510
אלה הם מספרים שלמים שווים.

277
00:24:11,510 --> 00:24:15,930
אם אנחנו עושים === אז זה הולך להיות כוזב.

278
00:24:15,930 --> 00:24:28,490
אני באמת אין לי מושג אם נעשה == מה (10 ו'10abc ');? בסדר. אז זה נכון.

279
00:24:28,490 --> 00:24:35,940
אז בדיוק כמו כאשר אתה עשית (10 + '10abc '), וזה יהיה 20,

280
00:24:35,940 --> 00:24:38,800
כאן (10 == '10abc '); הוא נכון.

281
00:24:38,800 --> 00:24:45,350
גרוע מכך הם דברים כמו (כוזב == NULL); נכון

282
00:24:45,350 --> 00:24:52,210
או (false == 0); נכון, (שקר == []);

283
00:24:52,210 --> 00:25:00,970
יש מקרים מוזרים של - זה אחד המקרים המוזרים האלה.

284
00:25:00,970 --> 00:25:08,110
שים לב ש( false == []); הוא נכון.

285
00:25:08,110 --> 00:25:11,950
('0 '== False); הוא נכון.

286
00:25:11,950 --> 00:25:16,090
('0 '== []); הוא שקרי.

287
00:25:16,090 --> 00:25:19,090
אז == הוא בשום אופן לא יוצא.

288
00:25:19,090 --> 00:25:26,830
יכול להיות שווה ל ב ויכול להיות שווה לג,

289
00:25:26,830 --> 00:25:29,340
אבל ב לא יכול להיות שווה לג.

290
00:25:29,340 --> 00:25:35,580
זה תועבה אליי, ואתה תמיד צריך להשתמש ===.

291
00:25:35,580 --> 00:25:38,590
[תלמיד] אנחנו יכולים לעשות! == גם? >> [אודן] כן.

292
00:25:38,590 --> 00:25:44,600
השווה יהיה! = ו! ==.

293
00:25:44,600 --> 00:25:48,230
זה הוא למעשה גדל בpset המפרט

294
00:25:48,230 --> 00:25:52,000
שבו הרבה פונקציות תמורה -

295
00:25:52,000 --> 00:25:53,890
המדריך של PHP הוא טוב לגבי זה.

296
00:25:53,890 --> 00:25:59,140
זה מכניס בקופסה אדומה גדולה ", זה יחזיר כוזב אם יש שגיאה."

297
00:25:59,140 --> 00:26:03,940
אבל 0 חוזרים הוא דבר הגיוני לחלוטין כדי לחזור.

298
00:26:03,940 --> 00:26:08,250
תחשוב על כל פונקציה שצפויה להחזיר מספר שלם.

299
00:26:11,250 --> 00:26:17,880
נניח שהפונקציה זו אמורה לספור את מספר השורות בקובץ או משהו.

300
00:26:17,880 --> 00:26:23,490
בנסיבות רגילות, שאתה עובר בפונקציה זו קובץ

301
00:26:23,490 --> 00:26:27,120
וזה הולך להחזיר מספר שלם שמייצג את מספר השורות.

302
00:26:27,120 --> 00:26:30,820
אז 0 הם מספר הגיוני לחלוטין אם הקובץ הוא פשוט ריק.

303
00:26:30,820 --> 00:26:36,810
אבל מה אם אתה עובר אותו קובץ לא חוקי והתפקוד קורה לתמורת שווא

304
00:26:36,810 --> 00:26:38,860
אם אתה עובר אותו קובץ לא חוקי?

305
00:26:38,860 --> 00:26:46,500
אם אתה פשוט עושה == אתה לא מבדיל בין מקרה קובץ לא חוקי וקובץ ריק.

306
00:26:48,870 --> 00:26:51,350
השתמש תמיד ב===.

307
00:26:55,690 --> 00:26:58,000
זה כל אלה.

308
00:26:58,000 --> 00:27:01,660
>> ב-PHP, סוג המערך הוא שונה ממה שאתה רגיל לראות בג

309
00:27:01,660 --> 00:27:06,650
ואכן, ייתכן שכבר שמת לב זה לעיל, כשראית שזה מסוג המערך.

310
00:27:06,650 --> 00:27:15,640
התחביר הוא הסוגר חדש כמו של PHP 5.4, המהווה את הגרסה החדשה ביותר של PHP.

311
00:27:15,640 --> 00:27:36,960
לפני זה תמיד היית צריך לכתוב מערך ('' -> 1, 'ב' -> 2.

312
00:27:36,960 --> 00:27:41,160
זה היה הבנאי למערך.

313
00:27:41,160 --> 00:27:45,950
עכשיו סוף סוף הגיע PHP בסביבה כדי התחביר הנחמד של סוגריים מרובעים בלבד,

314
00:27:45,950 --> 00:27:50,900
שהוא פשוט כל כך הרבה יותר טוב ממערך.

315
00:27:50,900 --> 00:27:54,480
אבל בהתחשב PHP 5.4 היא הגרסה החדשה ביותר,

316
00:27:54,480 --> 00:27:59,090
ייתכן שתיתקל במקומות שאפילו אין לי PHP 5.3.

317
00:27:59,090 --> 00:28:08,220
במהלך הקיץ נתקלנו בנושא הזה שבו PHP 5.3 היו מה שהיינו לנו על המכשיר,

318
00:28:08,220 --> 00:28:14,480
אבל השרת שנפרסנו בכל הספר בכיתה שלנו ולשלוח וכל זה כדי

319
00:28:14,480 --> 00:28:16,750
היה PHP 5.4.

320
00:28:16,750 --> 00:28:23,060
בלי לדעת זאת, פתח ב5.3, דחף ל -5.4,

321
00:28:23,060 --> 00:28:25,660
ועכשיו כל איש פתאומי של הקוד שלנו עובד

322
00:28:25,660 --> 00:28:28,680
כי יש במקרה היה שינויים בין 5.3 ל 5.4

323
00:28:28,680 --> 00:28:31,030
שאין תאימות לאחור,

324
00:28:31,030 --> 00:28:35,770
ואנחנו צריכים ללכת ולתקן את כל הדברים שלנו שלא עובדים עבור PHP 5.4.

325
00:28:39,210 --> 00:28:42,320
לכיתה זו, שכן המכשיר עושה לי PHP 5.4,

326
00:28:42,320 --> 00:28:45,490
זה בסדר גמור להשתמש בסוגריים מרובעים.

327
00:28:47,240 --> 00:28:50,440
אבל אם אתה מחפש את הדברים ברחבי האינטרנט,

328
00:28:50,440 --> 00:28:54,880
אם אתה מחפש קצת סוג של חומר מערך, סביר להניח שאתה הולך לראות

329
00:28:54,880 --> 00:29:02,020
הכישוף את תחביר בנאי מערך מאז שהיה פה מאז PHP נולד

330
00:29:02,020 --> 00:29:07,340
ותחביר סוגר מרובע בסביבה כבר כמה את החודשים האחרונים

331
00:29:07,340 --> 00:29:10,020
או בכל פעם שבאו סביב 5.4.

332
00:29:10,020 --> 00:29:12,710
זה איך אתה מדד.

333
00:29:12,710 --> 00:29:30,610
בדיוק כמו ב-C איך היית מדד בסוגריים מרובעים כמו מערך $ [0], $ מערך [1], מערך $ [2],

334
00:29:30,610 --> 00:29:36,320
יצירת אינדקס באותו אופן, אם במקרה יש לך המדדים להיות מחרוזות.

335
00:29:36,320 --> 00:29:40,440
אז מערך $ [''] ו$ מערך ['ב'].

336
00:29:40,440 --> 00:29:47,410
מערך $ [ב]. למה שזה יהיה בסדר?

337
00:29:52,490 --> 00:29:59,870
זה כנראה יפיק אזהרה אך עדיין עובד. PHP נוטה לעשות את זה.

338
00:29:59,870 --> 00:30:04,890
הוא נוטה פשוט, "אני הולך להזהיר אותך על זה, אבל אני רק הולך להמשיך

339
00:30:04,890 --> 00:30:07,550
"ולעשות כל מה שאני יכול."

340
00:30:07,550 --> 00:30:11,500
זה כנראה יהיה לתרגם את זה למחרוזת,

341
00:30:11,500 --> 00:30:15,000
אבל זה אפשרי, כי בשלב מסוים בעבר מישהו אמר

342
00:30:15,000 --> 00:30:20,180
להגדיר ב להיות "שלום העולם".

343
00:30:20,180 --> 00:30:28,740
אז עכשיו ב יכול להיות קבוע מערך ו$ [b] יהיה למעשה עושה "שלום העולם".

344
00:30:28,740 --> 00:30:32,380
אני חושב שבשלב זה, או לפחות הגדרות PHP שלנו,

345
00:30:32,380 --> 00:30:37,870
אם תנסה אינדקס לתוך מערך ומפתח שאינו קיים, הוא ייכשל.

346
00:30:37,870 --> 00:30:40,150
אני לא חושב שזה רק יזהיר אותך.

347
00:30:40,150 --> 00:30:44,560
או לפחות אתה יכול להגדיר אותו כך שהוא לא רק מזהיר אותך, זה פשוט ישר למעלה נכשל.

348
00:30:44,560 --> 00:30:49,290
>> הדרך בה אתה בודק אם באמת יש מדד כזה היא isset.

349
00:30:49,290 --> 00:30:54,690
אז isset ($ מערך ['שלום העולם']) יחזיר שקר.

350
00:30:54,690 --> 00:30:59,160
isset (מערך $ ['ב']) יחזיר אמת.

351
00:31:06,830 --> 00:31:09,880
אתה יכול לערבב תחביר אלה.

352
00:31:15,060 --> 00:31:22,440
אני די בטוח שזה מה שמערך סופו של דבר הוא - אנחנו יכולים לבדוק את זה.

353
00:31:43,290 --> 00:31:45,700
אה, אני צריך PHPWord.

354
00:31:53,960 --> 00:32:00,260
זו היא ערבוב התחביר שבו אתה מציין מה הוא המפתח

355
00:32:00,260 --> 00:32:03,330
ואינך מציין מה הוא המפתח.

356
00:32:03,330 --> 00:32:05,520
אז 3 כאן הוא ערך.

357
00:32:05,520 --> 00:32:08,080
לא באופן מפורש שאמרת את מה המפתח שלו הוא הולך להיות.

358
00:32:08,080 --> 00:32:11,670
מה אתה חושב שהמפתח שלו הוא הולך להיות?

359
00:32:11,670 --> 00:32:21,410
[תלמיד] 0. >> אני מנחש 0 רק בגלל שזה ראשון שלא צוין.

360
00:32:21,410 --> 00:32:23,500
אנחנו באמת יכולים לעשות כמה מקרים אלה.

361
00:32:23,500 --> 00:32:28,030
אז print_r הוא להדפיס רקורסיבית. זה יהיה להדפיס את כל המערך.

362
00:32:28,030 --> 00:32:32,700
זה יהיה להדפיס subarrays של המערך אם היו כאלה.

363
00:32:32,700 --> 00:32:36,630
php.test.php; אז print_r ($ מערך).

364
00:32:36,630 --> 00:32:38,810
זה נראה כמו שזה נתן לו 0.

365
00:32:38,810 --> 00:32:43,530
יש באמת משהו שכדאי לזכור כאן, אבל אנחנו נחזור אליה ברגע האחד.

366
00:32:43,530 --> 00:32:45,850
אבל מה אם אני במקרה עושה מדד זה 1?

367
00:32:45,850 --> 00:32:51,170
PHP לא להבדיל בין מדדי מייתרים ומדדים שלמים,

368
00:32:51,170 --> 00:33:00,280
לכן בשלב זה אני כבר ממש הגדרתי עמוד 1 ואני יכול לעשות את שניהם מערך $ [1] ומערך $ ['1 ']

369
00:33:00,280 --> 00:33:06,250
וזה יהיה אותו מדד ואותו מפתח.

370
00:33:06,250 --> 00:33:13,000
אז עכשיו מה אתה חושב 3 הולך להיות? >> [תלמיד] 2. >> [אודן] אני מנחש 2.

371
00:33:16,000 --> 00:33:18,690
כן. זה 2.

372
00:33:18,690 --> 00:33:24,790
מה אם עשינו את זה הוא 10, זה 4? מה אתה חושב שהמדד של 3 הולך להיות?

373
00:33:27,360 --> 00:33:29,110
אני חושב 11.

374
00:33:29,110 --> 00:33:33,060
הניחוש שלי לגבי מה PHP עושה - ואני חושב שראיתי את זה קודם -

375
00:33:33,060 --> 00:33:39,760
האם זה רק עוקב אחר מה שהמדד המספרי הגבוה ביותר שלו השתמש עד כה הוא.

376
00:33:39,760 --> 00:33:44,230
זה אף פעם לא הולך למנות את ראשי מחרוזת עד 3. זה תמיד יהיה מדד מספרי.

377
00:33:44,230 --> 00:33:47,690
אז זה עוקב אחר בגבוה זה הוקצה עד כה, אשר קורה להיות 10,

378
00:33:47,690 --> 00:33:52,540
וזה הולך לתת 11-3.

379
00:33:52,540 --> 00:34:02,110
מה שאמרתי קודם, שים לב לאופן בו הוא מדפיס מערך זה.

380
00:34:02,110 --> 00:34:06,850
היא מדפיסה 10 מפתח, מפתח 4, 11 מפתח, המפתח ד.

381
00:34:06,850 --> 00:34:09,790
או אפילו בואו נעשה -

382
00:34:15,760 --> 00:34:22,489
אני מניח שאני לא לשים 0, אבל זה דפוס 1, 2, 3, 4.

383
00:34:22,489 --> 00:34:29,330
מה, אם אני עובר כאן? או בואו בעצם לעבור 2 אלה.

384
00:34:29,330 --> 00:34:31,940
עכשיו זה מדפיס 2, 1, 3, 4.

385
00:34:31,940 --> 00:34:41,270
המערכים של PHP הם לא בדיוק כמו שולחן החשיש הרגיל שלך.

386
00:34:41,270 --> 00:34:45,570
זה הגיוני לחלוטין כדי לחשוב עליהם כשולחנות hash 99% מהזמן.

387
00:34:45,570 --> 00:34:53,790
אבל בטבלאות hash שלך אין שום תחושה של סדר בדברים שהוכנסו.

388
00:34:53,790 --> 00:34:56,639
אז ברגע שאתה מכניס אותו לתוך שולחן החשיש,

389
00:34:56,639 --> 00:35:00,590
תניח שאין רשימה מקושרת ואתה יכול לשפוט ברשימה מקושרת

390
00:35:00,590 --> 00:35:03,980
שהוכנס ראשון.

391
00:35:03,980 --> 00:35:10,060
אבל כאן הכנסנו 2 1 והוא יודע מתי זה להדפיס את המערך הזה ש2 מגיעים ראשון.

392
00:35:10,060 --> 00:35:13,090
זה לא להדפיס אותו בסתם סדר.

393
00:35:13,090 --> 00:35:17,550
מבנה הנתונים הטכני שהיא עושה שימוש הוא מפה מסודרת,

394
00:35:17,550 --> 00:35:24,690
כך שזה ממפה את המפתחות לערכים והוא זוכר את הסדר שבו המפתחות האלה הוכנסו.

395
00:35:24,690 --> 00:35:31,600
בעיקרון זה לסיבוכים מסוימים בם זה מעצבן ממש -

396
00:35:31,600 --> 00:35:34,510
בואו נגיד שיש לך מערך 0, 1, 2, 3, 4, 5

397
00:35:34,510 --> 00:35:37,700
ואתה רוצה לקחת את האינדקס 2.

398
00:35:37,700 --> 00:35:47,750
דרך אחת לעשות את זה, בואו לראות מה שנראה כמו.

399
00:35:47,750 --> 00:35:50,410
0, 2, 1, 3, 4.

400
00:35:50,410 --> 00:35:54,880
בטל הגדרה קורית כדי לבטל את הגדרת שני משתנים ומדדי מערך.

401
00:35:54,880 --> 00:35:58,630
כה מטלטלת (מערך [2] $);

402
00:35:58,630 --> 00:36:03,430
עכשיו, מה זה הולך להיראות כמו? 2 הם פשוט נעלם, כך שזה בסדר גמור.

403
00:36:03,430 --> 00:36:11,670
הדבר הכי מעצבן הוא שאם אתה רוצה שדברים יהיו ממש כמו מערך.

404
00:36:11,670 --> 00:36:14,910
אני אשים את המספרים אקראיים.

405
00:36:14,910 --> 00:36:20,400
עכשיו שם לב המדדים שלי.

406
00:36:20,400 --> 00:36:26,860
אני רוצה שזה פשוט להיות כמו מערך C בו הוא עובר בין 0 ל אורך - 1

407
00:36:26,860 --> 00:36:30,810
ואני יכול לחזר עליו ככזה.

408
00:36:30,810 --> 00:36:38,520
אבל ברגע שאני unset המדד השני, מה שהיה ב3 מדד לא עכשיו להיות אינדקס 2.

409
00:36:38,520 --> 00:36:44,790
במקום זאת, פשוט מסירה מדד ועכשיו אתה הולך 0, 1, 3, 4.

410
00:36:44,790 --> 00:36:48,740
זה הגיוני לגמרי.

411
00:36:48,740 --> 00:36:53,950
זה פשוט מעצבן ואתה צריך לעשות את דברים כמו אחו מערך. כן.

412
00:36:53,950 --> 00:36:57,200
>> [תלמיד] מה היה קורה אם היה לך ללולאה

413
00:36:57,200 --> 00:36:59,630
ושאתה רוצה ללכת על כל האלמנטים?

414
00:36:59,630 --> 00:37:02,290
כאשר הוא פגע 2, הייתי עליה להניב אי פעם?

415
00:37:02,290 --> 00:37:10,150
Iterating על מערך. ישנן 2 דרכים אתה יכול לעשות את זה.

416
00:37:10,150 --> 00:37:12,770
אתה יכול להשתמש רגיל ללולאה.

417
00:37:12,770 --> 00:37:22,000
זו מורכבות נוספת של PHP.

418
00:37:22,000 --> 00:37:27,420
רוב השפות, הייתי אומר, יש לו איזה אורך או len או משהו

419
00:37:27,420 --> 00:37:30,470
מציין את אורכו של מערך.

420
00:37:30,470 --> 00:37:32,820
ב PHP זה ספירה.

421
00:37:32,820 --> 00:37:36,160
אז ספירה ($ מערך); $ אני + +)

422
00:37:36,160 --> 00:37:42,950
בואו רק הדפסה (מערך [i $] $);

423
00:37:45,920 --> 00:37:48,820
שים לב: לא מוגדר קיזוז: 2.

424
00:37:48,820 --> 00:37:51,610
זה רק הולך להיכשל.

425
00:37:51,610 --> 00:38:03,020
זו הסיבה ש, על פי רוב, אתה לא צריך לחזר על מערך כזה.

426
00:38:03,020 --> 00:38:07,110
זה יכול להיות הגזמה, אבל אתה אף פעם לא צריך לחזר על מערך כזה

427
00:38:07,110 --> 00:38:19,410
כי PHP מספקת תחביר foreach foreach בה (מערך $ כפריט $).

428
00:38:19,410 --> 00:38:31,830
עכשיו, אם להדפיס ($ פריט); - להכין מלדון בו בשנייה - זה עובד בסדר גמור.

429
00:38:31,830 --> 00:38:38,960
האופן שבו הוא עובד foreach הוא הנימוק הראשון הוא המערך שאתה iterating נגמר.

430
00:38:38,960 --> 00:38:44,060
והטענה השנייה, הפריט, דרך כל מעבר של ללולאה

431
00:38:44,060 --> 00:38:52,690
זה הולך לקחת על הדבר הבא במערך. אז לזכור את המערך יש סדר.

432
00:38:52,690 --> 00:38:55,690
הפעם הראשונה דרך ללולאה, הפריט הולכת להיות 123

433
00:38:55,690 --> 00:38:59,540
ואז זה יהיה 12 אז זה יהיה 13 אז זה יהיה 23 ואז זה יהיה 213.

434
00:38:59,540 --> 00:39:04,670
דברים מקבלים ממש מוזרים כשאתה עושה משהו כמו foreach.

435
00:39:04,670 --> 00:39:07,480
בואו לראות מה קורה, כי אתה אף פעם לא צריך לעשות את זה.

436
00:39:07,480 --> 00:39:13,320
מה אם אנחנו unset (מערך [1] $);

437
00:39:20,410 --> 00:39:26,030
זה כנראה היה צפוי.

438
00:39:26,030 --> 00:39:30,950
אתה iterating על מערך זה, ובכל פעם שאתה unsetting המדד הראשון.

439
00:39:30,950 --> 00:39:39,720
אז למדד 0, הדבר, הפריט הראשון לוקח על ערך 0, אז זה הולך להיות 123.

440
00:39:39,720 --> 00:39:44,630
אבל בתוך הלולאה עבורנו מטלטלת 1 מדד, כך אומר 12 נעלמו.

441
00:39:44,630 --> 00:39:57,480
אז להדפיס. PHP_EOL.

442
00:39:57,480 --> 00:40:03,580
PHP_EOL הוא רק שורה חדשה, אבל מהבחינה טכנית זה יותר ניידת

443
00:40:03,580 --> 00:40:08,890
מאז השורה חדשה ב-Windows שונה משורה החדשה ב-Mac ו-UNIX.

444
00:40:08,890 --> 00:40:18,040
ב-Windows הוא שורה חדשה \ r \ n, ואילו בכל מקום אחר שהוא נוטה להיות רק \ n.

445
00:40:18,040 --> 00:40:25,150
PHP_EOL מוגדר כך שהוא משתמש בכל מה שהשורה החדשה של המערכת שלך.

446
00:40:25,150 --> 00:40:29,310
אז לפרסם את זה. בואו לא print_r ($ מערך) בסוף.

447
00:40:32,830 --> 00:40:37,390
לא היה לי מושג שזה יהיה ההתנהגות.

448
00:40:41,740 --> 00:40:48,960
הפריט עדיין מקבל את הערך 12 למרות שאנחנו unset 12 עוד לפני שהגענו אליו מהמערך.

449
00:40:52,770 --> 00:40:58,840
אל תיקח את המילה שלי על זה, אבל זה נראה כמו foreach יוצר עותק של המערך

450
00:40:58,840 --> 00:41:02,160
ולאחר מכן הפריט לוקח על כל הערכים שלו עותק.

451
00:41:02,160 --> 00:41:07,760
אז גם אם אתה משנה את המערך פנימי ללולאה,

452
00:41:07,760 --> 00:41:17,240
זה לא אכפת לי. פריט ייקח על הערכים המקוריים.

453
00:41:17,240 --> 00:41:19,240
בואו ננסה unsetting.

454
00:41:19,240 --> 00:41:24,460
מה אם זה מערך $ [1] = "שלום";

455
00:41:24,460 --> 00:41:31,770
למרות שאנחנו "שלום" הכנסנו לתוך המערך, הפריט לא לוקח על ערך זה.

456
00:41:31,770 --> 00:41:37,430
יש תחביר אחר לforeach לולאות

457
00:41:37,430 --> 00:41:45,900
איפה אתה שם 2 משתנה מופרד על ידי חץ.

458
00:41:45,900 --> 00:41:49,680
המשתנה ראשון זה הולך להיות המפתח של ערך זה,

459
00:41:49,680 --> 00:41:53,050
משתנה שני וזה הולך להיות אותו הפריט המדויק.

460
00:41:53,050 --> 00:42:01,610
זה לא מעניין פה, אבל אם יחזור למקרה המקורי שלנו של '' -> 1,

461
00:42:01,610 --> 00:42:06,090
'ב' -> 1,

462
00:42:06,090 --> 00:42:14,470
כאן אם רק לחזר לכל מערך כפריט, הפריט הולך להיות 1 בכל פעם אחת.

463
00:42:14,470 --> 00:42:18,170
אבל אם אנחנו רוצים גם לדעת המפתח מקושר לפריט

464
00:42:18,170 --> 00:42:25,230
אז אנחנו עושים מקש ש$ -> פריט $.

465
00:42:25,230 --> 00:42:31,980
אז עכשיו אנחנו יכולים לעשות הדפסת מפתח ($. ':'.

466
00:42:31,980 --> 00:42:39,380
עכשיו זה iterating מעל והדפסה על כל מקש והערך הקשור שלה.

467
00:42:39,380 --> 00:42:47,030
>> דבר נוסף שאנו יכולים לעשות בלולאות foreach הוא שאתה יכול לראות תחביר זה.

468
00:42:47,030 --> 00:42:54,770
אמפרסנד לפני שמות משתנים נוטה להיות איך עושה הפניות PHP.

469
00:42:54,770 --> 00:43:00,460
איפה הפניות דומות מאוד למצביעים,

470
00:43:00,460 --> 00:43:04,820
אין לך מצביעים, כך שלעולם לא להתמודד עם זיכרון ישירות.

471
00:43:04,820 --> 00:43:12,620
אבל יש לך הפניות שבו משתנה 1 מתייחסת לאותו הדבר כמו משתנה אחר.

472
00:43:12,620 --> 00:43:21,450
בתוך כאן בואו לעשות $ פריט. בואו נחזור ל1, 10.

473
00:43:21,450 --> 00:43:28,800
בואו לעשות $ פריט + +; זה עדיין קיים ב-PHP. אתה עדיין יכול לעשות + +.

474
00:43:28,800 --> 00:43:38,260
php.test.php. אני צריך להדפיס אותו. print_r ($ array);

475
00:43:38,260 --> 00:43:42,730
אנו מדפיסים 2, 11.

476
00:43:42,730 --> 00:43:49,560
אם אני רק עשיתי foreach (מערך $ כפריט $) אז פריט יהיה הערך 1

477
00:43:49,560 --> 00:43:54,190
בפעם הראשונה דרך הלולאה. זה יהיה להגדיל 1-2 וגמרנו.

478
00:43:54,190 --> 00:43:57,260
ואז זה יהיה לעבור את המעבר השני של הלולאה ופריט שהוא 10.

479
00:43:57,260 --> 00:44:01,570
זה פריט מרווחים עד 11, ולאחר מכן שפשוט נזרקו לפח.

480
00:44:01,570 --> 00:44:06,670
אז אנחנו print_r ($ מערך), ובואו נראים שזה רק 1, 10.

481
00:44:06,670 --> 00:44:09,070
אז התוספת שעשינו הייתה אבודה.

482
00:44:09,070 --> 00:44:13,410
אבל foreach (מערך $ וכפריט $)

483
00:44:13,410 --> 00:44:21,910
עכשיו סעיף זה את אותו הפריט שזכות זו כאן. זה אותו הדבר.

484
00:44:21,910 --> 00:44:26,820
אז פריט $ + + הוא שינוי המערך 0.

485
00:44:29,330 --> 00:44:41,850
בעיקרון, אתה יכול גם לעשות k $ - פריט> $ ואתה יכול לעשות $ מערך [יא $] + +;

486
00:44:41,850 --> 00:44:48,650
>> אז דרך אחרת לעשות את זה, אנחנו חופשיים לשנות פריט,

487
00:44:48,650 --> 00:44:54,070
אבל זה לא ישנה המערך המקורי שלנו.

488
00:44:54,070 --> 00:44:59,720
אבל אם אנו משתמשים k, שהוא המפתח שלנו, אז אנחנו יכולים רק אינדקס לתוך המערך שלנו באמצעות שמפתח

489
00:44:59,720 --> 00:45:01,530
ולהגדיל את זה.

490
00:45:01,530 --> 00:45:05,410
זה יותר ישירות משנה המערך המקורי שלנו.

491
00:45:05,410 --> 00:45:10,690
אתה אפילו יכול לעשות את זה, אם מסיבה כלשהי אתם רוצים את היכולת לשנות -

492
00:45:10,690 --> 00:45:13,510
למעשה, זה הגיוני לגמרי.

493
00:45:13,510 --> 00:45:16,020
אתה לא רוצה צריך לכתוב $ מערך [יא $] + +,

494
00:45:16,020 --> 00:45:27,890
אתה רק רצית לכתוב $ פריט + +, אבל אתה עדיין רוצה להגיד אם (k $ === '")

495
00:45:27,890 --> 00:45:30,620
אז להגדיל פריט ולאחר מכן להדפיס את המערך שלנו.

496
00:45:30,620 --> 00:45:36,290
אז עכשיו מה אנחנו מצפים print_r לעשות? מה ערכים צריכים להיות מודפס?

497
00:45:36,290 --> 00:45:43,770
[תלמיד] 2 ו 10. >> [אודן] רק אם המפתח היה '' נעשינו בפועל לפרסם את זה.

498
00:45:51,940 --> 00:45:55,670
>> אתה כנראה מאוד נדיר, אם בכלל, יש צורך להגדיר פונקציות ב-PHP,

499
00:45:55,670 --> 00:46:03,370
אבל אתה יכול לראות משהו דומה שבו אתה מגדיר בפונקציה כמו כל פונקציה.

500
00:46:03,370 --> 00:46:09,900
בדרך כלל היית אומר (foo $, $ ברים) ולאחר מכן להגדיר את זה כדי להיות כל דבר אחר.

501
00:46:09,900 --> 00:46:17,580
אבל אם אני עושה את זה, אז זה אומר שכל מה שקורא מה,

502
00:46:17,580 --> 00:46:25,110
כל מה שקורא באז, ולכן הטיעון הראשון עבר לבאז יכול להיות שונים.

503
00:46:25,110 --> 00:46:38,100
בואו נעשה foo $ + +;

504
00:46:38,100 --> 00:46:48,020
ובתוך מכאן בואו נעשה את באז ($ פריט);

505
00:46:48,020 --> 00:46:52,250
עכשיו אנחנו קוראים לפונקציה.

506
00:46:52,250 --> 00:46:56,780
הוויכוח הוא נלקח על ידי הפניה, מה שאומר שאם לשנות אותו

507
00:46:56,780 --> 00:47:00,390
אנחנו משנים את הדבר שעבר בו

508
00:47:00,390 --> 00:47:04,420
והדפסה זו אנו מצפים - אלא אם כן אני פשלתי תחביר - יש לנו 2, 11,

509
00:47:04,420 --> 00:47:06,300
אז זה בעצם מוגדל.

510
00:47:06,300 --> 00:47:08,790
שימו לב שאנחנו צריכים הפניות ב2 מקומות.

511
00:47:08,790 --> 00:47:13,050
מה אם עשיתי את זה? מה זה אומר?

512
00:47:13,050 --> 00:47:15,810
[תלמיד] זה ישתנה. >> כן.

513
00:47:15,810 --> 00:47:18,290
פריט הוא פשוט העתק של הערך במערך.

514
00:47:18,290 --> 00:47:26,670
אז הפריט ישתנה ל 2, אבל המערך [''] עדיין יהיה 1.

515
00:47:26,670 --> 00:47:32,560
או מה אם אני עושה את זה?

516
00:47:32,560 --> 00:47:39,260
עכשיו פריט נשלח כהעתק לבאז.

517
00:47:39,260 --> 00:47:46,330
אז העותק של הוויכוח יהיה מוגדל ל 2,

518
00:47:46,330 --> 00:47:49,240
אבל הפריט עצמו מעולם לא מוגדל ל 2.

519
00:47:49,240 --> 00:47:52,880
והפריט הוא אותו הדבר כמו סוגר מערך מה,

520
00:47:52,880 --> 00:47:55,380
כך שהמערך היה מעולם מוגדל.

521
00:47:55,380 --> 00:47:57,960
אז שני המקומות האלה צריכים את זה.

522
00:47:57,960 --> 00:48:03,830
>> PHP היא בדרך כלל די חכמה בעניין הזה.

523
00:48:03,830 --> 00:48:06,570
אתם אולי חושבים שאני רוצה להעביר על ידי התייחסות -

524
00:48:06,570 --> 00:48:09,560
זו הייתה למעשה שאלה על אחד psets.

525
00:48:09,560 --> 00:48:14,480
זה היה דבר questions.txt בו אמר,

526
00:48:14,480 --> 00:48:19,280
למה אולי אתה רוצה לעבור struct זה על דרך הפניה?

527
00:48:19,280 --> 00:48:21,250
מה הייתה תשובה לזה?

528
00:48:21,250 --> 00:48:25,100
[תלמיד] אז אתה לא צריך להעתיק משהו גדול. >> כן.

529
00:48:25,100 --> 00:48:32,920
Struct יכול להיות גדול באופן שרירותי, וכשאתה עובר בstruct כטיעון

530
00:48:32,920 --> 00:48:36,800
זה צריך להעתיק את זה כל struct להעביר אותו לפונקציה,

531
00:48:36,800 --> 00:48:40,410
בעוד שאם רק תעבור struct על ידי התייחסות

532
00:48:40,410 --> 00:48:46,530
אז זה פשוט צריך להעתיק את כתובת 4-ייט כטיעון לפונקציה.

533
00:48:48,520 --> 00:48:52,320
PHP היא קצת יותר חכמה מזה.

534
00:48:52,320 --> 00:49:00,650
אם לי איזה תפקיד ואני עובר אליו מערך של 1000 דברים,

535
00:49:00,650 --> 00:49:03,990
זה אומר שהוא יצטרך להעתיק את כל הדברים האלה של 1000

536
00:49:03,990 --> 00:49:10,450
כדי להעביר אותו לפונקציה? זה לא חייב לעשות את זה מייד.

537
00:49:10,450 --> 00:49:15,940
אם בתוך פונקציה זה לא באמת משנה foo,

538
00:49:15,940 --> 00:49:22,660
כך שאם (foo $ === 'שלום') ההחזר אמיתי.

539
00:49:22,660 --> 00:49:26,460
שים לב שאנו לא שונים בתוך הטיעון של פונקציה זו למעשה,

540
00:49:26,460 --> 00:49:30,010
מה שאומר שכל מה שעבר כבfoo לא צריך להיות מועתק

541
00:49:30,010 --> 00:49:32,100
כי זה לא משנה אותו.

542
00:49:32,100 --> 00:49:39,240
אז דרך PHP עבודות הן הטיעונים תמיד מועברת על ידי הפניה

543
00:49:39,240 --> 00:49:42,170
עד שאתה בעצם מנסה לשנות אותו.

544
00:49:42,170 --> 00:49:51,160
עכשיו, אם אני אומר foo $ + +, זה יהיה עכשיו ליצור עותק של foo המקורי ולשנות את העותק.

545
00:49:51,160 --> 00:49:53,090
זה חוסך קצת זמן.

546
00:49:53,090 --> 00:49:58,210
אם אתה לא נוגע במגוון העצום הזה, אתה אף פעם לא באמת לשנות אותו,

547
00:49:58,210 --> 00:50:02,360
זה לא צריך להפוך את העותק,

548
00:50:02,360 --> 00:50:06,640
בעוד שאם אנחנו פשוט לשים אמפרסנד זה שאומר שזה אפילו לא להעתיק אותו

549
00:50:06,640 --> 00:50:08,640
גם אם תשנה אותו.

550
00:50:08,640 --> 00:50:10,680
התנהגות זו נקראת העתקה בעת כתיבה.

551
00:50:10,680 --> 00:50:17,380
אתה תראה את זה במקומות אחרים, במיוחד אם אתה לוקח כמובן מערכת הפעלה.

552
00:50:17,380 --> 00:50:23,880
העתקה בעת כתיבה היא דפוס די רגיל שבו אתה לא צריך ליצור עותק של משהו

553
00:50:23,880 --> 00:50:26,650
אלא אם כן זה באמת משתנה. כן.

554
00:50:26,650 --> 00:50:29,520
[תלמיד] מה אם היה לך את התוספת בתוך הבדיקה,

555
00:50:29,520 --> 00:50:33,700
כך שרק האלמנט 1 מתוך 1000 היינו צריך להיות שונה?

556
00:50:33,700 --> 00:50:38,770
אני לא בטוח.

557
00:50:38,770 --> 00:50:51,250
אני חושב שזה יהיה להעתיק את כל הדבר הזה, אבל זה אפשרי זה מספיק חכם ש--

558
00:50:51,250 --> 00:51:00,020
למעשה, מה שאני חושב שהיינו לנו הוא לדמיין את מערך שנראה כך: array2 $ = [

559
00:51:00,020 --> 00:51:11,000
אז '' המדד הוא מערך של [1 2 3 4] 'ב', ומדד הוא מערך של כל דבר.

560
00:51:11,000 --> 00:51:15,380
אני צריך פסיקים בין כל אלה. תאר לעצמכם שיש פסיקים.

561
00:51:15,380 --> 00:51:21,210
אז 'ג'הוא 3 הערך.

562
00:51:24,210 --> 00:51:26,290
אוקיי.

563
00:51:26,290 --> 00:51:33,440
עכשיו אניח שאנחנו עושים באז $ (array2 $);

564
00:51:33,440 --> 00:51:36,540
בי באז לא לקחת את זה על דרך הפניה.

565
00:51:43,510 --> 00:51:47,370
אז $ foo ['ג'] + +;

566
00:51:47,370 --> 00:51:52,340
זה כגון דוגמה שבה אנחנו עוברים array2 כטיעון

567
00:51:52,340 --> 00:51:57,010
ואז זה שינוי מדד ספציפי של המערך ידי הגדלתו.

568
00:51:57,010 --> 00:52:01,090
באמת שאין לי מושג מה PHP הוא הולך לעשות.

569
00:52:01,090 --> 00:52:07,200
זה בקלות יכול ליצור עותק של כל הדבר, אבל אם זה חכם,

570
00:52:07,200 --> 00:52:15,030
זה יהיה ליצור עותק של המפתחות הללו שבו זה יהיה הערך הייחודי שלו

571
00:52:15,030 --> 00:52:20,620
אבל זה עדיין יכול להצביע לאותו המערך 1,2,3,4

572
00:52:20,620 --> 00:52:22,320
וזה עדיין יכול להצביע לאותו המערך.

573
00:52:22,320 --> 00:52:24,170
אני יהיה האייפד זה.

574
00:52:28,900 --> 00:52:45,950
אנחנו עוברים במערך הזה שבו נקודתי הטיפוס הזה כדי 3, נקודתי הבחור הזה [1,2,3,4],

575
00:52:45,950 --> 00:52:51,350
נקודתי הבחור הזה [34, ...]

576
00:52:51,350 --> 00:52:58,590
עכשיו שאנחנו מעבירים אותו לאז, אנחנו משנים את זה.

577
00:52:58,590 --> 00:53:03,550
אם PHP היא חכמה, הוא יכול פשוט לעשות -

578
00:53:11,850 --> 00:53:18,230
היו לנו עדיין להעתיק כמה זיכרון, אבל אם היו subarrays המקונן העצום הללו

579
00:53:18,230 --> 00:53:21,560
אנחנו לא צריכים להעתיק אותם.

580
00:53:21,560 --> 00:53:27,530
אני לא יודע אם זה מה שהיא עושה, אבל אני יכול לדמיין אותו עושה את זה.

581
00:53:29,050 --> 00:53:36,690
זהו גם יתרון די גדול של C מעל PHP.

582
00:53:36,690 --> 00:53:40,320
>> PHP עושה את החיים הרבה יותר קלים להרבה דברים,

583
00:53:40,320 --> 00:53:45,060
אבל אתה סוג של לי שום מושג כמה טוב זה יבצע

584
00:53:45,060 --> 00:53:52,530
משום שאין לי מושג מתחת למכסת המנוע כשהוא יצירת עותקים אלה של דברים,

585
00:53:52,530 --> 00:53:55,170
אה, אז זה הולך להיות עותק זמן קבוע,

586
00:53:55,170 --> 00:54:01,140
האם זה רק הולך לשנות מצביע 1, זה הולך להיות עותק יניארי גיחוך קשה?

587
00:54:01,140 --> 00:54:03,000
מה אם הוא לא יכול למצוא מקום?

588
00:54:03,000 --> 00:54:06,760
האם זה אז צריך להפעיל את איסוף אשפה כדי לקבל קצת יותר מקום?

589
00:54:06,760 --> 00:54:11,210
ואיסוף אשפה יכול לקחת שרירותי ארוך.

590
00:54:11,210 --> 00:54:13,600
ב C אתה לא צריך לדאוג לדברים האלה.

591
00:54:13,600 --> 00:54:19,780
כל שורה האחת אתה כותב שאתה יכול פחות או יותר סיבה על איך זה הולך לבצע.

592
00:54:26,800 --> 00:54:29,150
>> הבה תביט לאחור באלה.

593
00:54:35,400 --> 00:54:37,520
כמה נחמד זה שאתה לא צריך להתמודד עם פונקציות hash,

594
00:54:37,520 --> 00:54:39,010
רשימות מקושרות, או משהו כזה?

595
00:54:39,010 --> 00:54:41,980
מאז עבודה עם טבלאות hash היא כל כך קלה עכשיו, הנה חידת כיף לעבוד עליו.

596
00:54:41,980 --> 00:54:45,920
פתח את הקובץ בשם unique.php ובו לכתוב תכנית PHP

597
00:54:45,920 --> 00:54:48,330
(המכונה גם "סקריפט").

598
00:54:48,330 --> 00:54:55,700
אנו נוטים לקרוא להם תסריטים אם הם דברים קצרים שאתה מפעיל בשורת הפקודה.

599
00:54:55,700 --> 00:55:02,950
בעיקרון, כל שפה שאינך לקמפל אבל אתה הולך להפעיל את ההפעלה

600
00:55:02,950 --> 00:55:05,920
בשורת הפקודה, אתה יכול לקרוא לזה תסריט הפעלה.

601
00:55:05,920 --> 00:55:08,510
באותה מידה אני יכול לכתוב תכנית C שעושה את זה,

602
00:55:08,510 --> 00:55:12,300
אבל אני לא קורא לזה תסריט מאז שהקומפילציה ראשונה ולאחר מכן להפעיל אותו בינארי.

603
00:55:12,300 --> 00:55:15,480
אבל תכנית PHP זה אנחנו הולכים לקרוא את תסריט.

604
00:55:15,480 --> 00:55:23,830
או אם כתבנו אותו בPython או Perl או Node.js או כל אחד מהדברים האלה,

605
00:55:23,830 --> 00:55:26,500
היינו קורא להם כל התסריטים בגלל שאתה מריץ אותם בשורת הפקודה

606
00:55:26,500 --> 00:55:30,040
אבל אנחנו לא לקמפל אותם.

607
00:55:30,860 --> 00:55:33,400
אנחנו יכולים לעשות את זה די מהר.

608
00:55:36,960 --> 00:55:41,480
אנחנו לא הולכים להשתמש argv. בואו פשוט לפוצץ את זה.

609
00:55:41,480 --> 00:55:45,730
תקראו לזה ייחודי, כתיבת תכנית.

610
00:55:45,730 --> 00:55:49,400
אתה יכול להניח שהקלט יכיל מילה אחת בכל שורה.

611
00:55:49,400 --> 00:55:52,020
למעשה, argv יהיה די טריוויאלית לשימוש.

612
00:56:03,730 --> 00:56:06,720
unique.php.

613
00:56:08,550 --> 00:56:13,750
דבר הראשון ראשון, אנחנו רוצים לבדוק אם יש לנו כבר עברנו 1 טיעון של שורת פקודה.

614
00:56:13,750 --> 00:56:20,900
בדיוק כמו שהיית מצפה וargv argc ב-C, עדיין יש לנו אלה ב-PHP.

615
00:56:20,900 --> 00:56:33,900
אז אם (תכנית + $! == 2) אז אני לא אעסוק בהדפסת הודעה או משהו.

616
00:56:33,900 --> 00:56:37,340
אני רק יוצא, קוד שגיאה של 1.

617
00:56:37,340 --> 00:56:41,340
גם אני יכול לחזור 1.

618
00:56:41,340 --> 00:56:53,180
לעיתים נדיר ב-PHP אתה במצב הזה שבו אנחנו ב--

619
00:56:53,180 --> 00:56:57,820
בדרך כלל אתה נמצא בפונקציה שנקראת על ידי פונקציה שנקראת על ידי פונקציה שנקראת על ידי פונקציה.

620
00:56:57,820 --> 00:57:02,070
ואם משהו משתבש ואתה רק רוצה לצאת מכל מה שלחלוטין,

621
00:57:02,070 --> 00:57:05,680
יציאה פשוט נגמרת התכנית.

622
00:57:05,680 --> 00:57:08,160
זו קיימת גם בג

623
00:57:08,160 --> 00:57:10,700
אם אתה בתפקיד בפונקציה בפונקציה בפונקציה

624
00:57:10,700 --> 00:57:17,540
ואתה רוצה רק להרוג את התכנית, אתה יכול לקרוא ליציאה וזה יהיה פשוט לצאת.

625
00:57:17,540 --> 00:57:23,120
אבל ב-PHP שזה אפילו יותר נדיר, כי אנו נמצאים ברמה העליונה זו.

626
00:57:23,120 --> 00:57:26,090
בדרך כלל אנחנו נמצאים בתוך איזה פונקציה, ולכן אנחנו קוראים ליציאה

627
00:57:26,090 --> 00:57:29,650
כך שאין לנו כדי להחזיר את הדבר 1 שאז מבין שיש שגיאה

628
00:57:29,650 --> 00:57:32,270
כדי שיחזיר את אם שמכיר הייתה שגיאה.

629
00:57:32,270 --> 00:57:35,270
אנחנו לא רוצים להתעסק בזה, כל כך לצאת (1);

630
00:57:35,270 --> 00:57:38,240
תמורה (1), במקרה זה תהיה שווה.

631
00:57:38,240 --> 00:57:44,000
>> אז מה שאנחנו רוצים לפתוח אנחנו רוצים fopen.

632
00:57:44,000 --> 00:57:46,760
הטיעונים הולכים להסתכל די דומה.

633
00:57:46,760 --> 00:57:51,600
אנחנו רוצים fopen ($ argv [1], ואנחנו רוצים לפתוח אותו לקריאה.

634
00:57:51,600 --> 00:57:55,720
המחזיר את משאבים שאנחנו הולכים לקרוא ו.

635
00:57:55,720 --> 00:58:02,180
זה נראה די דומה לאופן שC עושה את זה, אלא רק שלא צריך לומר * קובץ.

636
00:58:02,180 --> 00:58:06,170
במקום שאנחנו פשוט אומרים f $. אוקיי.

637
00:58:06,170 --> 00:58:17,190
למעשה, אני חושב שזה אפילו נותן לנו רמז לפונקצית PHP בשם קובץ. קובץ PHP.

638
00:58:17,190 --> 00:58:23,990
מה זה הולך לעשות הוא לקרוא את כל קובץ לתוך מערך.

639
00:58:23,990 --> 00:58:29,770
אתה אפילו לא צריך fopen זה. זה הולך לעשות את זה בשבילך.

640
00:58:37,450 --> 00:58:43,700
אז קווי $ = קובץ ($ argv [1]);

641
00:58:43,700 --> 00:58:49,680
עכשיו כל הקווים של הקובץ הם בקווים. עכשיו אנחנו רוצים לסדר את השורות.

642
00:58:49,680 --> 00:58:52,180
איך אנחנו יכולים למיין את הקווים?

643
00:58:52,180 --> 00:58:54,920
אנחנו נמיין את הקווים.

644
00:58:54,920 --> 00:58:58,080
ועכשיו אנחנו יכולים להדפיס אותם או משהו כזה.

645
00:58:58,080 --> 00:59:05,580
כנראה הדרך הקלה ביותר היא foreach ($ שורות כמו $ קו) מהדהדים $ קו;

646
00:59:05,580 --> 00:59:10,960
[תלמיד] לא היית אפילו לחצות קווים על ידי התייחסות למשהו כזה?

647
00:59:10,960 --> 00:59:28,850
זה המקום בו היה מוגדר כמין סוג הפונקציה (ומערך $).

648
00:59:28,850 --> 00:59:32,650
כשאתה קורא לפונקציה שלא תעבור אותו על דרך הפניה.

649
00:59:32,650 --> 00:59:36,900
זה הפונקציה שמגדירה אותו כלוקח את זה כנקודת התייחסות.

650
00:59:36,900 --> 00:59:40,900
זהו למעשה מה בדיוק השתבשתי

651
00:59:40,900 --> 00:59:46,220
כאשר אנחנו שמים את הכל לשרתים שלנו כשנכנסנו 5.3-5.4.

652
00:59:46,220 --> 00:59:53,800
עד 5.4, זה היה הגיוני לגמרי.

653
00:59:53,800 --> 00:59:58,740
פונקציה לא מצפה לקחת את זה כנקודת התייחסות, אבל אתה יכול להעביר אותו כנקודת התייחסות

654
00:59:58,740 --> 01:00:02,860
כך שאם הפונקציה קורית כדי לשנות את זה, זה עדיין שונה.

655
01:00:02,860 --> 01:00:05,850
כשל 5.4, אתה לא אמור לעשות את זה.

656
01:00:05,850 --> 01:00:11,740
אז עכשיו הדרך היחידה שאתה עובר על ידי התייחסות היא אם הפונקציה עושה את זה באופן מפורש.

657
01:00:11,740 --> 01:00:19,840
אם אתה לא רוצה אותו כדי לשנות את זה, אז אתה צריך לעשות עותק $ = $ קווים והעתק עובר.

658
01:00:19,840 --> 01:00:24,820
אז עכשיו קווים יישמרו והעותק יהיה שונה.

659
01:00:27,670 --> 01:00:31,460
php.unique.php. אולי הייתי פשלתי משהו.

660
01:00:31,460 --> 01:00:33,190
'איכשהו' לא צפוי.

661
01:00:38,320 --> 01:00:43,850
יש הולך להיות משהו שעושה את זה בשבילנו.

662
01:00:43,850 --> 01:00:45,820
זה אפילו לא שם.

663
01:00:45,820 --> 01:00:52,140
שים לב, כאשר אתה קורא את המדריך שהטענה הראשונה צפויה להיות מערך

664
01:00:52,140 --> 01:00:56,490
וזה נלקח על ידי הפניה.

665
01:00:58,160 --> 01:01:03,540
למה זה אליי בטענות? כי יש לי סוג פונקציה זו עדיין כאן כי אני לא רוצה.

666
01:01:03,540 --> 01:01:09,210
אוקיי, php.unique.php. אני לא עברתי אותו טיעון, כי אין לי קובץ.

667
01:01:09,210 --> 01:01:13,560
זה php.unique.php על test.php.

668
01:01:13,560 --> 01:01:19,080
הנה test.php הדפיס בכל סדר מיון נחמד.

669
01:01:19,080 --> 01:01:24,600
שימו לב שסדר מיון הוא קצת מוזר לקובץ קוד

670
01:01:24,600 --> 01:01:27,460
מכיוון שכל השורות הריקות שלנו הולכים למקום ראשון

671
01:01:27,460 --> 01:01:30,190
אז תתחילו לבוא כל 1 החריצים ברמה שלנו

672
01:01:30,190 --> 01:01:33,360
אז לבוא כל החריצים לא שלנו.

673
01:01:33,360 --> 01:01:38,620
כן. >> [תלמיד] אז לקוד המקור שלא עבר התייחסות?

674
01:01:38,620 --> 01:01:42,240
האם שעבר בדרך כלל על ידי ערך?

675
01:01:42,240 --> 01:01:50,240
[אודן] כשאתה קורא לפונקציה, זה לא קובע אם זה הועבר על ידי הפניה.

676
01:01:50,240 --> 01:01:53,960
זה הגדרת הפונקציה שקובעת אם זה הועבר על ידי הפניה.

677
01:01:53,960 --> 01:01:59,450
ומסתכל על הגדרת הפונקציה של מיון או פשוט מסתכל על זה,

678
01:01:59,450 --> 01:02:02,820
זה לוקח את הוויכוח על דרך הפניה.

679
01:02:02,820 --> 01:02:07,160
אז בין אם אתה רוצה שזה ייקח את זה על ידי הפניה, זה לוקח את זה על דרך הפניה.

680
01:02:07,160 --> 01:02:10,200
זה משנה את המערך במקום.

681
01:02:10,200 --> 01:02:17,400
זה פשוט לא מותר. אסור לך לעשות את זה. >> [תלמיד] אה, בסדר.

682
01:02:17,400 --> 01:02:22,410
[אודן] זה, סוג הולך לקחת קווים על ידי הפניה ולשנות אותו.

683
01:02:22,410 --> 01:02:26,850
ושוב, אם אתה לא רוצה את זה כדי לעשות את זה, אתה יכול ליצור עותק של מיון.

684
01:02:26,850 --> 01:02:35,850
גם במקרה זה, העתק אינו למעשה העתק של קווים.

685
01:02:35,850 --> 01:02:40,620
זה פשוט מצביע על אותו הדבר עד שהוא מקבל 1 שונה,

686
01:02:40,620 --> 01:02:44,430
איפה זה הולך ראשון שמקבל שונה בפונקצית המיון,

687
01:02:44,430 --> 01:02:50,940
שם, כי זה של העתקה בעת כתיבה, עכשיו עותק של עותק הולך להתבצע.

688
01:02:57,500 --> 01:03:04,250
אתה יכול גם לעשות את זה. זה המקום האחר אתה יכול לראות אמפרסנד.

689
01:03:04,250 --> 01:03:07,190
אתה רואה את זה בלולאות foreach, אתה רואה את זה בהצהרות פונקציות,

690
01:03:07,190 --> 01:03:10,040
ואתה רואה את זה כשרק הקצאה משתנית.

691
01:03:10,040 --> 01:03:12,350
עכשיו יש לנו להשיג דבר על ידי עושה את זה

692
01:03:12,350 --> 01:03:15,600
בגלל העתקה וקווים ממש אותו הדבר.

693
01:03:15,600 --> 01:03:19,940
ניתן להשתמש בקווים ולהעתיק לסירוגין.

694
01:03:19,940 --> 01:03:25,430
אתה יכול לעשות unset (עותק $), ושאינו קווים מוגדרים,

695
01:03:25,430 --> 01:03:29,120
אתה פשוט מאבד את ההתייחסות שלך לאותו הדבר.

696
01:03:29,120 --> 01:03:33,440
אז כמו בשלב זה, עכשיו קווים הוא הדרך היחידה שאתה יכול לגשת לקווים.

697
01:03:36,450 --> 01:03:38,770
>> שאלות?

698
01:03:41,000 --> 01:03:42,460
כן.

699
01:03:42,460 --> 01:03:45,880
[תלמיד] לחלוטין מן הנושא, אבל אין לך לסגור את PHP - >> אתם לא צריכים.

700
01:03:45,880 --> 01:03:47,730
אוקיי.

701
01:03:47,730 --> 01:03:53,790
[אודן] הייתי מרחיק לכת ולומר שזה מעשה רע כדי לסגור אותם.

702
01:03:53,790 --> 01:03:57,580
זה כנראה הגזמה, במיוחד בתסריט,

703
01:03:57,580 --> 01:04:03,740
אבל בואו נראה מה קורה אם אני עושה את זה.

704
01:04:03,740 --> 01:04:08,890
שלא עשה דבר. מה אם אני רוצה - [נאנח]

705
01:04:13,870 --> 01:04:16,960
אני צריך לעבור ויכוח.

706
01:04:19,000 --> 01:04:22,050
לירות. קראתי את זה לא נכון.

707
01:04:24,340 --> 01:04:28,310
אז php.unique.php עם טיעון.

708
01:04:28,310 --> 01:04:30,980
עכשיו אני אפילו לא צריך את זה.

709
01:04:34,520 --> 01:04:37,740
אני אעביר את זה טיעון תקף.

710
01:04:37,740 --> 01:04:42,050
זה כל מה שזה מודפס בהדפסה.

711
01:04:45,260 --> 01:04:50,080
אני מדפיס עותק ועותק לא קיים. אז קווים.

712
01:04:53,650 --> 01:04:58,270
הוא הדפיס את הכל, ואז הבחין בכל הזבל הזה כאן למטה,

713
01:04:58,270 --> 01:05:06,690
כי בכל דבר PHP שהוא מחוץ לתגי PHP

714
01:05:06,690 --> 01:05:09,520
פשוט הולך להיות מודפסים, פשוטו כמשמעו.

715
01:05:09,520 --> 01:05:18,050
לכן ה-HTML, זה כל כך נחמד שאני יכול לעשות div בלה, בלה, בלה כיתה או משהו כזה,

716
01:05:18,050 --> 01:05:25,140
בלה, בלה, בלה ולאחר מכן לעשות קצת קוד PHP ואז לעשות div הסוף.

717
01:05:25,140 --> 01:05:36,460
ועכשיו אני מקבל את זה מדפיס div הנחמד שלי למעלה, כל מה שPHP המודפס, div בתחתית.

718
01:05:36,460 --> 01:05:43,510
אסון כשמשהו כזה קורה, וזה די נפוץ,

719
01:05:43,510 --> 01:05:47,930
רק שורה חדשה תועה בתחתית קובץ.

720
01:05:47,930 --> 01:05:50,940
אתה לא חושב שזה יהיה כל כך גדול של עסקה

721
01:05:50,940 --> 01:05:58,660
עד שאתה מחשיב את העובדה כי עם דפדפנים -

722
01:05:58,660 --> 01:06:03,880
>> איך מפנה עבודה או בעצם כל עבודת כותרות,

723
01:06:03,880 --> 01:06:07,980
כשאתה עושה את החיבור שלך לאתר והוא שולח בחזרה את כל הכותרות והדברים האלה

724
01:06:07,980 --> 01:06:12,020
כמו תגובה 200 או להפנות תגובה או כל דבר אחר,

725
01:06:12,020 --> 01:06:18,230
הכותרות תקפות רק עד לבית הראשון של נתונים נשלחים.

726
01:06:18,230 --> 01:06:23,140
אתה יכול להפנות אותו אלף פעמים, אבל ברגע שהבית הראשון של נתונים נשלחים

727
01:06:23,140 --> 01:06:26,120
אתה לא אמור להפנות שוב.

728
01:06:26,120 --> 01:06:31,860
>> אם יש לך שורה חדשה תועה בתחתית קובץ

729
01:06:31,860 --> 01:06:37,260
ונניח שאתה משתמש בפונקציה זו, ואז אתה רוצה -

730
01:06:41,580 --> 01:06:52,870
בואו נגיד שזה קובץ אחר זה index.php ואתה require_once משהו -

731
01:06:52,870 --> 01:06:56,920
אני לא יכול לחשוב על דוגמה טובה לזה.

732
01:06:56,920 --> 01:07:04,740
הבעיה מתרחשת כאשר קו זה בתחתית מקבל הדהד.

733
01:07:04,740 --> 01:07:08,660
אתה לא רוצה שום דבר כבר הדהד עדיין.

734
01:07:10,820 --> 01:07:15,700
למרות שאתה לא מתכוון על כל דבר מקבל הד, משהו אכן מקבל הדהד

735
01:07:15,700 --> 01:07:17,990
ואז עכשיו אתה לא אמור לשלוח כל עוד כותרות

736
01:07:17,990 --> 01:07:20,030
ואתה הולך לקבל תלונות.

737
01:07:22,170 --> 01:07:24,420
אתה פשוט לא צריך תגיות סגירה אלה.

738
01:07:24,420 --> 01:07:27,420
אם אתה מתכנן לעשות משהו עם HTML -

739
01:07:27,420 --> 01:07:30,490
וזה לגמרי סביר לעשות כאן מה div

740
01:07:30,490 --> 01:07:39,450
ואז בשלב הזה אתה יכול או אינך יכול לכלול אותן.

741
01:07:39,450 --> 01:07:41,590
זה לא ממש משנה.

742
01:07:41,590 --> 01:07:45,450
אבל בהסקריפטים PHP זה נדיר כדי לסגור אותו.

743
01:07:45,450 --> 01:07:50,400
כשהכל זה PHP, ממש הכול,

744
01:07:50,400 --> 01:07:55,460
אתה לא באמת צריך לסגור אותו / אתה לא צריך לסגור אותו.

745
01:08:02,030 --> 01:08:05,720
>> התמודדות עם מחרוזות היא הרבה יותר נחמדה מאשר בג

746
01:08:05,720 --> 01:08:09,470
ב PHP ניתן לציין מחרוזת עם מרכאות בודדות או כפולות.

747
01:08:09,470 --> 01:08:12,820
עם מרכאות בודדות אתה לא יכול להשתמש רצפים "בריחה".

748
01:08:12,820 --> 01:08:17,640
כל זמן לברוח, בלה, בלה, בלה.

749
01:08:19,920 --> 01:08:24,010
אז printf הוא נדיר מאוד ב-PHP.

750
01:08:24,010 --> 01:08:32,290
אני מניח שהייתי משתמש printf אם אני רוצה לעשות דברים כאלה - בpset 5 השתמשת sprintf או משהו כזה.

751
01:08:32,290 --> 01:08:36,060
אבל אתה רוצה לעשות ו001.jpg 002.jpg.

752
01:08:36,060 --> 01:08:40,300
אז בשביל זה סוג הדברים שאני באמת רוצה לעצב את הטקסט הייתי משתמש printf.

753
01:08:40,300 --> 01:08:44,689
אבל חוץ מזה הייתי פשוט להשתמש בחיבור מחרוזות.

754
01:08:44,689 --> 01:08:47,000
אני לא באמת משתמש printf.

755
01:08:49,229 --> 01:09:00,170
אנחנו רק מבדילים את הפרטים בין גרשיים בודדים ומרכאות כפולות.

756
01:09:00,170 --> 01:09:07,490
ההבדל הגדול ביותר הוא שגרשיים בודדים, שהוא יודפס באופן מילולי.

757
01:09:07,490 --> 01:09:15,390
אין סוג הנתונים char ב-PHP, בניגוד C, אז זה שווה את זה.

758
01:09:15,390 --> 01:09:17,970
הם שתי המחרוזות.

759
01:09:17,970 --> 01:09:29,180
והדבר נחמד על מייתרי ציטוט יחידים הוא שאני יכול לומר "שלום העולם!" בלה, בלה, בלה,

760
01:09:29,180 --> 01:09:33,340
wooo $ $.

761
01:09:33,340 --> 01:09:38,260
מה קורה כאשר אני מדפיס את זה הוא שזה יהיה להדפיס אותו, פשוטו כמשמעו.

762
01:09:38,260 --> 01:09:40,680
בואו להיפטר מכל הדברים שלנו.

763
01:09:40,680 --> 01:09:44,700
אז הד str1 $;

764
01:09:48,569 --> 01:09:56,570
הוא הדפיס את כל הדברים האלה, פשוטו כמשמעו: סימני דולר,

765
01:09:56,570 --> 01:09:58,770
קו הנטוי n, שהיית חושב שיהיה שורה חדשה -

766
01:09:58,770 --> 01:10:01,500
את כל הדברים האלה הוא מדפיס באופן מילולי.

767
01:10:01,500 --> 01:10:05,650
הדבר היחיד שאתה צריך לברוח הם ציטוטים בודדים

768
01:10:05,650 --> 01:10:09,470
כי אחר זה הייתי חושב שזה סוגר את הגרשיים הבודדים.

769
01:10:09,470 --> 01:10:15,050
מרכאות כפולות, שונות לחלוטין.

770
01:10:20,300 --> 01:10:25,870
אנחנו כבר רואים את הדגשת התחביר היא cluing על מה שעומד להשתבש לגמרי.

771
01:10:25,870 --> 01:10:36,190
php.unique. לא מוגדר משתנה: wooo כי זה יפורש כמשתנה הנקראת wooo.

772
01:10:36,190 --> 01:10:42,400
מרכאות כפולות מאפשרות לך להכניס את משתנים ל--

773
01:10:42,400 --> 01:10:52,730
בואו נגיד את שם $ = "רוב";

774
01:10:52,730 --> 01:10:58,020
אז הד "היי, השם שלי הוא שם $!";

775
01:10:58,020 --> 01:11:09,260
היא מכירה בזה כמשתנה.

776
01:11:09,260 --> 01:11:21,210
כאשר אני מפעיל את זה - ואני אוסיף שורה חדשה - היי, השם שלי הוא רוב! ושלום עולם!

777
01:11:21,210 --> 01:11:24,910
זאת משום שמעולם לא הסירה את ההדפסה של wooo לעיל.

778
01:11:24,910 --> 01:11:30,020
יש צעד נוסף שאתה יכול לעשות 1.

779
01:11:30,020 --> 01:11:39,250
מערך $ = [1, 2, 3];

780
01:11:39,250 --> 01:11:43,270
מה אם אני רוצה להדפיס את האינדקס הראשון של מערך?

781
01:11:43,270 --> 01:11:45,150
אתה עושה מערך $ [0].

782
01:11:45,150 --> 01:11:49,280
את הדגשת התחביר היא רמז. מה זה יעשה?

783
01:11:52,320 --> 01:11:54,510
php.unique.

784
01:11:54,510 --> 01:11:59,860
היי, השם שלי הוא 1! וזה לא מה שרציתי.

785
01:11:59,860 --> 01:12:05,050
הדגשת תחביר שייקרה לי.

786
01:12:05,050 --> 01:12:13,020
בואו ננסה '"-> 1,' ב '-> 2.

787
01:12:18,450 --> 01:12:21,440
ככה הייתי צריך לכתוב את זה.

788
01:12:26,350 --> 01:12:32,160
ציטוט אחד בלתי צפוי (T_ENCAPSED בלה, בלה, בלה, בלה, בלה).

789
01:12:32,160 --> 01:12:41,780
הרעיון הוא שזה לא מזהה את זה כחלק מהמערך.

790
01:12:41,780 --> 01:12:46,620
זה לא הכרה בכך מערך אינדקס של מכתב.

791
01:12:46,620 --> 01:12:49,870
אתה רוצה לעשות את זה מוקף בסוגריים מסולסלים,

792
01:12:49,870 --> 01:12:54,730
ועכשיו כל מה שהוא בסד מתולתל זה יהיה אינטרפולציה,

793
01:12:54,730 --> 01:13:00,340
שהמילה שאנחנו משתמשים להוספת קסם המשתנים הללו למקומות הנכונים.

794
01:13:00,340 --> 01:13:04,280
עכשיו עושה את זה, php.unique, והיי, השם שלי הוא 1! כצפוי

795
01:13:04,280 --> 01:13:07,720
או היי, השם שלי הוא רוב!

796
01:13:14,110 --> 01:13:23,130
דבר אחד שהוא סוג של נחמד על גרש יחיד הוא ש--

797
01:13:23,130 --> 01:13:28,480
יש כמה עלות לביון.

798
01:13:30,520 --> 01:13:35,100
אם אתה משתמש במרכאות כפולות, המתורגמן יש לעבור על מחרוזת זו,

799
01:13:35,100 --> 01:13:41,500
לוודא כי, "הו, הנה משתנה. עכשיו אני צריך ללכת להביא את המשתנה ושלהכניס אותו לכאן."

800
01:13:41,500 --> 01:13:48,930
גם אם אתה לא משתמש בכל משתנים,

801
01:13:48,930 --> 01:13:52,220
דבר בתוך המרכאות הכפולות הללו צריך להיות אינטרפולציה,

802
01:13:52,220 --> 01:13:56,800
אבל זה עדיין יהיה איטי יותר משום שהוא צריך ללכת על המרכאות הכפולות

803
01:13:56,800 --> 01:14:00,130
מחפש דברים שצריכים אינטרפולציה.

804
01:14:00,130 --> 01:14:05,360
ציטוטים בודדים אז יכולים להיות קצת יותר מהר אם דבר צריך להיות באינטרפולציה,

805
01:14:05,360 --> 01:14:15,650
ואני נוטה גם להשתמש בגרש יחיד ל, "היי, קורא לי '. מערך $ [''] בכל מקרה.

806
01:14:15,650 --> 01:14:20,430
זה הולך להיות שווה ערך למה שהיינו לפני.

807
01:14:24,840 --> 01:14:28,440
אבל זה עניין של העדפה.

808
01:14:28,440 --> 01:14:34,750
אם אתה משתמש ב-PHP, אתה כנראה לא אכפת לי הבדל במהירות.

809
01:14:34,750 --> 01:14:39,480
אין מספיק לחשוב בהיגיון אותם מלכתחילה.

810
01:14:39,480 --> 01:14:43,030
>> איזה שאלות?

811
01:14:47,430 --> 01:14:51,710
>> אנחנו למעשה אפילו לא לעבור את כל זה, אבל הדבר הזה היה משעמם.

812
01:14:51,710 --> 01:14:59,080
הדבר האחרון שדי נחמד בPHP הוא כאשר אתה מתעסק עם HTML,

813
01:14:59,080 --> 01:15:06,450
תוכל להשתמש בו קצת, ולכן תחביר הקיצור הנחמד להדפסה משתנית.

814
01:15:32,400 --> 01:15:36,730
בלי לשים PHP כאן, זה נקרא תגים קצרים.

815
01:15:36,730 --> 01:15:44,330
באופן רשמי כשל PHP 5.4, זו כבר אינה בתוקף.

816
01:15:44,330 --> 01:15:48,640
אתה מומלץ לשים PHP.

817
01:15:48,640 --> 01:15:55,770
זה עדיין נתמך, תגים כל כך קצרים עם <? = הם עדיין בסדר גמורים.

818
01:15:55,770 --> 01:16:02,480
זה נתמך כברירת המחדל, כך שאתה יכול להשתמש באלו כרצונך, והם די נוחים.

819
01:16:02,480 --> 01:16:05,700
>> יש שאלות?

820
01:16:07,780 --> 01:16:09,270
בסדר.

821
01:16:10,840 --> 01:16:13,800
>> הישאר קלאסה, סן דייגו.

822
01:16:13,800 --> 01:16:16,070
[מגחך]

823
01:16:18,620 --> 01:16:22,660
ביי. [צוחק]

824
01:16:24,350 --> 01:16:28,470
[מחיאות כפות] [צוחק]

825
01:22:46,460 --> 01:22:49,460
>> [CS50.TV]