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

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

3
00:00:04,000 --> 00:00:08,000
[זה CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:11,000
>> ברוכים באים לשניים שלנו לסעיף אחרון.

5
00:00:11,000 --> 00:00:13,000
בשבוע זה אנחנו הולכים לדבר על PHP, ואז בשבוע הבא

6
00:00:13,000 --> 00:00:17,000
אנחנו עושים ביקורת קטנה לחידון 1.

7
00:00:17,000 --> 00:00:20,000
אנחנו עומדים להתחיל בעמוד 3 של הבעיה מקובעת חפיסה,

8
00:00:20,000 --> 00:00:28,000
ואנחנו נעבוד כל הקטע של שאלות די מהר.

9
00:00:28,000 --> 00:00:34,000
בעמוד 3, אנחנו מתחילים לדבר על ההבדל הזה בין C ו-PHP

10
00:00:34,000 --> 00:00:38,000
במובן זה שPHP היא שפה דינמית מוקלדת,

11
00:00:38,000 --> 00:00:42,000
ואילו C הקלדה סטטי,

12
00:00:42,000 --> 00:00:46,000
ואף אחד לא עשה שום קידוד במשהו כמו PHP ממש מהר

13
00:00:46,000 --> 00:00:51,000
או Python או Ruby לפני, JavaScript?

14
00:00:51,000 --> 00:00:53,000
חדש לגמרי? אוקיי.

15
00:00:53,000 --> 00:00:56,000
>> כל השפות האלה שהזכרתי זה עתה

16
00:00:56,000 --> 00:01:01,000
שונים מאוד משפות כמו C ו-C + + וג'אווה

17
00:01:01,000 --> 00:01:04,000
במובן זה שכאשר אתה מצהיר על משתנה אתה לא צריך להצהיר על

18
00:01:04,000 --> 00:01:09,000
איזה סוג של משתנה זה, ולכן ב-C היינו תקוע לי תמיד לומר

19
00:01:09,000 --> 00:01:13,000
זה הולך להיות משתנה int, או שזה הולך להיות משתנה * char,

20
00:01:13,000 --> 00:01:16,000
ואילו עם PHP, עם פייתון, עם רובי,

21
00:01:16,000 --> 00:01:20,000
עם הרבה השפות המודרניות יותר האלה אתה לא צריך לעשות את זה בכלל.

22
00:01:20,000 --> 00:01:24,000
אתה פשוט מצהיר משתנה, ובמקרה של PHP

23
00:01:24,000 --> 00:01:28,000
אתה מצהיר שזה משתנה ובהקדים לי סימן $,

24
00:01:28,000 --> 00:01:35,000
ולאחר מכן את הסוג משתנה נקבע על ידי כל ערך שהוא מחזיק,

25
00:01:35,000 --> 00:01:38,000
שזה די מגניב.

26
00:01:38,000 --> 00:01:44,000
לשחק עם זה קצת, יש לנו מדגם קוד PHP ממש כאן

27
00:01:44,000 --> 00:01:47,000
בבין תגי ההתחלה וסיום.

28
00:01:47,000 --> 00:01:53,000
אנחנו משתמשים בסוג זה של כמו HTML, במובן זה

29
00:01:53,000 --> 00:01:56,000
יש לנו הסוגריים האלה כאן כדי לפתוח ולסגור.

30
00:01:56,000 --> 00:01:58,000
אתה רואה את זה ב-HTML.

31
00:01:58,000 --> 00:02:03,000
אתה תראה אותו הסוג של תחביר עם XML מדי.

32
00:02:03,000 --> 00:02:06,000
>> זה מצביע על תחילתו של בלוק PHP.

33
00:02:06,000 --> 00:02:09,000
? Php זה ספציפי ל-PHP.

34
00:02:09,000 --> 00:02:16,000
אנחנו סוגרים את הכל ב?> גם כן.

35
00:02:16,000 --> 00:02:22,000
בואו לפתוח את קובץ במכשיר שלנו באמצעות כל מה שהיית רוצה.

36
00:02:22,000 --> 00:02:25,000
בחבילה הזאת זה אומר להתקשר dynamic.php.

37
00:02:25,000 --> 00:02:29,000
למען אמת, אתה יכול לקרוא לזה איך שתרצה, אבל את שם הקובץ יעלה

38
00:02:29,000 --> 00:02:34,000
ויהיו חשוב מאוחר יותר, כך בדיוק זוכרים את מה שאתה קורא לזה.

39
00:02:34,000 --> 00:02:36,000
אני הולך לעבור למכשיר,

40
00:02:36,000 --> 00:02:43,000
ואני הולך לעשות את ספרייה עבור

41
00:02:43,000 --> 00:02:48,000
סעיף 9 אני מאמין שאנחנו בבית עכשיו.

42
00:02:48,000 --> 00:02:51,000
וגם תלכו לסעיף 9,

43
00:02:51,000 --> 00:02:54,000
ואני הולך להשתמש gedit.

44
00:02:54,000 --> 00:02:59,000
בואו נראים, gedit, ואני הולך לקרוא dynamic.php.

45
00:02:59,000 --> 00:03:03,000
בום.

46
00:03:03,000 --> 00:03:06,000
בתוך dynamic.php, שכן מדובר בקובץ PHP

47
00:03:06,000 --> 00:03:09,000
ואני רוצה להפעיל את זה דרך מתורגמן PHP

48
00:03:09,000 --> 00:03:12,000
אני צריך להתחיל הכל מעם התגים האלה פתוחים,

49
00:03:12,000 --> 00:03:17,000
אז אני הולך להתחיל אלה מייד,

50
00:03:17,000 --> 00:03:23,000
לתת לעצמי מקום קטן בבין התגים,

51
00:03:23,000 --> 00:03:26,000
ואז הנקודה של התרגיל הזה הייתה לשחק עם

52
00:03:26,000 --> 00:03:34,000
פונקציה זו נקראת gettype, כך gettype, פונקציה זו ממש כאן.

53
00:03:34,000 --> 00:03:38,000
>> שימו לב שאין משחקים להבליט או רווח או מקף או משהו כזה

54
00:03:38,000 --> 00:03:42,000
להפריד את 2 מילים, לקבל ולהקליד, רק מילה אחת לגמרי.

55
00:03:42,000 --> 00:03:46,000
אבל מה שזה יעשה הוא אם אני עובר במשתנה לgettype,

56
00:03:46,000 --> 00:03:51,000
אומר var $ או x $,

57
00:03:51,000 --> 00:03:55,000
זה יגיד לי בסוג של פורמט ניפוי

58
00:03:55,000 --> 00:03:59,000
מה שמו של סוג זה הוא.

59
00:03:59,000 --> 00:04:03,000
אנחנו הולכים להתנסות כאן.

60
00:04:03,000 --> 00:04:07,000
בפרט, אם אתה מסתכל אחורה בpset המפרט

61
00:04:07,000 --> 00:04:11,000
יש לנו כמה קווים שונים של קוד כאן.

62
00:04:11,000 --> 00:04:16,000
בשורה הראשונה של קוד אנחנו לאתחל משתנים זה, $ var,

63
00:04:16,000 --> 00:04:21,000
להיות שווה ל7, ולאחר מכן יש לנו קו printf זה

64
00:04:21,000 --> 00:04:25,000
שאומר היי, var printf הוא ריק.

65
00:04:25,000 --> 00:04:29,000
Printf הוא אחת מהדרכים הרבות שאנו יכולים להדפיס דברים ב-PHP.

66
00:04:29,000 --> 00:04:33,000
לעתים קרובות אתה רואה את תפקידו ההד להשתמש במקום printf,

67
00:04:33,000 --> 00:04:40,000
אבל printf כולנו מכירים לאחר שהקידוד ב-C לזמן מה.

68
00:04:40,000 --> 00:04:42,000
מה שאתה בעצם יכול לעשות זה בוא נראה אם ​​עבודות העתקה והדבקה.

69
00:04:42,000 --> 00:04:46,000
אני הולך לתת את זה לנסות.

70
00:04:46,000 --> 00:04:52,000
אנחנו נחזור שוב למכשיר.

71
00:04:52,000 --> 00:05:00,000
אוקיי, ויש לנו ללכת.

72
00:05:00,000 --> 00:05:05,000
ומרווח הוא קצת מסריח, אבל הנה זה בא.

73
00:05:05,000 --> 00:05:08,000
יש לנו את הקוד הזה בפה.

74
00:05:08,000 --> 00:05:11,000
>> [סטודנטים] האם זה סגנון לא טוב לכרטיסייה זה?

75
00:05:11,000 --> 00:05:13,000
סליחה?

76
00:05:13,000 --> 00:05:15,000
[סטודנטים] האם זה מקובל לכרטיסייה זה?

77
00:05:15,000 --> 00:05:21,000
בסדר, אז סם שואל אם זה כנס לכרטיסייה זה או לא.

78
00:05:21,000 --> 00:05:23,000
בדרך כלל כן.

79
00:05:23,000 --> 00:05:26,000
במקרה הזה אני בחרתי שלא.

80
00:05:26,000 --> 00:05:33,000
בכנות, אתה תראה דברים שונים בקרב מתכנתים שונים.

81
00:05:33,000 --> 00:05:40,000
PHP משמש בדרך כלל לעתים קרובות בשילוב עם HTML

82
00:05:40,000 --> 00:05:45,000
ובשפות אחרות, ואז לפעמים ההדפסה תיראה קצת מסריח

83
00:05:45,000 --> 00:05:50,000
אם כניסה בתחילת PHP ותגי סיום.

84
00:05:50,000 --> 00:05:53,000
זה מאוד תלוי.

85
00:05:53,000 --> 00:05:56,000
במקרה זה העתק ודבק לא להדביק את הכרטיסיות בבשבילי,

86
00:05:56,000 --> 00:06:02,000
אבל זה בהחלט, כמו שאמרת, לעשות את זה ברור יותר.

87
00:06:02,000 --> 00:06:06,000
בסדר, אם תשמור את הקוד הזה בdynamic.php

88
00:06:06,000 --> 00:06:10,000
אז מה שאתה יכול לעשות זה לבוא אל חלון המסוף שבו אני צודק כאן

89
00:06:10,000 --> 00:06:17,000
בgedit, ולעשות את המקבילה של הידור

90
00:06:17,000 --> 00:06:20,000
משתמש לבצע ולאחר מכן להפעיל את הקוד שלך ב-C

91
00:06:20,000 --> 00:06:25,000
כל מה שאתה צריך לעשות עם קובץ ה-PHP הוא להתחיל מתורגמן PHP,

92
00:06:25,000 --> 00:06:30,000
שהיא תכנית קטנה בשם PHP,

93
00:06:30,000 --> 00:06:35,000
והטיעון שאתה נותן למתורגמן הוא הקובץ שאתה רוצה לפרש.

94
00:06:35,000 --> 00:06:40,000
במקרה זה, dynamic.php.

95
00:06:40,000 --> 00:06:43,000
אופס, איפה שמתי את זה?

96
00:06:43,000 --> 00:06:52,000
אה, שמתי אותו בסעיף 9, והנה אני כאן. זה למה.

97
00:06:52,000 --> 00:06:57,000
>> עכשיו אם אני מפעיל את זה שוב

98
00:06:57,000 --> 00:07:02,000
אנו רואים כי בקריאה לפונקצית gettype הראשונה שלי

99
00:07:02,000 --> 00:07:04,000
var הוא מספר שלם.

100
00:07:04,000 --> 00:07:12,000
בvar הבא אחד היא מחרוזת, ולאחר מכן בvar השליש הוא בוליאני.

101
00:07:12,000 --> 00:07:15,000
מה שמעניין בכל זה הוא אם אנחנו לגלול חזרה אנו רואים כי

102
00:07:15,000 --> 00:07:18,000
אלה הם סוגים דומים לאלה שהיו לנו בג

103
00:07:18,000 --> 00:07:22,000
היו לנו ints בג

104
00:07:22,000 --> 00:07:26,000
אנחנו די היינו מחרוזות ב-C,

105
00:07:26,000 --> 00:07:31,000
כך המחרוזות לא היו סוג לגמרי לגיטימי במובן זה

106
00:07:31,000 --> 00:07:37,000
מחרוזת CS50 הייתה באמת מה?

107
00:07:37,000 --> 00:07:39,000
סליחה? מסים?

108
00:07:39,000 --> 00:07:41,000
[מסים] char *.

109
00:07:41,000 --> 00:07:43,000
כן, זה היה * char זו עשתה שימוש.

110
00:07:43,000 --> 00:07:47,000
ממש בתחילתו של הסמסטר שהיינו באמצעות טיפוס המחרוזת,

111
00:07:47,000 --> 00:07:52,000
אבל זה היה באמת דמות * מתחת למכסת המנוע.

112
00:07:52,000 --> 00:07:58,000
אנחנו פשוט סוג מוגדר זה, ואילו ב-PHP המייתרים האלה הם סוג של ממש.

113
00:07:58,000 --> 00:08:07,000
אין עוד חומר של טיפוס * char זה.

114
00:08:07,000 --> 00:08:10,000
>> אתה תראה שאנחנו יכולים לעשות הרבה יותר דברים עם מחרוזות

115
00:08:10,000 --> 00:08:14,000
הרבה יותר בקלות מאשר ב-PHP שיכולנו ב-C,

116
00:08:14,000 --> 00:08:17,000
ולבסוף, יש לנו סוג בוליאני זה, וההבדל הגדול כאן הוא ש

117
00:08:17,000 --> 00:08:21,000
אם אנחנו לגלול למטה אנו רואים ששמו של סוגים אלה

118
00:08:21,000 --> 00:08:28,000
כעת, מחרוזת שלמה, ווליאני במקום int וbool,

119
00:08:28,000 --> 00:08:31,000
כפי שאתה לאסוף את שפות תכנות שונות ו,

120
00:08:31,000 --> 00:08:36,000
בהנחה שבשלב כלשהו בחייך שאתה בא במגע עם

121
00:08:36,000 --> 00:08:40,000
אלה שונים יוכלו להבחין מוזרויות קטנות כמו זה

122
00:08:40,000 --> 00:08:44,000
כאשר C קורא ints מספרים השלמים.

123
00:08:44,000 --> 00:08:46,000
יש כאלה שקוראים אותו שלמים.

124
00:08:46,000 --> 00:08:51,000
יש תנאים אחרים שאתה נתקלת בם.

125
00:08:51,000 --> 00:08:55,000
int הגדול שראינו היום ב-SQL.

126
00:08:55,000 --> 00:08:59,000
ישנם גם מספר ולאחר מכן bool, וליאני,

127
00:08:59,000 --> 00:09:03,000
כל מיני הבדלים שם.

128
00:09:03,000 --> 00:09:07,000
>> זה לא ממש מעניין, אבל עכשיו אני הולך לתת לך קצת זמן

129
00:09:07,000 --> 00:09:13,000
אם להתקרב חזרה לעבודה דרך התרגיל הזה בתחתית העמוד 3

130
00:09:13,000 --> 00:09:20,000
שם הוא שואל מה סוגים מתאימים לערכים אלה כאן בתחתית.

131
00:09:20,000 --> 00:09:24,000
יש לנו 3.50.

132
00:09:24,000 --> 00:09:28,000
יש לנו את הדבר הזה ממש כאן, וזה מעניין.

133
00:09:28,000 --> 00:09:32,000
לא ראינו את זה קודם, למרות שאם אתה כבר לאחר יחד בהרצאה

134
00:09:32,000 --> 00:09:35,000
אתם בטח כבר יודעים מה זה.

135
00:09:35,000 --> 00:09:40,000
אז יש לנו את זה, שזה סוג של פאנקי.

136
00:09:40,000 --> 00:09:42,000
אתה מכיר את זה.

137
00:09:42,000 --> 00:09:46,000
מה זה ב-C?

138
00:09:46,000 --> 00:09:50,000
סם? מה זה נותן לך ב-C?

139
00:09:50,000 --> 00:09:54,000
זה יהיה לפתוח קובץ שנקרא dynamic.php ולהפוך אותו לקריא.

140
00:09:54,000 --> 00:09:58,000
כן, ומה יהיה הסוג המשתנה שהיינו להקצות לזה? כוכב קובץ. >>

141
00:09:58,000 --> 00:10:02,000
בדיוק, היינו להקצות זה לכוכב קובץ.

142
00:10:02,000 --> 00:10:08,000
זה לגיטימי מדי PHP.

143
00:10:08,000 --> 00:10:12,000
הפעל את זה. ראה מה קורה כאשר אתה עובר את זה לתוך gettype.

144
00:10:12,000 --> 00:10:19,000
ואז גם לבדוק מה הוא null, מה שעשוי להיות ב-PHP.

145
00:10:19,000 --> 00:10:21,000
אני אתן לך כמה דקות.

146
00:10:21,000 --> 00:10:24,000
אתה ממש יכול להעתיק ולהדביק את הערכים הללו ב,

147
00:10:24,000 --> 00:10:29,000
ואז אנחנו נעשה את שיחה אקראית קטנה עליך

148
00:10:29,000 --> 00:10:34,000
ולראות מה יש לך.

149
00:10:34,000 --> 00:10:36,000
>> [סטודנטים] יש לי שאלה. << כן.

150
00:10:36,000 --> 00:10:40,000
באחת ההרצאות שאמר דוד יש משהו שאתה יכול לשים בחלק העליון של הקובץ שלך

151
00:10:40,000 --> 00:10:43,000
כך שאתה לא צריך להקליד ב-PHP בכל פעם.

152
00:10:43,000 --> 00:10:45,000
מה זה היה?

153
00:10:45,000 --> 00:10:50,000
כנראה שהוא מדבר על מפץ הק"ג, מפץ החשיש.

154
00:10:50,000 --> 00:10:57,000
זה הוראה שאם אתה מסמן את הקובץ כהפעלה

155
00:10:57,000 --> 00:11:01,000
אז מה שהוא עושה הוא כאשר אתה להפעיל את הקובץ

156
00:11:01,000 --> 00:11:06,000
את זה יגיד לי תכנית הפגז

157
00:11:06,000 --> 00:11:12,000
כדי להשתמש במתורגמן PHP כדי לפרש את תוכנו של הקובץ.

158
00:11:12,000 --> 00:11:16,000
השאלה היא מה היה הקו המיוחד הזה

159
00:11:16,000 --> 00:11:20,000
שאנחנו יכולים לכלול בחלק העליון של קבצי PHP שלנו לא צריך לכלול

160
00:11:20,000 --> 00:11:26,000
קו זה PHP או פקודת PHP זה בכל פעם שאנחנו רוצים להפעיל את הקובץ?

161
00:11:26,000 --> 00:11:31,000
ואתה באמת יכול לעשות את זה עם חבורה של קבצים שונים.

162
00:11:31,000 --> 00:11:37,000
אני מאמין שזה תלוי במיקום בינארי PHP מאוחסן,

163
00:11:37,000 --> 00:11:43,000
אך לעתים קרובות usr / bin / php הוא מקום טוב להתחיל בו.

164
00:11:43,000 --> 00:11:45,000
אתה יכול להבין את זה בדיוק על ידי הולך שוב למכשיר שלך

165
00:11:45,000 --> 00:11:50,000
ולהקליד בו PHP.

166
00:11:50,000 --> 00:11:55,000
הפקודה שחשבה וכשאתה מבצע בינארי

167
00:11:55,000 --> 00:12:01,000
או פקודה שבו הקובץ המתאים היא.

168
00:12:01,000 --> 00:12:06,000
זה אומר לי שPHP היא באמת כינוי זה קובץ בינארי

169
00:12:06,000 --> 00:12:13,000
ששומר בusr / bin, אשר בו הרבה קבצים הבינאריים של המערכת מותקנת.

170
00:12:13,000 --> 00:12:21,000
לדוגמה, אם אני לגלול עד למעלה, עכשיו אחרי ששמתי את זה #! קו כאן

171
00:12:21,000 --> 00:12:27,000
אני יכול לגלול למטה, ואני יכול לנסות להפעיל

172
00:12:27,000 --> 00:12:35,000
dynamic.php, אבל אני מקבל את הודעת השגיאה על אישור שנדחה,

173
00:12:35,000 --> 00:12:42,000
ומה שזה אומר זה שקובץ זה אינו כרגע נותן הרשאות הפעלה.

174
00:12:42,000 --> 00:12:46,000
זה שאינו מסומן כקובץ שמישהו יכול לרוץ.

175
00:12:46,000 --> 00:12:52,000
>> כשרצת לעשות או קלאנג ויש לך הפעלה מזה

176
00:12:52,000 --> 00:12:56,000
המהדר היה חכם מספיק כדי לדעת כי היי, אני בונה הפעלה.

177
00:12:56,000 --> 00:13:00,000
אתה כנראה רוצה לבצע את זה, כך שזה יהיה להגדיר באופן אוטומטי

178
00:13:00,000 --> 00:13:02,000
את ההרשאות עבורך.

179
00:13:02,000 --> 00:13:06,000
אלא שאין זה המקרה, בעת יצירת קובץ רגיל מאפסת,

180
00:13:06,000 --> 00:13:13,000
הסיבה שבדרך כלל אתה לא רוצה להיות כל קובץ במערכת שלך תהיה הפעלה,

181
00:13:13,000 --> 00:13:15,000
אז אתה בעצם צריך ללכת באופן ידני ולעשות את זה.

182
00:13:15,000 --> 00:13:22,000
הדרך הקלה ביותר לעשות זאת היא בעזרת פקודת chmod,

183
00:13:22,000 --> 00:13:28,000
וchmod + x אומר להוסיף קצת ההפעלה

184
00:13:28,000 --> 00:13:31,000
בגלל שיש קצת הקריאה, קצת כתיבה וקצת ההפעלה,

185
00:13:31,000 --> 00:13:35,000
r, W ו-X,

186
00:13:35,000 --> 00:13:39,000
ואומר chmod + x יהיה להפעיל קצת ההפעלה

187
00:13:39,000 --> 00:13:46,000
אז לקובץ שציינו, שבמקרה זה יהיה dynamic.php.

188
00:13:46,000 --> 00:13:49,000
>> [סטודנטים] שמופעלים לכולם?

189
00:13:49,000 --> 00:13:52,000
בואו לבדוק את זה, אז איך אני יכול לבדוק את ההרשאות?

190
00:13:52,000 --> 00:13:54,000
אתה יודע כמה הייתי לבדוק את ההרשאות של קובץ?

191
00:13:54,000 --> 00:13:56,000
[תגובת תלמיד לא נשמעה]

192
00:13:56,000 --> 00:13:58,000
סליחה? >> [סטודנטים] XSD.

193
00:13:58,000 --> 00:14:03,000
XSD נותן לנו את הקובץ בפריצות.

194
00:14:03,000 --> 00:14:09,000
המפרט את כל הקבצים,-L, יציג את כל קבציי בספרייה שלי

195
00:14:09,000 --> 00:14:13,000
סוג של ב, הרישום המפורט הארוך שלהם, ואז הנה אנו רואים כי

196
00:14:13,000 --> 00:14:17,000
קובץ זה dynamic.php

197
00:14:17,000 --> 00:14:23,000
שונה לאחרונה 5 בנובמבר בשעה 4:21.

198
00:14:23,000 --> 00:14:26,000
הבעלים של קובץ זה jharvard.

199
00:14:26,000 --> 00:14:28,000
זה המשתמש שנכנס פנימה

200
00:14:28,000 --> 00:14:31,000
זה המשתמש אני עובד בתור,

201
00:14:31,000 --> 00:14:36,000
ואם אתה גם במכשיר שאתה עובד גם כjharvard משתמש.

202
00:14:36,000 --> 00:14:38,000
אתה בקבוצת התלמידים,

203
00:14:38,000 --> 00:14:44,000
ואלה הם דברים שאתה רואה לעתים קרובות מספיק.

204
00:14:44,000 --> 00:14:47,000
>> אנחנו יכולים להיכנס לפרטים רבים כאן,

205
00:14:47,000 --> 00:14:50,000
אבל על פי רוב מה שאתה רוצה להסתכל כאשר אתה מחפש לראות

206
00:14:50,000 --> 00:14:55,000
הפעלה או לא קובץ הוא בעיקר

207
00:14:55,000 --> 00:14:58,000
המשתמש שבעלים של הקובץ, הבעלים,

208
00:14:58,000 --> 00:15:03,000
כך jharvard זה, ולאחר מכן יש לנו

209
00:15:03,000 --> 00:15:07,000
את ביטי הרשאות לכאן משמאל,

210
00:15:07,000 --> 00:15:13,000
והדרך לקריאה זו היא שהחלק האחרון

211
00:15:13,000 --> 00:15:18,000
בדרך כלל משמש לסימון או לא, לפחות במקרה זה

212
00:15:18,000 --> 00:15:21,000
הקטע האחרון לעתים קרובות יוגדר מודעה כדי להצביע

213
00:15:21,000 --> 00:15:24,000
שהקובץ הוא ספרייה ולא רק קובץ רגיל.

214
00:15:24,000 --> 00:15:28,000
לאחר מכן את 3 הביטים הבאים ממש כאן

215
00:15:28,000 --> 00:15:34,000
לקבוע את ההרשאות שהבעלים של הקובץ יש לו,

216
00:15:34,000 --> 00:15:38,000
ולכן במקרה jharvard זה, כבעלים של הקובץ, יכול לקרוא ולכתוב בקובץ זה,

217
00:15:38,000 --> 00:15:42,000
אבל יש אומר שמקף jharvard לא יכול לבצע את הקובץ.

218
00:15:42,000 --> 00:15:46,000
את 3 הביטים הבאים הם לקבוצה, כך שזו קבוצת התלמידים,

219
00:15:46,000 --> 00:15:49,000
כך שאם היו משתמשים רבים במכשיר שלי,

220
00:15:49,000 --> 00:15:52,000
והיו לנו מספר רבים של משתמשים, כחלק מקבוצת התלמידים,

221
00:15:52,000 --> 00:15:55,000
אז כולם יכול לקרוא את הקובץ הזה, אבל הם לא יכולים לכתוב את זה,

222
00:15:55,000 --> 00:15:59,000
וכך גם כל אדם אחר, העולם

223
00:15:59,000 --> 00:16:01,000
יכול רק לקרוא את הקובץ הזה גם כן.

224
00:16:01,000 --> 00:16:03,000
יש writeup טוב, הרבה על זה,

225
00:16:03,000 --> 00:16:05,000
כך שאתה יכול לקרוא באינטרנט.

226
00:16:05,000 --> 00:16:10,000
במפרט סט הבעיה שנתעמק בזה בפירוט רב יותר.

227
00:16:10,000 --> 00:16:12,000
>> [סטודנטים] האם 218 מתייחסים לעולם?

228
00:16:12,000 --> 00:16:17,000
218 הן, את החלק העליון של הראש שלי אני שוכח,

229
00:16:17,000 --> 00:16:20,000
אבל לא.

230
00:16:20,000 --> 00:16:29,000
בואו נראים. אני blanking על זה כרגע.

231
00:16:29,000 --> 00:16:32,000
לחזור למה שהיינו אמור לעשות עם chmod + x זה

232
00:16:32,000 --> 00:16:37,000
שבו אנחנו רוצים לתת הרשאות הפעלת dynamic.php,

233
00:16:37,000 --> 00:16:40,000
והשאלה הייתה אם זה היה נותן הרשאות הפעלה לכולם

234
00:16:40,000 --> 00:16:44,000
או לסתם jharvard, ואנחנו יכולים לראות את זה על ידי

235
00:16:44,000 --> 00:16:48,000
הרצת הפקודות והקלדת ls-l,

236
00:16:48,000 --> 00:16:51,000
ועכשיו אנחנו רואים שהיא מסומנת כהפעלה.

237
00:16:51,000 --> 00:16:54,000
אתה רואה שיש שינוי צבע.

238
00:16:54,000 --> 00:16:57,000
עכשיו dynamic.php מופיע בירוק,

239
00:16:57,000 --> 00:17:01,000
וזה נראה כמו התשובה לשאלה היא מה, שרלוט?

240
00:17:01,000 --> 00:17:04,000
[שארלוט] רק jharvard. >> רק jharvard, כן.

241
00:17:04,000 --> 00:17:08,000
>> אם אנחנו רוצים להפוך קצת על ההפעלה לכולם

242
00:17:08,000 --> 00:17:10,000
איך ניתן לעשות זאת?

243
00:17:10,000 --> 00:17:13,000
כל מחשבות? >> + X?

244
00:17:13,000 --> 00:17:15,000
כן, בדיוק.

245
00:17:15,000 --> 00:17:23,000
שרלוט אמרה שאנחנו יכולים לעשות chmod של + x של dynamic.php,

246
00:17:23,000 --> 00:17:26,000
ועכשיו אם אנחנו רצים ls-l אנו רואים שאת ביטי ההפעלה

247
00:17:26,000 --> 00:17:30,000
הם פנו אכן בכולם.

248
00:17:30,000 --> 00:17:37,000
ואתה יכול בעצם לעשות את ההפך מזה, כך שאתה יכול לכבות אותו לכולם

249
00:17:37,000 --> 00:17:41,000
שימוש במינוס.

250
00:17:41,000 --> 00:17:46,000
עכשיו הוא כבוי, ועכשיו אנחנו יכולים להפעיל אותו מחדש לjharvard

251
00:17:46,000 --> 00:17:52,000
כדי שנוכל להפעיל אותו דווקא עכשיו,

252
00:17:52,000 --> 00:17:58,000
ועכשיו אתה רואה כאשר אנו מפעילים את הקוד המיוחד הזה #! קו בחלקו העליון,

253
00:17:58,000 --> 00:18:04,000
#! קו, ספר את הקליפה,

254
00:18:04,000 --> 00:18:08,000
אמר לנו המסוף היי, כאשר קובץ זה מופעל,

255
00:18:08,000 --> 00:18:14,000
להשתמש / usr / bin / php לפרש את הקובץ הזה

256
00:18:14,000 --> 00:18:20,000
ולאחר מכן להדפיס את הפלט.

257
00:18:20,000 --> 00:18:22,000
[שאלת תלמיד לא נשמעה]

258
00:18:22,000 --> 00:18:25,000
בטח, בואו לגלול אותי בחזרה למעלה. בדיוק כמו זה.

259
00:18:25,000 --> 00:18:36,000
אתה תראה את כל ההנחיות הללו מתחילות עם חץ ק"ג זה ולאחר מכן הסימן הקריא,

260
00:18:36,000 --> 00:18:39,000
המכונה לעתים מפץ עסק, חשיש.

261
00:18:39,000 --> 00:18:48,000
>> [סטודנטים] איך אנחנו יכולים להפעיל אותו עם dynamic.php php לפני שאנחנו עושים את זה לביצוע?

262
00:18:48,000 --> 00:18:55,000
השאלה הייתה איך אנחנו יכולים להפעיל את זה באמצעות PHP ינארי

263
00:18:55,000 --> 00:18:58,000
בעוד dynamic.php הוא אינם ניתן לביצוע?

264
00:18:58,000 --> 00:19:01,000
זה סופר חשוב כי זה בדיוק איך

265
00:19:01,000 --> 00:19:06,000
זה הולך לעבוד כשאתה כותב סדרת בעיה 7.

266
00:19:06,000 --> 00:19:09,000
רוב קבצי PHP הזמן הם לא באופן ישיר לביצוע.

267
00:19:09,000 --> 00:19:14,000
הדרך שעובדת היא בגלל שזה בינארי PHP זה הפעלה.

268
00:19:14,000 --> 00:19:16,000
המתורגמן הוא הדבר המוצא להורג,

269
00:19:16,000 --> 00:19:20,000
ואז מה שהוא עושה הוא ממש slurping בכל התוכן

270
00:19:20,000 --> 00:19:25,000
של קובץ dynamic.php והקו הולך לפי קו

271
00:19:25,000 --> 00:19:29,000
וביצוע פקודות אלה, כך שמשתמש בקובץ ה-PHP שלנו

272
00:19:29,000 --> 00:19:31,000
כרשימה של הוראות.

273
00:19:31,000 --> 00:19:36,000
זה לא ישירות של הרצתו.

274
00:19:36,000 --> 00:19:40,000
זה שבו אנחנו אומרים שהקבצים הללו מתפרשים בזמן ריצה.

275
00:19:40,000 --> 00:19:46,000
זו שפת זמן ריצה במקום משהו שנקבע בזמן הידור,

276
00:19:46,000 --> 00:19:49,000
לא שפת הידור כמו ג

277
00:19:49,000 --> 00:19:54,000
>> האם יש דרך לקבל את שפת זמן ריצה להתנהג כאילו זה שפה לקמפל זמן,

278
00:19:54,000 --> 00:19:58,000
כמו שאם יש לך את כל שנעשה בשרת בו פועל

279
00:19:58,000 --> 00:20:00,000
ולא, אתה יודע למה אני מתכוון?

280
00:20:00,000 --> 00:20:04,000
כן, אז השאלה היא

281
00:20:04,000 --> 00:20:11,000
האם יש דרך לקבל שפות זמן ריצה לפעול יותר כמו סוגי הזמן לקמפל של שפות?

282
00:20:11,000 --> 00:20:18,000
ויש, אני מתכוון, שהוא אזור פעיל של מחקר להרבה מהחברות הללו.

283
00:20:18,000 --> 00:20:22,000
אני מאמין שפייסבוק עשה הרבה עבודה עם PHP

284
00:20:22,000 --> 00:20:25,000
והידור אותו, הופך אותו מהר יותר, אופטימיזציה שלה

285
00:20:25,000 --> 00:20:29,000
מאז האתר שלהם בנוי על PHP.

286
00:20:29,000 --> 00:20:34,000
אם אתה עוקב אחרי node.js בכלל,

287
00:20:34,000 --> 00:20:40,000
שהוא סוג של מתורגמן JavaScript

288
00:20:40,000 --> 00:20:44,000
כדי להיות מסוגל להפעיל JavaScript מחוץ לדפדפן, מחוץ לדפדפן האינטרנט שלך,

289
00:20:44,000 --> 00:20:47,000
משום שאופן מסורתי הייתי פשוט להפעיל JavaScript הפנימי של פיירפוקס או כרום,

290
00:20:47,000 --> 00:20:52,000
וזה הייתי לשמש להכנת אנימציות מגניבות יקרו בדף אינטרנט

291
00:20:52,000 --> 00:20:55,000
ולהפוך את דף האינטרנט שלך דינמי.

292
00:20:55,000 --> 00:20:59,000
זה כבר בנוי על הרבה עבודה שגוגל עשתה

293
00:20:59,000 --> 00:21:03,000
כדי להפוך את JavaScript ו-C + +

294
00:21:03,000 --> 00:21:09,000
נקשר יחדיו, כך שאין הרבה מחקר הפעיל

295
00:21:09,000 --> 00:21:13,000
לקבל השפות הבאות כדי אינטראקציה ולייעל אותם,

296
00:21:13,000 --> 00:21:17,000
בעיקר משום שכל כך הרבה אנשים יכולים קוד ב-PHP ו-JavaScript

297
00:21:17,000 --> 00:21:19,000
כי זה הרבה יותר קל.

298
00:21:19,000 --> 00:21:21,000
זה הרבה יותר נחמד. אתה לא צריך עצות.

299
00:21:21,000 --> 00:21:27,000
אין לך סוגים מרחפים.

300
00:21:27,000 --> 00:21:31,000
הם רצו לקבל את היתרונות של שפות אלה הזמן לקמפל

301
00:21:31,000 --> 00:21:36,000
עם כל סוג הבדיקה ואת המהירות ואת השימוש בזיכרון הנמוך וכל זה

302
00:21:36,000 --> 00:21:42,000
תוך שמירה על הגמישות וקלת שימוש של אלה חדשים אלה.

303
00:21:42,000 --> 00:21:46,000
>> בחזרה לתכנית המקורית שלנו להתקפה.

304
00:21:46,000 --> 00:21:50,000
יש לנו כמה מהשאלות האלה כאן במפרט סט הבעיה שלנו.

305
00:21:50,000 --> 00:21:54,000
בואו נעבור אותם מהר מאוד, ואנחנו נלך מסביב לחדר.

306
00:21:54,000 --> 00:21:59,000
שרלוט, איזה סוג היא 3.50?

307
00:21:59,000 --> 00:22:01,000
[שארלוט] זה כפול. >> זה כפול.

308
00:22:01,000 --> 00:22:03,000
ג'ימי, מה זה הבא? >> מערך.

309
00:22:03,000 --> 00:22:09,000
מערך, מדהים, וג'ארד, מה הוא fopen?

310
00:22:09,000 --> 00:22:11,000
[ג'ארד] זה משאב. >> זה משאב.

311
00:22:11,000 --> 00:22:15,000
זה סוג של אחד חדש, לא כוכב קובץ, ולא קובץ.

312
00:22:15,000 --> 00:22:19,000
זה משאב הוא הסוג ב-PHP,

313
00:22:19,000 --> 00:22:24,000
ואני מצטער, אלה, null האחרון הם מה?

314
00:22:24,000 --> 00:22:26,000
Null.

315
00:22:26,000 --> 00:22:28,000
ריק, איך מאיית את זה ב-PHP? >> אותה הדרך.

316
00:22:28,000 --> 00:22:30,000
באותה הדרך, בירות? >> כן.

317
00:22:30,000 --> 00:22:33,000
כן, בסדר.

318
00:22:33,000 --> 00:22:35,000
הנה, יש לנו כפול, יש לנו מערך,

319
00:22:35,000 --> 00:22:41,000
יש לנו משאבים, ולאחר מכן יש לנו אפס.

320
00:22:41,000 --> 00:22:48,000
בואו נראים עכשיו יש לך לראות,

321
00:22:48,000 --> 00:22:51,000
בואו נראים, אז עכשיו אני מניח שאני גם רוצה לעשות היא למשוך את

322
00:22:51,000 --> 00:22:56,000
דף אינטרנט זה ממש כאן, זה php.net / ידני,

323
00:22:56,000 --> 00:23:01,000
כך שאם אתם מעתיקים את זה ולפתוח את דפדפן אינטרנט.

324
00:23:01,000 --> 00:23:07,000
אני הולך למשוך את הכרום, שהכניס פנימה

325
00:23:07,000 --> 00:23:10,000
אני רוצה להראות לך את זה לא רק בגלל

326
00:23:10,000 --> 00:23:13,000
אנחנו יכולים לדבר כל היום על סוגים וכל זה כיף

327
00:23:13,000 --> 00:23:19,000
אלא משום שזה הוא המדריך של PHP,

328
00:23:19,000 --> 00:23:23,000
ויש הרבה מתכנתי PHP שם בחוץ.

329
00:23:23,000 --> 00:23:26,000
יש הרבה אתרי האינטרנט PHP שם בחוץ,

330
00:23:26,000 --> 00:23:31,000
וכתוצאה מכך, יש הרבה תיעוד על PHP,

331
00:23:31,000 --> 00:23:36,000
והידני, php.net זה, הוא באמת מקום טוב ללכת

332
00:23:36,000 --> 00:23:43,000
בכל פעם שיש לך שאלות על מהי הדרך הטובה ביותר לעשות X ב-PHP

333
00:23:43,000 --> 00:23:45,000
או מה פונקציה נראית?

334
00:23:45,000 --> 00:23:49,000
פשוט סוג של היכרות עם מה שזה נראה, כי

335
00:23:49,000 --> 00:23:54,000
אתה תבוא לכאן לעתים קרובות, קצת לבעיה להגדיר 7.

336
00:23:54,000 --> 00:23:57,000
>> אם בסופו של דבר עושה פרויקט גמר המשתמש PHP

337
00:23:57,000 --> 00:24:04,000
זה יהיה מקום שאהיה מכיר היטב.

338
00:24:04,000 --> 00:24:09,000
לעתים קרובות כמו שאנשים עושים את זה הוא שהם משתמשים ב-Google לחיפוש באתר,

339
00:24:09,000 --> 00:24:16,000
והם לא משתמשים בתיבת החיפוש שנמצאת פה בפינה הימנית העליונה, שהוא סוג של קטנטן.

340
00:24:16,000 --> 00:24:19,000
אם אתה Googling מחפש משהו שתוכל לעשות עם PHP ואתה רואה

341
00:24:19,000 --> 00:24:24,000
אחד מהקישורים הידניים לצוץ אתה בדרך כלל יכול לסמוך על זה

342
00:24:24,000 --> 00:24:31,000
כמשאב טוב למדי.

343
00:24:31,000 --> 00:24:34,000
מדהים, זאת מתוך סוגים אלה, רק מתוך סקרנות,

344
00:24:34,000 --> 00:24:37,000
אילו האם לא ראה?

345
00:24:37,000 --> 00:24:40,000
שום דבר שלא ראה כאן?

346
00:24:40,000 --> 00:24:44,000
[סטודנטים] משאבים. >> ראינו משאב עם שיחת fopen.

347
00:24:44,000 --> 00:24:48,000
[סטודנטים] אובייקטים. >> אובייקטים שלא ראו בודאות.

348
00:24:48,000 --> 00:24:51,000
Callbacks שלא ראו.

349
00:24:51,000 --> 00:24:54,000
יש כמה מן פסאודו סוגים אלה.

350
00:24:54,000 --> 00:24:57,000
אנחנו בהחלט ראינו רק מספר שלם וכפול.

351
00:24:57,000 --> 00:25:01,000
לא ראינו כמה מהאחרים, ולכן, אם נלחץ על מספרים שלמים

352
00:25:01,000 --> 00:25:08,000
אנו יכולים לראות האם יש מספרים שלמים אחרים שיש להם כאן?

353
00:25:08,000 --> 00:25:11,000
האם הם כל כך שלמים, מספר שלם, מספר שלם.

354
00:25:11,000 --> 00:25:14,000
שפות יש סוגים שלמים גדולים יותר,

355
00:25:14,000 --> 00:25:23,000
כמו שראינו בMySQL היום היה int ואז int הגדול.

356
00:25:23,000 --> 00:25:25,000
מגניב.

357
00:25:25,000 --> 00:25:28,000
>> לכן, מדריך של PHP.

358
00:25:28,000 --> 00:25:37,000
בואו נחזור למפרט סט הבעיה שלנו, ואנחנו עכשיו נצטרך לגלול למטה לעמוד 4.

359
00:25:37,000 --> 00:25:41,000
אחד הדברים שקורים כאשר אתה מקבל שפות הבאות

360
00:25:41,000 --> 00:25:49,000
שאין לי ההקלדה הסטטי הזה, אז השפות הבאות בו אתה צריך להכריז

361
00:25:49,000 --> 00:25:52,000
הסוג של חזית את המשתנה

362
00:25:52,000 --> 00:26:00,000
הוא שאתה מקבל מקרים שבם ייתכן שתתחילו משתנה מטיפוסים שונים

363
00:26:00,000 --> 00:26:04,000
אינטראקציה זה עם זה,

364
00:26:04,000 --> 00:26:09,000
וPHP עושה את הדבר הזה שבו הוא מנסה לעשות

365
00:26:09,000 --> 00:26:13,000
מה שהיא מגדיר כדבר ההגיוני ביותר לעשות

366
00:26:13,000 --> 00:26:18,000
כאשר יש לך 2 סוגים שונים לתקשר אחד עם השני.

367
00:26:18,000 --> 00:26:24,000
לדוגמה, אם אנו מסתכלים על השורות האלה של קוד כאן

368
00:26:24,000 --> 00:26:29,000
אתה רואה שיש לנו מה קורה כאשר

369
00:26:29,000 --> 00:26:38,000
אנחנו מנסים ולהוסיף מחרוזת 1 עד 2 מספר השלמים.

370
00:26:38,000 --> 00:26:41,000
מה קורה אם אנחנו מנסים ולהוסיף מחרוזת שאינה ערך מספרי

371
00:26:41,000 --> 00:26:48,000
אבל דמויות לא אמיתיות, CS למספר 50?

372
00:26:48,000 --> 00:26:51,000
אז נראה האם יש משהו אחר שקורה שם

373
00:26:51,000 --> 00:26:56,000
במקום להוסיף את מחרוזת למספר שאנחנו מוסיפים מספר למחרוזת,

374
00:26:56,000 --> 00:27:00,000
וכן הלאה וכן הלאה עד לנקודה שבה אנחנו מקבלים

375
00:27:00,000 --> 00:27:05,000
איזה דברים מוזרים בדיוק איפה שאנחנו חייבים 7 + אמיתיים.

376
00:27:05,000 --> 00:27:09,000
מה לעזאזל זה אומר?

377
00:27:09,000 --> 00:27:19,000
>> אם אתם הולכים קדימה ולהדביק חלק מקוד זה למכשיר שלך.

378
00:27:19,000 --> 00:27:27,000
אתה יכול לשמור את זה בdynamic.php.

379
00:27:27,000 --> 00:27:30,000
נצטרך לראות מה קורה.

380
00:27:41,000 --> 00:27:43,000
[סטודנטים] פשוט להשתמש בהדפסה, ולא printf?

381
00:27:43,000 --> 00:27:52,000
כן, אז אתה תמצא שהדפסה היא גם פונקציה תקפה להדפסה ב-PHP.

382
00:27:52,000 --> 00:27:54,000
ישנן דרכים רבות ושונות לעשות את זה.

383
00:27:54,000 --> 00:27:58,000
נראים עם כמה הדוגמות בהמשך ברגע שנתחיל לדבר

384
00:27:58,000 --> 00:28:02,000
על הבעיה הייחודית שאנחנו הולכים לכתוב

385
00:28:02,000 --> 00:28:06,000
ואז בעית הריכוזים שאנחנו הולכים לכתוב

386
00:28:06,000 --> 00:28:09,000
שלמרות שיש לנו וfopen fclose

387
00:28:09,000 --> 00:28:15,000
זה לעתים קרובות לא הדרך הפשוטה לקרוא את התוכן של קובץ.

388
00:28:15,000 --> 00:28:21,000
PHP יש הרבה שאריות C-כמו אלה.

389
00:28:21,000 --> 00:28:28,000
[סטודנטים] כשאני שם בכל 6 מאותם דברים שאני מקבל מספר אחד כפלט בלבד.

390
00:28:28,000 --> 00:28:36,000
[נייט ח] כשאתה שם בכל 6 לדברים האלה.

391
00:28:36,000 --> 00:28:39,000
בואו נראים שזה בגלל שזה אולי-

392
00:28:39,000 --> 00:28:46,000
דבר אחד הוא ששיחות הדפסה אלה לא הסתיימו בסוף עם קווים חדשים.

393
00:28:46,000 --> 00:28:49,000
אין קו חדש של יש להפריד כל אחד משיחות ההדפסה האלה,

394
00:28:49,000 --> 00:28:51,000
אז אולי אתה מקבל מספר גדול אחד,

395
00:28:51,000 --> 00:28:58,000
וזה באמת רק תערובת של תווים בשורה החדשים.

396
00:28:58,000 --> 00:29:00,000
[סטודנטים] אוקיי, איך אני מוודא ש-

397
00:29:00,000 --> 00:29:03,000
ובכן, יש חבורה של דרכים שונות.

398
00:29:03,000 --> 00:29:06,000
אתה יכול לשים באופן ידני בהדפסה של תו שורה חדשה,

399
00:29:06,000 --> 00:29:09,000
הד לתו שורה חדש,

400
00:29:09,000 --> 00:29:12,000
הדפסה של קו חדש.

401
00:29:12,000 --> 00:29:16,000
[סטודנטים] אז ההד הוא אותו הדבר כמו printf?

402
00:29:16,000 --> 00:29:21,000
>> Printf הוא כמו C printf

403
00:29:21,000 --> 00:29:24,000
איפה אתה מדפיס מחרוזת מעוצבת.

404
00:29:24,000 --> 00:29:32,000
אתה מספק לו מחרוזת בתבנית ולאחר מכן את כל משתני מצייני המיקום.

405
00:29:32,000 --> 00:29:39,000
זה בדרך כלל משהו שלא ישמשו

406
00:29:39,000 --> 00:29:42,000
בואו נראים, כהסתייגות,

407
00:29:42,000 --> 00:29:48,000
אני פחות מכיר את PHP ממני עם שפות אינטרנט אחרות,

408
00:29:48,000 --> 00:29:53,000
וכאשר יש לי לתכנת ב-PHP אני בדרך כלל לא משתמש בprintf

409
00:29:53,000 --> 00:29:59,000
משום שאני מוצא את זה יותר מהר כדי להשתמש ביכולות אינטרפולציה המחרוזת שיש לו,

410
00:29:59,000 --> 00:30:04,000
שנלך ולאני אראה לך בדיוק שני,

411
00:30:04,000 --> 00:30:08,000
ואילו ב-C אנחנו סוג של צריכים לעשות דבר חאקי זה כדי לקבל את זה כדי להדפיס כהלכה.

412
00:30:08,000 --> 00:30:16,000
למעשה אתה יכול לשים משתנים ישירות לתוך מחרוזות ב-PHP.

413
00:30:16,000 --> 00:30:22,000
Printf הוא סוג של ארוך מדי עבור מה שאני עושה בדרך כלל. כן, אלה.

414
00:30:22,000 --> 00:30:25,000
[אלה] באופן כללי אם אתה מקבל שגיאת ניתוח זה אומר-

415
00:30:25,000 --> 00:30:30,000
כמו על C זה לא אומר לך בדיוק איפה הטעות היא ומה הוא,

416
00:30:30,000 --> 00:30:34,000
אז זה אומר שמבט דרך כל הקוד שלך ולהבין את זה?

417
00:30:34,000 --> 00:30:39,000
זה בדרך כלל יותר ממוקד מזה.

418
00:30:39,000 --> 00:30:48,000
אני חושב שבמקרה זה היה קצת כבוי,

419
00:30:48,000 --> 00:30:51,000
לכן אני חושב שבמקרה שהיו חסר פסיק.

420
00:30:51,000 --> 00:30:54,000
הוא מנסה למצוא היגיון בכל דבר,

421
00:30:54,000 --> 00:30:57,000
כל כך כמו שפות לפרש אלה, הפרשן הולך לנסות

422
00:30:57,000 --> 00:31:01,000
ותעשה כמיטב יכולתה כדי להפוך את עבודת הכל כראוי.

423
00:31:01,000 --> 00:31:04,000
>> תראה, למשל, ב-JavaScript

424
00:31:04,000 --> 00:31:10,000
אתה לעתים קרובות אונליין הצהרות קצה עם פסיק בדיוק כמו שהם עושים ב-PHP,

425
00:31:10,000 --> 00:31:13,000
בדיוק כפי שהם עושים בג

426
00:31:13,000 --> 00:31:15,000
ב-JavaScript חלק מפרשני JavaScript

427
00:31:15,000 --> 00:31:20,000
בהרבה מהדפדפנים תהיינה לשים בפסיק בשבילך

428
00:31:20,000 --> 00:31:23,000
אם קורים לך להיות חסרים אותם.

429
00:31:23,000 --> 00:31:29,000
הם ינסו להתאים לרשלנות כלשהי מצידך.

430
00:31:29,000 --> 00:31:34,000
זה המקום שבו ייתכן שהוא מנסה ומנסה ומנסה לעשות דברי עבודה,

431
00:31:34,000 --> 00:31:36,000
ואז סוף הסוף זה מגיע לנקודה שבה אומר בסדר,

432
00:31:36,000 --> 00:31:38,000
אני לא יכול לגרום לדברים לעבוד על שחרור בערבות, וזה שבו יקבל מספר קו

433
00:31:38,000 --> 00:31:44,000
שאולי נראה קצת מהמקום המדויק.

434
00:31:44,000 --> 00:31:47,000
אוקיי, אז בואו נעבור את זה ממש מהר.

435
00:31:47,000 --> 00:31:50,000
אבל עזב אותי עם אלה, אז בואו נלך למסים,

436
00:31:50,000 --> 00:31:54,000
ומסים, מה הדפסה של מחרוזת 1 פלוס המספר 2 ינתנו לך?

437
00:31:54,000 --> 00:31:56,000
[מסים] 3. >> 3.

438
00:31:56,000 --> 00:31:59,000
האם זה הגיוני? סוג של?

439
00:31:59,000 --> 00:32:02,000
האם זה נותן לך מספר? האם זה נותן לך חוט?

440
00:32:02,000 --> 00:32:05,000
[מסים] מספר. >> זה מספר.

441
00:32:05,000 --> 00:32:09,000
אבל זה להדפיס אותה, אז זה הולך לתת לך איזה חוט.

442
00:32:09,000 --> 00:32:12,000
>> אחד דברים שאנחנו יכולים לעשות כדי לבדוק את זה

443
00:32:12,000 --> 00:32:21,000
הוא אם אנחנו עושים $ var = 1 + 2

444
00:32:21,000 --> 00:32:28,000
ואז אנחנו אומרים הד gettype,

445
00:32:28,000 --> 00:32:33,000
כך אנחנו משתמשים בסוג שלישי של הדפסה כאן.

446
00:32:33,000 --> 00:32:39,000
עכשיו אנחנו יכולים לראות את מה שקורה כאן.

447
00:32:39,000 --> 00:32:42,000
הנה מה שיש לנו הוא שיש לנו מספר שלם מתוך זה.

448
00:32:42,000 --> 00:32:45,000
למרות שאנחנו מוסיפים מחרוזת זה למספר,

449
00:32:45,000 --> 00:32:48,000
אנחנו לא מקבלים את המחרוזת שלו, בדיוק כמו מסים, אמרו.

450
00:32:48,000 --> 00:32:52,000
אנחנו מקבלים מספר שלם.

451
00:32:52,000 --> 00:32:57,000
אוקיי, אז בואו נראים, הבא למעלה, קווין.

452
00:32:57,000 --> 00:32:59,000
CS + 50? >> [קווין] 50.

453
00:32:59,000 --> 00:33:02,000
[נייט ח] 50. האם זה הגיוני?

454
00:33:02,000 --> 00:33:04,000
[קווין] כן.

455
00:33:04,000 --> 00:33:06,000
[נייט ח] למה? למה זה נשמע לך הגיוני?

456
00:33:06,000 --> 00:33:11,000
[קווין] כי זה פשוט הזמין את המחרוזת, שערך אפס מספר.

457
00:33:11,000 --> 00:33:16,000
כן, נהדר.

458
00:33:16,000 --> 00:33:20,000
סוג של מצבים מעורפלים, אבל זה טוב לדעת מה קורה.

459
00:33:20,000 --> 00:33:25,000
סטלה, מה קורה עם מספר 1 + מחרוזת 2?

460
00:33:25,000 --> 00:33:27,000
[סטלה] 3. >> 3 שוב.

461
00:33:27,000 --> 00:33:30,000
ובמקרה הזה, אנחנו מקבלים מחרוזת או מספר?

462
00:33:30,000 --> 00:33:36,000
>> בואו לתת את זה לנסות.

463
00:33:36,000 --> 00:33:43,000
אף אחד מהר יותר מאשר לי את התשובה? שרלוט?

464
00:33:43,000 --> 00:33:46,000
אה, אני לא ידע-בסדר, בואו נראים, אנחנו הולכים לעשות את אותו דבר

465
00:33:46,000 --> 00:33:49,000
איפה שיש לנו מספר בתוספת מחרוזת, ואנחנו הולכים להד הסוג,

466
00:33:49,000 --> 00:33:51,000
לראות מה אנחנו מקבלים.

467
00:33:51,000 --> 00:33:55,000
כמו כן, אנו מקבלים מספר שלם.

468
00:33:55,000 --> 00:33:58,000
זה לא משנה איזה מהם הוא המחרוזת, איזה מהם היא המספר.

469
00:33:58,000 --> 00:34:00,000
אנחנו עדיין הולכים לקבל מספר שלם.

470
00:34:00,000 --> 00:34:04,000
זה עדיין הולך לעשות את מה שהיינו מצפה.

471
00:34:04,000 --> 00:34:09,000
בסדר, אז סם, מה לגבי 90 + 9 בקבוקים של בירה על הקיר?

472
00:34:09,000 --> 00:34:12,000
[סם] 99. >> 99.

473
00:34:12,000 --> 00:34:15,000
אין בקבוקים של בירה על הקיר, אם כי.

474
00:34:15,000 --> 00:34:17,000
זה נותן לנו קצת יותר מידע על מה שקורה.

475
00:34:17,000 --> 00:34:21,000
[סם] אם כתב באותיות 9

476
00:34:21,000 --> 00:34:23,000
אז היית צריכים 90, נכון?

477
00:34:23,000 --> 00:34:26,000
[נייט ח] כן.

478
00:34:26,000 --> 00:34:30,000
השאלה הייתה אם הייתי כתוב 9 מתוך כ N-I-N-E

479
00:34:30,000 --> 00:34:34,000
האם היינו מקבל 99 או 90?

480
00:34:34,000 --> 00:34:38,000
היינו מקבל 90.

481
00:34:38,000 --> 00:34:42,000
זה ממש סתם מחפש תווים ספרתיים.

482
00:34:42,000 --> 00:34:46,000
זה לא חכם מספיק כדי לזהות מילים ומספרים שדברים כאלה. כן.

483
00:34:46,000 --> 00:34:48,000
>> [סטודנטים] האם יש דבר כזה כמו ליהוק שחקנים ב-PHP?

484
00:34:48,000 --> 00:34:54,000
יש, וזה בדיוק כמו שאתה הייתי עושה את זה בג

485
00:34:54,000 --> 00:34:56,000
מה לגבי 10/7, שרלוט?

486
00:34:56,000 --> 00:34:58,000
[שארלוט] 1.4285.

487
00:34:58,000 --> 00:35:01,000
[נייט ח] כן, אז מה יכול להיות מפתיע בעניין הזה?

488
00:35:01,000 --> 00:35:04,000
מה היה קורה אם היית עושה אותו דבר כזה ב-C,

489
00:35:04,000 --> 00:35:06,000
אם עשית 10/7 ב-C?

490
00:35:06,000 --> 00:35:08,000
[שארלוט] זה יהיה רק ​​לתת לך תלוי על איך אתה typecasted אני מניח

491
00:35:08,000 --> 00:35:12,000
זה ייתן לך רק מספר מוגבל של ספרות אחרי הנקודה העשרונית.

492
00:35:12,000 --> 00:35:16,000
כן, אז מספר מוגבל של ספרות אחרי הנקודה העשרונית.

493
00:35:16,000 --> 00:35:21,000
מה עוד יכול להיות שזה ייתן לך שום ספרות אחרי הנקודה העשרונית?

494
00:35:21,000 --> 00:35:28,000
לעתים קרובות לא, אז שוב, תלויים איך אתה ליהוק שחקניה

495
00:35:28,000 --> 00:35:31,000
זה יכול או לא יכול להמיר אותו למספר עשרוני.

496
00:35:31,000 --> 00:35:35,000
כאן זה היה די נחמד שהיא עשתה.

497
00:35:35,000 --> 00:35:40,000
אם הייתי מראה לך את זה בחזרה כשהתחלנו לעשות דברים כאלה ב-C

498
00:35:40,000 --> 00:35:44,000
זה כנראה היה עושה קצת יותר הגיוני

499
00:35:44,000 --> 00:35:48,000
שזה לא פשוט ללכת 1.

500
00:35:48,000 --> 00:35:51,000
ולבסוף, ג'יימי, מה לגבי 7 + נכון?

501
00:35:51,000 --> 00:35:53,000
[ג'יימי] 8. >> 8.

502
00:35:53,000 --> 00:35:56,000
מה זה אומר?

503
00:35:56,000 --> 00:35:58,000
אני מניח שזה רק נותן לי אמיתי ערך 1.

504
00:35:58,000 --> 00:36:01,000
כן. מה יקרה אם תשנו את זה שקר?

505
00:36:01,000 --> 00:36:04,000
[סטודנטים] 7.

506
00:36:04,000 --> 00:36:09,000
כן, כל כך זוכר איפה אנו מדברים על הערכים בינאריים אלה,

507
00:36:09,000 --> 00:36:12,000
1 להיות ב, 0 להיות מעל?

508
00:36:12,000 --> 00:36:17,000
עכשיו יש לנו נכון הוא 1, 0 הם שקר,

509
00:36:17,000 --> 00:36:21,000
וייתכן שלא ראה את זה בדוגמאות C שעשינו בסמסטר שעבר,

510
00:36:21,000 --> 00:36:27,000
אבל מהבחינה הסטורית סוג bool ב C לא היה סוג אמיתי,

511
00:36:27,000 --> 00:36:32,000
כך האנשים השתמשו 0 ו 1 במקום של אמת ושקר.

512
00:36:32,000 --> 00:36:35,000
זו היא ביטוי לכך.

513
00:36:35,000 --> 00:36:39,000
>> אוקיי, אז חלק חשוב אחד על כל זה

514
00:36:39,000 --> 00:36:41,000
הוא שיש לנו סוגים שונים האלה.

515
00:36:41,000 --> 00:36:43,000
הם יכולים לתקשר אחד עם השני.

516
00:36:43,000 --> 00:36:49,000
לעתים קרובות הם יכולים לתקשר אחד עם השני בדרכים שהן נחמדות, כמו שראינו כאן.

517
00:36:49,000 --> 00:36:53,000
זה נחמד להיות מסוגל לקבל מחרוזת 1 ומספר 2, להוסיף אותם יחד ותקבל 3.

518
00:36:53,000 --> 00:36:55,000
זה הגיוני.

519
00:36:55,000 --> 00:36:59,000
עם זאת, כאשר אתה כותב אתרי אינטרנט, ובמיוחד כשאתה מעבד

520
00:36:59,000 --> 00:37:04,000
קלט משתמש, ולכן אומר שכתבת טופס אינטרנט

521
00:37:04,000 --> 00:37:09,000
שאוסף מידע מהמשתמש ואז הולך לעבד אותו

522
00:37:09,000 --> 00:37:13,000
בקצה האחורי, בצד השרת בקוד ה-PHP

523
00:37:13,000 --> 00:37:18,000
אם אתה מצפה שהערך שמשתמש הקליד ובהגשתי

524
00:37:18,000 --> 00:37:23,000
לטופס שלך כדי להיות שלם או להיות מספר נקודה צפה או משהו כזה

525
00:37:23,000 --> 00:37:29,000
אתה צריך באופן מפורש שהטיל אותו

526
00:37:29,000 --> 00:37:34,000
ואז לעשות כמה בדיקות סוג.

527
00:37:34,000 --> 00:37:41,000
>> אתה לא רוצה פשוט להסתמך על מערכת ג'אגלינג סוג זה כדי לגרום לדברים לעבוד,

528
00:37:41,000 --> 00:37:48,000
בעיקר מסיבות בטחוניות ורק לחוסנו של אתר האינטרנט שלך.

529
00:37:48,000 --> 00:37:51,000
רק משהו שכדאי לזכור שבכל פעם שאתה מטפל בנתוני טופס,

530
00:37:51,000 --> 00:37:57,000
כל דבר שמגיע בדואר או את superglobals קבל

531
00:37:57,000 --> 00:38:01,000
לוודא שאתה תמיד לאמת אותו ולהפוך אותו ותייגת אותו.

532
00:38:01,000 --> 00:38:04,000
ובדיוק כמו שאנחנו מדברים על רגע לפני שליהוק השחקנים

533
00:38:04,000 --> 00:38:08,000
בPHP הוא בדיוק אותו הדבר כמו ב-C בו אתה צריך את הסוגריים

534
00:38:08,000 --> 00:38:14,000
ולאחר מכן את הסוג.

535
00:38:14,000 --> 00:38:16,000
לזכור את זה.

536
00:38:16,000 --> 00:38:19,000
פונקציה אחת שתהיה שימושי כשאתה עושה את זה

537
00:38:19,000 --> 00:38:22,000
הוא אנחנו כבר משתמשים וזה סוג של כצד-

538
00:38:22,000 --> 00:38:27,000
אנחנו כבר משתמשים פונקצית gettype זה ממש כאן

539
00:38:27,000 --> 00:38:30,000
כדי להבין את הסוג משתנה,

540
00:38:30,000 --> 00:38:37,000
ובזמן הזה הוא שימושי לניפוי ולראות איזה סוג של משתנה הוא

541
00:38:37,000 --> 00:38:42,000
אתה לא רוצה להשתמש בו, זה לדוגמה, במצב שבו

542
00:38:42,000 --> 00:38:57,000
אתה בודק אם gettype של $ var = שלם לעשות משהו.

543
00:38:57,000 --> 00:39:01,000
זה רע, רע, רע.

544
00:39:01,000 --> 00:39:09,000
במקום יש הפונקציות הללו נקראים הוא מספר שלם, היא מחרוזת,

545
00:39:09,000 --> 00:39:14,000
הוא מערך שאתה רוצה להשתמש במקום, ולכן במקרה זה

546
00:39:14,000 --> 00:39:18,000
מה הייתי רוצה לעשות במקום הבחור הזה ממש כאן

547
00:39:18,000 --> 00:39:31,000
הוא משתמש הוא var מספר שלם.

548
00:39:31,000 --> 00:39:37,000
והם מכונים לעתים קרובות הם * is_ במובן זה שאתה יכול להחליף * עם שלם,

549
00:39:37,000 --> 00:39:43,000
מחרוזת, וכולי, ורק כדי לוודא שבאמת מהיר

550
00:39:43,000 --> 00:39:50,000
הוא זה int PHP.

551
00:39:50,000 --> 00:39:59,000
נראה כאילו אתה יכול לעשות גם הוא int או שיש מספר שלם, כמו גם?

552
00:39:59,000 --> 00:40:06,000
כן, כינוי, כינויים שלמים כך int.

553
00:40:06,000 --> 00:40:08,000
מגניב.

554
00:40:14,000 --> 00:40:17,000
>> איך אנחנו עושים?

555
00:40:17,000 --> 00:40:20,000
בואו להרים את הקצב מעט.

556
00:40:20,000 --> 00:40:24,000
עכשיו אנחנו הולכים לדבר על מערכים, אז כפי שאתם יכולים לראות

557
00:40:24,000 --> 00:40:28,000
בחלק הבא של המפרט אנחנו מדברים על מערכים איך ב-PHP

558
00:40:28,000 --> 00:40:31,000
הם מעט שונים ממה שהם בג

559
00:40:31,000 --> 00:40:34,000
למען אמת, הם מעין תערובת של

560
00:40:34,000 --> 00:40:36,000
המערכים שאתה כבר יודע ואוהב ב-C

561
00:40:36,000 --> 00:40:40,000
בו הכל מאותו הסוג

562
00:40:40,000 --> 00:40:43,000
מאוחסן ברציפות וסמיכות בזיכרון,

563
00:40:43,000 --> 00:40:46,000
ויש לך מדדים מספריים אלה.

564
00:40:46,000 --> 00:40:49,000
יש לך מדד 0, 1, מדד 2,

565
00:40:49,000 --> 00:40:53,000
ולך לאחסן ערכים במדדים אלה.

566
00:40:53,000 --> 00:40:57,000
גם אתה ב-C, כאשר כתבו מאית, הרבה מכם

567
00:40:57,000 --> 00:41:00,000
עשה גישת שולחן החשיש, ואת רואה שיש לנו

568
00:41:00,000 --> 00:41:03,000
סוג אחר של אחסון שבו היינו מיפוי

569
00:41:03,000 --> 00:41:07,000
מפתח לשווי, ולכן כאשר אתה ניסית לאחסן משהו בשולחן חשיש

570
00:41:07,000 --> 00:41:11,000
היית חייב לציין שאתה רוצה לאחסן אותו עם מפתח מסוים,

571
00:41:11,000 --> 00:41:17,000
ומפתח שקבע את מיקומו של הערך ובו יאוחסן.

572
00:41:17,000 --> 00:41:22,000
סוג של יש לך את שני המושגים האלה קורים באותו הזמן במערך PHP,

573
00:41:22,000 --> 00:41:27,000
וכתוצאה מכך, לעתים קרובות אנו קוראים מערכים אסוציאטיביים

574
00:41:27,000 --> 00:41:33,000
איפה אנחנו משייכים מפתח בערך.

575
00:41:33,000 --> 00:41:39,000
בחלק הבא שאנחנו מדברים על מערך פשוט PHP

576
00:41:39,000 --> 00:41:45,000
שם יש לנו את מפתחות, B ו-C,

577
00:41:45,000 --> 00:41:53,000
כל המחרוזות, מיפוי למספרים השלמים 1, 2, ו 3.

578
00:41:53,000 --> 00:41:57,000
ואתה יכול לקבל את מפתחות מסוגים שונים.

579
00:41:57,000 --> 00:42:00,000
>> אתה יכול להיות כמה מפתחות שמחרוזות, כמה מפתחות שהם מספרים שלמים.

580
00:42:00,000 --> 00:42:03,000
אתה יכול לקבל ערכים מסוגים שונים.

581
00:42:03,000 --> 00:42:06,000
אתה יכול להיות בעל ערך זה מחרוזת, ערך זה מספר שלם,

582
00:42:06,000 --> 00:42:11,000
ערך זה אובייקט או מערך אחר, לדוגמה,

583
00:42:11,000 --> 00:42:16,000
כולם באותו אובייקט המערך, שהוא קצת מוזר.

584
00:42:16,000 --> 00:42:20,000
אתה לא צריך להיות מערך שפשוט יש לו סוג אחד של אלמנט בו.

585
00:42:20,000 --> 00:42:26,000
אתה יכול להיות הרבה דברים שונים קורים שם.

586
00:42:26,000 --> 00:42:33,000
הדבר השני שיש לשים לב, שכאשר אתה רואה משהו כזה בקוד שלך,

587
00:42:33,000 --> 00:42:38,000
שזה PHP החוקי להכריז על מערך כזה בדיוק, 0, 1, 2, 3, 4, 5,

588
00:42:38,000 --> 00:42:43,000
שיכריז arr $ אותחלו להיות זה מערך.

589
00:42:43,000 --> 00:42:48,000
אבל מה שאתה באמת מקבל מתחת למכסת המנוע הוא זה סוג של סמוי

590
00:42:48,000 --> 00:42:55,000
דור של מקשים בי שיש לנו 0-0, 1 עד 1, 2 ב2, 3 עד 3.

591
00:42:55,000 --> 00:42:59,000
ומתברר שגם אם יש לך מערך כמו הבחור הזה כאן

592
00:42:59,000 --> 00:43:03,000
שם יש לך, B ו-C כמפתחות

593
00:43:03,000 --> 00:43:09,000
ואז אתה מתחיל להשתמש בשיטת דחיפת המערך כדי להתחיל להשתמש במערך זה כמו ערימה,

594
00:43:09,000 --> 00:43:12,000
כך שאתה יכול לראות שזה אובייקט מערך, המערך הזה הוא באמת הופך עמוס.

595
00:43:12,000 --> 00:43:15,000
אנחנו יכולים להשתמש בו כמגוון. אנחנו יכולים להשתמש בו כשולחן חשיש.

596
00:43:15,000 --> 00:43:19,000
אנחנו יכולים להשתמש בו כערימה.

597
00:43:19,000 --> 00:43:22,000
כאשר אתה מתחיל לדחוף דברים על מערך זה

598
00:43:22,000 --> 00:43:30,000
הדבר הראשון שאתה דוחף אל זה יהיה מדד 0 1 ולאחר מכן מדד ומדד 2.

599
00:43:30,000 --> 00:43:33,000
אתה יכול לקבל סוג כזה של דור הסמוי של מפתחות

600
00:43:33,000 --> 00:43:38,000
אלא אם כן ציינת אותם במפורש.

601
00:43:38,000 --> 00:43:43,000
הדרך שציינת במפורש מפתחות, כמובן, היא באמצעות סימון סוגר זה,

602
00:43:43,000 --> 00:43:48,000
בדומה למערכים למעט במקום לאפשר רק

603
00:43:48,000 --> 00:43:54,000
מדדים שלמים בפה, אנחנו נאפשר לכל דבר.

604
00:43:54,000 --> 00:43:57,000
אם אתה רוצה להיות המפתח שלך למחרוזת, היית מציין את זה ככה.

605
00:43:57,000 --> 00:44:06,000
אם אתה רוצה שזה יהיה int, שתציין את זה עם int ברצונך להשתמש.

606
00:44:06,000 --> 00:44:13,000
>> שאלות על זה עד כה?

607
00:44:13,000 --> 00:44:18,000
אחד הדברים היפים ברעיון הזה

608
00:44:18,000 --> 00:44:26,000
הוא שאתה יחיד שיכול להיות ערך אחד מאוחסן במפתח מסוים.

609
00:44:26,000 --> 00:44:32,000
אם אחזור אלינו המכשיר, תן לי למחוק חלק מהחומר הזה.

610
00:44:32,000 --> 00:44:47,000
ונניח שאני לאתחל מערך להיות 0, 1, 2, עשה.

611
00:44:47,000 --> 00:44:55,000
אם אני עכשיו יודע את זה, לדוגמה, אם אני מהדהד arr $ [0]

612
00:44:55,000 --> 00:44:59,000
אני הולך לקבל את ערך 0 הדפיסו,

613
00:44:59,000 --> 00:45:05,000
ומכיוון שיכול להיות רק ערך אחד מאוחסן על מקש מסוים

614
00:45:05,000 --> 00:45:11,000
אם אני לאחסן משהו בעיבוד $ [0], אומר,

615
00:45:11,000 --> 00:45:16,000
אז אני יודע מתי אני חוזר על $ arr [0] שוב

616
00:45:16,000 --> 00:45:19,000
אני לא הולך לקבל 0 הדפיסו כמו קודם.

617
00:45:19,000 --> 00:45:24,000
אני רק הולך לקבל.

618
00:45:24,000 --> 00:45:30,000
אז זה בעצם אומר שאני לא יכול להיות arr $ [0] 2 ערכי אחסון שונים.

619
00:45:30,000 --> 00:45:34,000
זה לא יכול לאחסן הוא 0 וחוט, כמו זה ממש מחליף

620
00:45:34,000 --> 00:45:38,000
מה שהיה בעיבוד $ [0] בעבר.

621
00:45:38,000 --> 00:45:43,000
הסיבה שאני מעלה את זה הוא להפעיל אותו, לראות מה קורה.

622
00:45:43,000 --> 00:45:47,000
ראה כאן כי יש לי 0 ולאחר מכן הדפיסו כאן למטה.

623
00:45:47,000 --> 00:45:51,000
אין שום קו חדש שם, כי הייתי עצלן ולא כתב את זה פנימה

624
00:45:51,000 --> 00:45:54,000
מה מגניב על זה שאנחנו יכולים להשתמש בזה כדרך

625
00:45:54,000 --> 00:46:00,000
כדי ללכוד את הרעיון הזה של קבוצה

626
00:46:00,000 --> 00:46:07,000
שבו אנחנו לא יכולים לקבל את המפתחות מרובים בתוך מערך.

627
00:46:07,000 --> 00:46:10,000
אנחנו לא יכולים לקבל את מפתחות זהים בתוך מערך.

628
00:46:10,000 --> 00:46:17,000
אני לא יכול להיות מקש 0 וערך 1 ועל מקש 0 וערך

629
00:46:17,000 --> 00:46:21,000
או 0 וערך מפתח נכון.

630
00:46:21,000 --> 00:46:27,000
המפתחות הם כל יש רק מקש 1 במערך.

631
00:46:27,000 --> 00:46:32,000
למרות שאתה יכול לקבל את אותו הערך המאוחסן

632
00:46:32,000 --> 00:46:35,000
מספר פעמים במערך תחת מפתחות שונים

633
00:46:35,000 --> 00:46:42,000
זה לא אפשרי שתהיינה מפתחות זהים מספר פעמים במערך PHP שלך.

634
00:46:42,000 --> 00:46:47,000
>> אם יתבונן בבעיה הבאה, unique.php,

635
00:46:47,000 --> 00:46:51,000
לאן אנחנו רוצים לפתוח את קובץ ה-PHP

636
00:46:51,000 --> 00:46:54,000
המכיל רשימה של מחרוזות, מחרוזת אחת בכל שורה,

637
00:46:54,000 --> 00:47:01,000
ואנחנו רוצים למצוא את כל החוטים הייחודיים שבקובץ

638
00:47:01,000 --> 00:47:06,000
כל מה שאנחנו צריכים לעשות הוא להשתמש באחד מהמערכים האלה PHP

639
00:47:06,000 --> 00:47:12,000
ולהשתמש במחרוזות בקובץ כמפתחות למערך זה

640
00:47:12,000 --> 00:47:17,000
ולעדכן באופן שוטף המערך שלנו כמו שאנחנו מאחסנים את המפתחות החדשים אלה.

641
00:47:17,000 --> 00:47:22,000
כפי שאנו קוראים כל שורה מתוך הקובץ שאנו יכולים לאחסן אותו במערך,

642
00:47:22,000 --> 00:47:28,000
ובסופו יהיה לנו כמפתחות שלנו במערך שלנו

643
00:47:28,000 --> 00:47:34,000
את כל החוטים הייחודיים בתוך הקובץ.

644
00:47:34,000 --> 00:47:37,000
האם זה הגיוני?

645
00:47:37,000 --> 00:47:41,000
בואו לראות איך זה עובד.

646
00:47:41,000 --> 00:47:49,000
אנחנו הולכים לפתוח, על פי המפרט, קובץ חדש בשם unique.php.

647
00:47:49,000 --> 00:47:58,000
פתח. אופס, סליחה, קובץ חדש.

648
00:47:58,000 --> 00:48:03,000
אנחנו הולכים להתחיל אותו עם תגים אותה ההתחלה וסיום.

649
00:48:03,000 --> 00:48:17,000
אנחנו הולכים כדי לשמור אותו בסעיף 9, ואנחנו הולכים לקרוא לזה unique.php.

650
00:48:17,000 --> 00:48:25,000
אוקיי, עכשיו להתמקד פנימה

651
00:48:25,000 --> 00:48:32,000
הרעיון כאן הוא לפתוח קובץ,

652
00:48:32,000 --> 00:48:38,000
לקרוא בשורת קובץ אחר שורה.

653
00:48:38,000 --> 00:48:46,000
לכל שורה בקובץ

654
00:48:46,000 --> 00:48:51,000
יהיה לנו מערך שבו יש לנו

655
00:48:51,000 --> 00:49:03,000
 הקו כמפתח שלנו.

656
00:49:03,000 --> 00:49:09,000
ואז כשנגיע לסוף כאן

657
00:49:09,000 --> 00:49:17,000
המפתחות של $ arr הם קווים הייחודיים

658
00:49:17,000 --> 00:49:25,000
מהקובץ מאחר שאנו יודעים שאם אני אשים קו למערך זה

659
00:49:25,000 --> 00:49:33,000
פעמים רבות זה תהיה פשוט לשמור על דריסת הערך הישן,

660
00:49:33,000 --> 00:49:46,000
ואנחנו באמת יכולים לשים את הקו במערך כעצמו סתם ככה.

661
00:49:46,000 --> 00:49:48,000
>> זה קצת מוזר.

662
00:49:48,000 --> 00:49:52,000
אנחנו מאחסנים אותו זוג ערך המפתח שוב ושוב ושוב,

663
00:49:52,000 --> 00:50:00,000
אבל מאחר שאנחנו מובטחים שלא יהיו רק מקש 1 נקרא קו

664
00:50:00,000 --> 00:50:05,000
כך שאם יש לנו קובץ שאומר-קובץ של קולות של בעלי חיים ויש לו האו, האו,

665
00:50:05,000 --> 00:50:11,000
מיאו, מיאו, מו, מו, ובכל פעם שאנחנו קוראים את רעש של חיה

666
00:50:11,000 --> 00:50:15,000
כמו האו ולאחסן אותו במערך שלנו אנחנו מקבלים לנבוח, ואז בפעם השנייה

667
00:50:15,000 --> 00:50:20,000
אנו מאחסנים וף זה יהיה להחליף את הפעם הראשונה שמאוחסנים בו.

668
00:50:20,000 --> 00:50:25,000
בסופו יהיה לנו ערך אחד במערך היחיד

669
00:50:25,000 --> 00:50:33,000
לכל אחד מהקולות של בעלי החיים בקובץ הקולות של בעלי החיים שלנו.

670
00:50:33,000 --> 00:50:41,000
האם אתם מרגישים בטוחים שאתה יכול להתמודד עם פתיחת קובץ ב-PHP?

671
00:50:41,000 --> 00:50:45,000
דרך אחת לעשות את זה, בואו נלך על דרך במהירות, זה לעשות את זה

672
00:50:45,000 --> 00:50:50,000
הוא עם fopen, כמו שראינו קודם.

673
00:50:50,000 --> 00:50:55,000
אתה יכול fopen some_file.txt.

674
00:50:55,000 --> 00:50:59,000
אתה יכול לפתוח אותו במצב קריאה, ממש כמו בג

675
00:50:59,000 --> 00:51:02,000
זו דרך מושלמת טובה אחת לעשות את זה.

676
00:51:02,000 --> 00:51:05,000
גם לאחר מכן לקריאה בקובץ השורה אחרת שורה אתה

677
00:51:05,000 --> 00:51:12,000
יש את אותן פונקציות, רבים מהם, שעשיתם בג

678
00:51:12,000 --> 00:51:14,000
יש לך fgets.

679
00:51:14,000 --> 00:51:17,000
יש לך feof, למרות שאנחנו לא אוהבים להשתמש בזה

680
00:51:17,000 --> 00:51:22,000
משום, לזכור, שלא היה גדול בג

681
00:51:22,000 --> 00:51:25,000
אתה יכול לעשות את זה באותה הדרך,

682
00:51:25,000 --> 00:51:34,000
אבל כאן זה דבר ממש מגניב.

683
00:51:34,000 --> 00:51:41,000
מצטער, אני לא רוצה לעשות $ קובץ, אבל יש פונקציה שנקראת קובץ ב-PHP,

684
00:51:41,000 --> 00:51:47,000
ופונקציה זו זכות כאן היא מגניבה כי הוא קורא את כל התוכן

685
00:51:47,000 --> 00:51:52,000
של הקובץ שאתה מציין, ולכן some_file.txt,

686
00:51:52,000 --> 00:51:56,000
קורא את כל התוכן של קובץ זה במערך

687
00:51:56,000 --> 00:52:03,000
ולאחר מכן מאפשר לך לחזר על זה, וזה די מגניב.

688
00:52:03,000 --> 00:52:07,000
>> אם אנחנו הולכים, למשל, לדפדפן האינטרנט שלנו

689
00:52:07,000 --> 00:52:14,000
ואנחנו מסתכלים על גוגל לקובץ PHP

690
00:52:14,000 --> 00:52:23,000
אתם יכולים לראות כאן שבמדריך שלנו אומר קובץ שקורא כל קובץ לתוך מערך,

691
00:52:23,000 --> 00:52:27,000
ואנחנו יכולים file_get_contents להחזיר את התוכן של קובץ כמחרוזת,

692
00:52:27,000 --> 00:52:30,000
אבל בדרך כלל פשוט מקבל את זה כמערך הוא באמת נחמד, כי מה שהוא עושה

693
00:52:30,000 --> 00:52:33,000
היא אותו שובר אותו, כך שכל רכיב

694
00:52:33,000 --> 00:52:37,000
במערך היא שורה אחת של הקובץ,

695
00:52:37,000 --> 00:52:41,000
כך שאם אנחנו מסתכלים על קובץ 0, זאת השורה הראשונה של הקובץ.

696
00:52:41,000 --> 00:52:46,000
קובץ 1, קו שני, קובץ 2, שורה שלישית, וכן הלאה וכן הלאה.

697
00:52:46,000 --> 00:52:50,000
האם לא יהיה זה נחמד אם זה היה כל מה שצריך לעשות ב-C?

698
00:52:50,000 --> 00:52:53,000
די מגניב.

699
00:52:53,000 --> 00:52:59,000
הדוד הראה את זה בהרצאה, ואת הניב שהוא הראה היה

700
00:52:59,000 --> 00:53:03,000
כי בנוסף לסטנדרט שלנו ללולאה ב-PHP שהיו לנו

701
00:53:03,000 --> 00:53:09,000
עבור ($ i = 0; i <10; אני + +),

702
00:53:09,000 --> 00:53:16,000
ואתה יכול לעשות את זה ב-PHP מדי, אותו דבר,

703
00:53:16,000 --> 00:53:27,000
יש לנו גם המבנה המגניב הזה שנקרא foreach.

704
00:53:27,000 --> 00:53:32,000
Foreach הוא באמת שימושי כאשר iterating על מערכים או מבני נתונים אלה

705
00:53:32,000 --> 00:53:36,000
כי זה מאפשר לך להוציא את כל אלמנט של המערך

706
00:53:36,000 --> 00:53:42,000
מבלי לעשות ידני האינדקס עצמך,

707
00:53:42,000 --> 00:53:46,000
מבלי ליצור ידני משתנה מדד, להגדיל אותו,

708
00:53:46,000 --> 00:53:51,000
לשלוף את הערך במערך בשלב זה, כי זה דבר נפוץ מאוד לעשות.

709
00:53:51,000 --> 00:53:54,000
>> יש לך כנראה עשה את זה טונות של פעמים כשאתה עושה דברי C

710
00:53:54,000 --> 00:54:00,000
על הסמסטר, כך עם foreach זה

711
00:54:00,000 --> 00:54:06,000
אנחנו יכולים לולאה על מערך קובץ זה,

712
00:54:06,000 --> 00:54:12,000
והתחביר הוא שאנחנו רוצים עכשיו לולאה על מערך זה

713
00:54:12,000 --> 00:54:18,000
ולציין שהמשתנה שאנחנו הולכים להשתמש לאחסון

714
00:54:18,000 --> 00:54:27,000
האלמנט של מערך זה באופן מקומי, המקומי להיקף של לולאת foreach זה,

715
00:54:27,000 --> 00:54:32,000
הוא שאנחנו הולכים לקרוא לזה קו.

716
00:54:32,000 --> 00:54:38,000
אם זה קובץ של מילים בלבד ויש מילה אחת בשורה

717
00:54:38,000 --> 00:54:43,000
אנחנו יכולים לקרוא לו גם מלה, באמת רק לך לתת את זה שם,

718
00:54:43,000 --> 00:54:49,000
כל מה שאתה רוצה לקרוא לזה,

719
00:54:49,000 --> 00:55:02,000
ואז בתוך הלולאה אתה יכול לעשות מה שאתה רוצה עם קו משתנה זה.

720
00:55:02,000 --> 00:55:08,000
אם זה לא מספיק כדי לקבל את הערך של המערך ואתה גם רוצה לקבל

721
00:55:08,000 --> 00:55:17,000
המדד יחד עם זה אתה יכול לציין שם למדד

722
00:55:17,000 --> 00:55:22,000
כמו גם את הערך, ועכשיו יש לך גישה ל2 משתנה.

723
00:55:22,000 --> 00:55:26,000
יש לך $ אני וקו

724
00:55:26,000 --> 00:55:30,000
בי $ i הוא האינדקס במערך,

725
00:55:30,000 --> 00:55:38,000
וקו הוא הקו שנלקח מהקובץ.

726
00:55:38,000 --> 00:55:49,000
לדוגמה, אם אנחנו רוצים להדפיס 0 הד קו של הקובץ כמו זה,

727
00:55:49,000 --> 00:55:57,000
אנחנו יכולים לעשות את זה כמו שזה, "קו $ i של הקובץ הוא $ קו,"

728
00:55:57,000 --> 00:56:02,000
והנה משהו שגם שעוד לא ראה או

729
00:56:02,000 --> 00:56:13,000
איפה שאני פשוט דלגתי לחלוטין מעל% של כל% זה ד העסק

730
00:56:13,000 --> 00:56:16,000
שיש לנו כדי להתמודד עם ב-C, ובמקום זאת אני כבר הלכתי ישר ל

731
00:56:16,000 --> 00:56:19,000
כתיבת המשתנים בשורה במחרוזת שלי.

732
00:56:19,000 --> 00:56:23,000
>> זה נקרא אינטרפולציה משתנית, המחרוזת אינטרפולציה

733
00:56:23,000 --> 00:56:26,000
לאן אתה דוחס את המשתנים נכון ובמתורגמן PHP

734
00:56:26,000 --> 00:56:31,000
הוא חכם מספיק כאשר הוא קורא דרך שרשרת שמתחילה עם ציטוטים כפולים-

735
00:56:31,000 --> 00:56:34,000
לא גרשיים בודדים, עם מחרוזות מצוטטות בודדות אתה לא יכול לעשות את זה,

736
00:56:34,000 --> 00:56:38,000
אבל עם מחרוזות מצוטטות כפולות כפי שהוא קורא אותו מחפש משתנים.

737
00:56:38,000 --> 00:56:42,000
זה לצוד אותם, ואם הוא רואה משתנה ייקח את הערך של המשתנה

738
00:56:42,000 --> 00:56:47,000
ודוחף אותה למחרוזת אם זה יכול להמיר אותו לייצוג מחרוזת,

739
00:56:47,000 --> 00:56:51,000
וזה די מגניב.

740
00:56:51,000 --> 00:56:56,000
לעת עתה, בואו להגיב את שאר הכל,

741
00:56:56,000 --> 00:57:00,000
לשמור את זה, ומה שאנחנו יכולים לעשות עכשיו הם אנחנו יכולים לפתוח את קובץ

742
00:57:00,000 --> 00:57:06,000
שאנחנו יכולים לקרוא some_file.txt-בוא ליצור קובץ חדש,

743
00:57:06,000 --> 00:57:15,000
ואנחנו יכולים לשים בחבורה של דברי הבל פה רק כדי לבדוק את הכל,

744
00:57:15,000 --> 00:57:25,000
לשמור אותו, קורא לזה some_file.txt, כפי שאני עושה כאן בראש,

745
00:57:25,000 --> 00:57:33,000
ועכשיו אם אני זום החוצה רק כדי לוודא שהכל נמצא באותה הספרייה,

746
00:57:33,000 --> 00:57:36,000
זה נראה כאילו יש לי unique.php וsome_file.txt באותה הספרייה.

747
00:57:36,000 --> 00:57:42,000
אם אני מפעיל unique.php php

748
00:57:42,000 --> 00:57:51,000
לראות איך זה מדפיס את כל שורה בקובץ שלי ומה השורה?

749
00:57:51,000 --> 00:57:56,000
>> זה די חזק, נכון?

750
00:57:56,000 --> 00:58:03,000
תראה, לקח לו 3 שורות של קוד כדי לפתוח את קובץ.

751
00:58:03,000 --> 00:58:08,000
ובכן, 4 שורות של קוד. אני לא יכול לספור היום, זה ברור.

752
00:58:08,000 --> 00:58:13,000
אבל באמת רק 2 שורות מעניינות של קוד, כי האחרים היו 2 הסוגריים המסולסלים,

753
00:58:13,000 --> 00:58:17,000
אבל בהרבה קוד הזה היינו יכול לפתוח קובץ, לחזר דרכו,

754
00:58:17,000 --> 00:58:20,000
לשלוף את מספר הקו והקו עצמו

755
00:58:20,000 --> 00:58:24,000
ולהדפיס אותו.

756
00:58:24,000 --> 00:58:26,000
דברים מגניבים. שרלוט.

757
00:58:26,000 --> 00:58:28,000
[שארלוט] יש לי שאלה על התחביר.

758
00:58:28,000 --> 00:58:33,000
אז foreach עוסק בכל שורה יחידה של הקובץ שאתה פותח,

759
00:58:33,000 --> 00:58:37,000
ואז כשאתה רוצה לעשות דברים עם כל שורה אחת שפשוט עושה את זה כמו

760
00:58:37,000 --> 00:58:39,000
ולאחר מכן לשייך את הערך.

761
00:58:39,000 --> 00:58:41,000
[נייט ח] מה שאתה יכול לעשות כאן, השאלה הייתה

762
00:58:41,000 --> 00:58:46,000
foreach יש לעשות עם המערך, כך תחביר foreach

763
00:58:46,000 --> 00:58:51,000
הוא באמת foreach, והודעה שאין מקום

764
00:58:51,000 --> 00:58:53,000
או כל דבר בין ולכל אחד.

765
00:58:53,000 --> 00:58:56,000
הם צריכים ללכת ממש ליד אחד את השני,

766
00:58:56,000 --> 00:59:00,000
ואז זה לוקח במערך,

767
00:59:00,000 --> 00:59:05,000
ואז יש לך מילת מפתח אחר זה נקרא כמו שצריך להיות שם,

768
00:59:05,000 --> 00:59:11,000
ואז אחרי שאתה יכול לשים את השם של משתנה אחד,

769
00:59:11,000 --> 00:59:14,000
בכל מקרה אתה הולך להיות מושך את הערכים של המערך,

770
00:59:14,000 --> 00:59:20,000
לא את המדדים, או אם אתה עושה את זה כמו שכתבנו בהמשך

771
00:59:20,000 --> 00:59:24,000
אתה מקבל את המפתחות והערכים.

772
00:59:24,000 --> 00:59:33,000
יש לך אלמנט foreach של המערך או זוג המערך כרגש לשווי

773
00:59:33,000 --> 00:59:38,000
או פשוט כערך.

774
00:59:38,000 --> 00:59:40,000
תלוי מה אתה צריך, אם אתה לא צריך את המפתחות,

775
00:59:40,000 --> 00:59:42,000
אז אתה יכול ללכת עם הערך.

776
00:59:42,000 --> 00:59:45,000
אם אתה רוצה את המפתחות אתה יכול ללכת איתם יותר מדי.

777
00:59:45,000 --> 00:59:48,000
>> [שארלוט] גם הבנו שאנחנו אף פעם לא הצהרנו שאני או הקו.

778
00:59:48,000 --> 00:59:51,000
איך בכלל זה יודע מה הם?

779
00:59:51,000 --> 00:59:53,000
[נייט ח] מה אתה מתכוון להכריז?

780
00:59:53,000 --> 00:59:57,000
[שארלוט] מעולם לא אמרו להם מה אני או קו אמצעי.

781
00:59:57,000 --> 01:00:01,000
[נייט ח] מעולם לא אמר את מה שהמחשב או קו המשמעות במונחים של

782
01:00:01,000 --> 01:00:05,000
[שארלוט] שהם צמודים למדד או שפזור ב-

783
01:00:05,000 --> 01:00:09,000
[נייט ח] מעולם לא אמרו לו שזה אמור להיות מדד או המפתח והערך,

784
01:00:09,000 --> 01:00:13,000
וזה בגלל שזה מתורגמן PHP.

785
01:00:13,000 --> 01:00:17,000
זה משמש כהצהרה ואומר בסדר, המפתח הולך להיות

786
01:00:17,000 --> 01:00:20,000
משתנה בשמי מאוחסן במשתנה בשם.

787
01:00:20,000 --> 01:00:24,000
הערך הולך להיות מאוחסן בשורה נקראת משתנית,

788
01:00:24,000 --> 01:00:28,000
אז זה משמש כהצהרה על משתנים אלו

789
01:00:28,000 --> 01:00:35,000
ואומר לי $ הם מפתח, ושורת $ היא ערך.

790
01:00:35,000 --> 01:00:37,000
כן, אלה.

791
01:00:37,000 --> 01:00:41,000
[אלה] אם המפתחות לא עשו מבחינה מספרית

792
01:00:41,000 --> 01:00:44,000
איך זה להחליט מה סדר זה הולך להדפיס כל דבר?

793
01:00:44,000 --> 01:00:47,000
האם זה בדיוק כמו את הסדר שהם נכנסים?

794
01:00:47,000 --> 01:00:51,000
[נייט ח] בואו לנסות את זה.

795
01:00:51,000 --> 01:00:57,000
בואו ליצור משתנה בשם arr,

796
01:00:57,000 --> 01:01:06,000
ואנחנו יכולים לעשות את הולכים 7.

797
01:01:06,000 --> 01:01:19,000
תניחו 0 הולכים למערך אחר עם 1, 2, או תפוח.

798
01:01:19,000 --> 01:01:30,000
תניחו 7 הולכים ל1, ב הולך ל2,

799
01:01:30,000 --> 01:01:39,000
ו 3 הולכים 4.

800
01:01:39,000 --> 01:01:44,000
זה סוג של דוגמה מחפשת מטורפת כי אנחנו מערבבים

801
01:01:44,000 --> 01:01:47,000
מחרוזות ומספרים שלמים בכל המקום.

802
01:01:47,000 --> 01:01:50,000
אין סדר אמיתי למערך זה.

803
01:01:50,000 --> 01:01:55,000
אני מתכוון, שנוכל להזמין את כל מה בסדר אלפביתי לפי את המפתחות.

804
01:01:55,000 --> 01:01:57,000
אפשר להזמין הכל בסדר אלפביתי לפי הערך.

805
01:01:57,000 --> 01:02:00,000
>> אנחנו יכולים לנסות ולקחת בחשבון שחלקם מחרוזות, חלקם ints,

806
01:02:00,000 --> 01:02:03,000
ואנחנו יכולים לנסות ולהמיר את כולם לאותו הסוג ולראות מה קורה,

807
01:02:03,000 --> 01:02:09,000
או שאנחנו יכולים לשקול אותם בשווי שבו אנחנו כבר הזנו אותם

808
01:02:09,000 --> 01:02:14,000
בו אנחנו שמים את הבחור הזה בהתחלה, הבחור הזה במקום שני, הבחור הזה בשלישי,

809
01:02:14,000 --> 01:02:19,000
הבחור הזה ב, וכולי רביעי.

810
01:02:19,000 --> 01:02:23,000
בואו לראות מה קורה כאשר אנו מפעילים את הקוד הזה.

811
01:02:23,000 --> 01:02:29,000
אם אנחנו לגלול למטה ולעשות את אותו דבר,

812
01:02:29,000 --> 01:02:31,000
וכאן זה לא מדפיס את הקווים החדשים.

813
01:02:31,000 --> 01:02:35,000
כשקרא את דבריו של הקובץ שכולל את הקווים החדשים בערכים,

814
01:02:35,000 --> 01:02:38,000
שלכן הדפיס יפה, ואילו כאן זה לא קרה,

815
01:02:38,000 --> 01:02:40,000
זאת הסיבה שמכיל דחוסה יחד.

816
01:02:40,000 --> 01:02:44,000
בואו נוסיף שבשורה חדשה, רק כדי לעשות דברים נחמדים.

817
01:02:44,000 --> 01:02:51,000
בואו שידור חוזר זה, ואז הנה

818
01:02:51,000 --> 01:02:54,000
מסתכל על מה שקרה.

819
01:02:54,000 --> 01:03:00,000
הוא הדפיס את הכל בהסדר שבו אנחנו מכניסים אותו למערך.

820
01:03:00,000 --> 01:03:10,000
זה לשמור על סדר במובן הזה.

821
01:03:10,000 --> 01:03:15,000
>> יחזור לבעיה זו של uniques

822
01:03:15,000 --> 01:03:20,000
איפה אנחנו רוצים להיות מסוגלים לנוע הלוך ושוב על קובץ,

823
01:03:20,000 --> 01:03:24,000
ואנחנו ניתן אותו some_file.txt,

824
01:03:24,000 --> 01:03:27,000
ואנחנו הולכים לחזר על זה ככה.

825
01:03:27,000 --> 01:03:31,000
אנחנו אמרנו שאנחנו רוצים להשתמש במערך כדי לוודא שהיינו מגיע כל

826
01:03:31,000 --> 01:03:36,000
קווים ייחודיים משם, ואנחנו יכולים לעשות את זה ממש בקלות

827
01:03:36,000 --> 01:03:49,000
רק על ידי האחסון במערך שאנחנו כמובן להכריז מחוץ להיקף של לולאה,

828
01:03:49,000 --> 01:03:55,000
ואנחנו אמרנו שאם השתמשנו בשורות בקובץ כמפתחות במערך שלנו

829
01:03:55,000 --> 01:03:59,000
אם נכנסנו לקו כפול שהיינו דריסת הערך הקודם.

830
01:03:59,000 --> 01:04:08,000
זה לא תמיד אפשרי יש 2 מקשים זהים באותו המערך.

831
01:04:08,000 --> 01:04:13,000
אנחנו יכולים לעשות בדיוק את זה.

832
01:04:13,000 --> 01:04:17,000
אנחנו הולכים להיפטר מהצהרת הד זה ממש כאן.

833
01:04:17,000 --> 01:04:24,000
כאן אנחנו אחסון השורה בקובץ במערך שלנו

834
01:04:24,000 --> 01:04:28,000
שימוש עצמו כמפתח.

835
01:04:28,000 --> 01:04:32,000
זה שום דבר, ומתברר שאנחנו אפילו לא צריכים את המפתח הזה.

836
01:04:32,000 --> 01:04:38,000
אנחנו לא צריכים שאני משתנה.

837
01:04:38,000 --> 01:04:43,000
בשלב זה, אם היינו עושה עוד לולאת foreach

838
01:04:43,000 --> 01:04:48,000
והיינו ללולאה מעל כל arr

839
01:04:48,000 --> 01:04:56,000
ועכשיו, אם קו, אופס הד, מצטער.

840
01:04:56,000 --> 01:05:00,000
אנחנו לא יכולים להשתמש בפסיק. אנחנו צריכים להשתמש בזה כמילת מפתח.

841
01:05:00,000 --> 01:05:05,000
עכשיו, אם הד קו שאנחנו צריכים לקבל את כל המילים הייחודיות בקובץ.

842
01:05:05,000 --> 01:05:10,000
אם תלכו עד some_file.txt,

843
01:05:10,000 --> 01:05:19,000
ונניח שאנחנו עושים תפוח, בננה, תפוח, תפוח, בננה,

844
01:05:19,000 --> 01:05:22,000
אם אתה מדפיס את כל המילים הייחודיות בקובץ זה אנחנו צריכים רק לקבל

845
01:05:22,000 --> 01:05:30,000
תפוח ובננה להדפיס.

846
01:05:30,000 --> 01:05:36,000
אם תצילו את זה, עכשיו אנחנו כאן להתקרב בחזרה,

847
01:05:36,000 --> 01:05:44,000
php unique.php, וTa-da.

848
01:05:44,000 --> 01:05:51,000
אנחנו uniqued קובץ בהצלחה.

849
01:05:51,000 --> 01:05:55,000
>> חלק הסופי של בעיה זו הוא מבקש ממך למיין המערך הזה לפני שהדפסת

850
01:05:55,000 --> 01:05:58,000
כי בדוגמא הפשוטה הזה שאנחנו פשוט עשינו

851
01:05:58,000 --> 01:06:04,000
היו לנו מזל במובן זה שקובץ

852
01:06:04,000 --> 01:06:06,000
עשינו דוגמה המאולצת הזה עם תפוחים ובננות.

853
01:06:06,000 --> 01:06:08,000
זה כבר מסודר.

854
01:06:08,000 --> 01:06:19,000
אבל שימוש בפונקצית הסוג הפשוטה ניתן למיין מערך, וזה די מגניב.

855
01:06:19,000 --> 01:06:24,000
הדבר האחרון שאני רוצה לדבר איתכם על ממש מהר

856
01:06:24,000 --> 01:06:31,000
הוא שזה סוג של PHP הוא טוב ויפה, וזה סופר שימושי

857
01:06:31,000 --> 01:06:43,000
כדי לדעת איך עושה אם אי פעם תצטרך לעשות דברים קטנים, מהירים תכנותי.

858
01:06:43,000 --> 01:06:48,000
לדוגמה, אם אני צריך לכתוב תכנית ש, אומר,

859
01:06:48,000 --> 01:06:53,000
מכניס את כולם לחלקים אני לא מתכוון ללכת ולכתוב אותו ב C.

860
01:06:53,000 --> 01:06:55,000
זה הולך להיות ארוך.

861
01:06:55,000 --> 01:06:57,000
זה הולך להיות סוג של כאב, במיוחד אם יש קבצים המעורבים,

862
01:06:57,000 --> 01:07:00,000
בדיוק כפי שאתם רואים.

863
01:07:00,000 --> 01:07:05,000
זה כל כך יפה שרק עם הרבה קוד זה ממש כאן

864
01:07:05,000 --> 01:07:08,000
היינו יכול לטרוף בקובץ, למשוך את כל הערכים הייחודיים

865
01:07:08,000 --> 01:07:11,000
ולהדפיס אותם בחזרה החוצה.

866
01:07:11,000 --> 01:07:16,000
>> עם זאת, למשימות שלך, לפרויקטים שלך,

867
01:07:16,000 --> 01:07:20,000
אם אתה בונה אתרים עם PHP הכח הוא כי

868
01:07:20,000 --> 01:07:25,000
אנחנו רצים כל קבצי PHP שלנו באמצעות מתורגמן זה,

869
01:07:25,000 --> 01:07:29,000
והמתורגמן הוא עיבוד הכל בתוך תגי PHP,

870
01:07:29,000 --> 01:07:34,000
וכל השאר לא נגעו וירק את התוצאות.

871
01:07:34,000 --> 01:07:40,000
אנחנו יכולים לעשות את זה כדי לבנות HTML תכנותי.

872
01:07:40,000 --> 01:07:46,000
עכשיו, אם אחזור למפרט, הבעיה האחרונה במפרט

873
01:07:46,000 --> 01:07:56,000
מדבר על הרעיון הזה של ריכוזים

874
01:07:56,000 --> 01:08:01,000
ויצירת תפריט נפתח,

875
01:08:01,000 --> 01:08:06,000
שאתה יכול או לא רוצה לעשות, תלוי מה פרויקט הגמר שלך עושה,

876
01:08:06,000 --> 01:08:13,000
המאפשר למשתמש לבחור מתוך רשימה של כל הריכוזים האפשריים

877
01:08:13,000 --> 01:08:15,000
הריכוז שלהם אחד.

878
01:08:15,000 --> 01:08:21,000
עכשיו, זה סוג של כאב להקליד את זה

879
01:08:21,000 --> 01:08:25,000
וצריך לעשות את כל זה באופן ידני, במיוחד כאשר יש לך כדי לוודא

880
01:08:25,000 --> 01:08:28,000
שיש לך את כל סוגריים במקום הנכון ואת כל ציטוטים במקום הנכון,

881
01:08:28,000 --> 01:08:34,000
כך עם PHP אתה יכול לעשות את זה באמצעות תכנות, ואתה יכול לעשות את זה ממש מהר.

882
01:08:34,000 --> 01:08:36,000
>> בואו לראות איך עושה את זה.

883
01:08:36,000 --> 01:08:42,000
אנחנו הולכים לפתוח את קובץ חדש.

884
01:08:42,000 --> 01:08:46,000
אנחנו הולכים לשים בתגי PHP שלנו.

885
01:08:46,000 --> 01:08:53,000
אנחנו הולכים לקרוא לזה concentrations.php,

886
01:08:53,000 --> 01:08:58,000
ועכשיו כשאתה עושה את זה, זה סוג של משהו טוב לחשוב על

887
01:08:58,000 --> 01:09:02,000
כאשר אתה מנסה לערבב ולהתאים PHP ו-HTML שלך שלך

888
01:09:02,000 --> 01:09:08,000
הוא להבין, בסדר, מה הוא חלק שאני רוצה תכנותי לייצר?

889
01:09:08,000 --> 01:09:11,000
מהו חלק שאני תכנותי יכול לייצר?

890
01:09:11,000 --> 01:09:17,000
זה נכון שאתה יכול לעשות את כל HTML שלך

891
01:09:17,000 --> 01:09:19,000
בתוך בלוקי PHP.

892
01:09:19,000 --> 01:09:24,000
אתה יכול להדהד כל HTML כמחרוזות.

893
01:09:24,000 --> 01:09:30,000
לדוגמה, אם אני רוצה להתחיל לעשות את התגים הנבחרים בתוך PHP

894
01:09:30,000 --> 01:09:46,000
אני יכול לומר הד, אומרים לבחור בשם = ריכוז,

895
01:09:46,000 --> 01:09:49,000
ואז למטה אהיה לי תג הד אחר

896
01:09:49,000 --> 01:09:57,000
או הד אחר בשם קרוב לבחור.

897
01:09:57,000 --> 01:10:00,000
זו דרך אחת לעשות את זה כי זה מה שממש לא הולך לעשות

898
01:10:00,000 --> 01:10:09,000
הוא להדפיס את המחרוזת היום כשזה לרוץ דרך מתורגמן PHP,

899
01:10:09,000 --> 01:10:12,000
כך התוצאה תהיה ה-HTML.

900
01:10:12,000 --> 01:10:18,000
אם אני שומר את הקובץ הזה כמו שהוא עכשיו

901
01:10:18,000 --> 01:10:24,000
ואני רץ concentrations.php php

902
01:10:24,000 --> 01:10:26,000
להסתכל על מה שיש לי.

903
01:10:26,000 --> 01:10:30,000
יש לי תג בחר הסגור הפתוח הזה.

904
01:10:30,000 --> 01:10:36,000
>> אם היינו צריך לעשות את זה ואני היה להציל את התוצאה הזאת לקובץ,

905
01:10:36,000 --> 01:10:45,000
אומרים, concentrations.html-המתנה, זה נראה כאילו אני כבר עברתי לצד השני,

906
01:10:45,000 --> 01:11:02,000
עכשיו אם אני פותח כאן concentrations.html אתה רואה יש לי קובץ HTML תקף.

907
01:11:02,000 --> 01:11:05,000
זה קצת מוזר?

908
01:11:05,000 --> 01:11:09,000
אנחנו משתמשים PHP כדי ליצור HTML, ליצור HTML התקף.

909
01:11:09,000 --> 01:11:13,000
כמו שאנחנו עושים זה שאנחנו פשוט סובלים הדפסת PHP

910
01:11:13,000 --> 01:11:16,000
HTML שאנחנו רוצים אותו להדפסה.

911
01:11:16,000 --> 01:11:20,000
זה ממש כמה אתרי PHP עובדים.

912
01:11:20,000 --> 01:11:24,000
כאשר אתה מבקר באתר ששולח לך למשהו כמו

913
01:11:24,000 --> 01:11:30,000
משהו, משהו, משהו dot com הלוכסן index.php

914
01:11:30,000 --> 01:11:33,000
המחשב, פשוטו כמשמעו, הוא קורא את index.php,

915
01:11:33,000 --> 01:11:38,000
מפעיל אותו באמצעות מתורגמן PHP, וכל זבל יוצא

916
01:11:38,000 --> 01:11:49,000
היא שולחת חזרה לדפדפן ואומרת היי, דפדפן מפרשת את זה כ-HTML.

917
01:11:49,000 --> 01:11:54,000
הדבר הנחמד הוא שזה יכול להיות כאב כל זמן לכתוב הד, הד, הד, הד

918
01:11:54,000 --> 01:11:59,000
ולהקיף הכל בציטוטים כמו זה, כך שאם אתה רוצה לכתוב

919
01:11:59,000 --> 01:12:04,000
HTML שהולך להיות סטטית עצמך שאתה יכול לעשות את זה ככה,

920
01:12:04,000 --> 01:12:16,000
לשים אותו בחוץ, לסגור אותו,

921
01:12:16,000 --> 01:12:21,000
ואז אתה מכניס לכאן רק בתוך תגי PHP שבו אתה יודע

922
01:12:21,000 --> 01:12:26,000
אתה רוצה תכנות ליצירה, ובמקרה הזה זה אלה תגי אופציות

923
01:12:26,000 --> 01:12:31,000
שהם כאב ליצירה.

924
01:12:31,000 --> 01:12:37,000
>> לדוגמה, נוכל לייצר תגי אופציות אלף

925
01:12:37,000 --> 01:12:48,000
על ידי עושה משהו כזה, אני $ <1000, אני + +

926
01:12:48,000 --> 01:13:00,000
ואומר ערך אפשרות הד = $-אופס, אני לא יכול לעשות את זה.

927
01:13:00,000 --> 01:13:03,000
ובכן, בואו לנסות את זה ולראות מה קורה.

928
01:13:03,000 --> 01:13:22,000
$ I ואז אומרת לי $ </ אופציה.

929
01:13:22,000 --> 01:13:27,000
במקום צורך להקליד את האפשרות שתג אלף פעמים שונות

930
01:13:27,000 --> 01:13:33,000
אני משתמש בקוד PHP כדי ליצור אותו באופן אוטומטי, באמצעות תכנות.

931
01:13:33,000 --> 01:13:38,000
סוג של nifty. כן.

932
01:13:38,000 --> 01:13:41,000
אני זוכר את זה מוזכר באחת ההרצאה או הדרכה,

933
01:13:41,000 --> 01:13:43,000
אבל מה ההבדל בין המרכאות,

934
01:13:43,000 --> 01:13:45,000
אלה הרגילים ודברים יחידים אלה?

935
01:13:45,000 --> 01:13:49,000
זה באמת משהו שאני עושה לא נכון כאן שאני הולך להראות לך.

936
01:13:49,000 --> 01:13:52,000
את הציטוטים הבודדים אינם מאפשרים כל תווים מיוחדים,

937
01:13:52,000 --> 01:13:57,000
אז כל מה שבתוך מחרוזת מצוטטת אחת מתפרש באופן מילולי.

938
01:13:57,000 --> 01:14:02,000
אם היה לי \ n בתוך גרשיים בודדים ואני שומר את זה, למשל,

939
01:14:02,000 --> 01:14:07,000
ועכשיו אני יורד כאן ולהפעיל אותו,

940
01:14:07,000 --> 01:14:12,000
אופס, לאן אני הולך?

941
01:14:12,000 --> 01:14:19,000
אה, זה בגלל שאני שכחתי $.

942
01:14:19,000 --> 01:14:25,000
>> עכשיו אם אני פותח, ולמעשה, כאן, אנחנו הולכים להיפטר מלהקליד אותו לקובץ.

943
01:14:25,000 --> 01:14:27,000
אנחנו פשוט לקרוא אותו.

944
01:14:27,000 --> 01:14:34,000
כאן אתה רואה שיש לי זה מילולי \ n במחרוזת, כמו לא קו חדש בפועל,

945
01:14:34,000 --> 01:14:38,000
וכמו כן, במקום באמת ביון הערך של זה משתנה

946
01:14:38,000 --> 01:14:42,000
זה נתן לי אני עוצמה, $ שהם סוג של כאב.

947
01:14:42,000 --> 01:14:46,000
דרך לעקוף את זה הוא להשתמש במרכאות הכפולות,

948
01:14:46,000 --> 01:14:52,000
ולאחר מכן כאשר אתה משתמש במרכאות כפולות זה יהיה ממש

949
01:14:52,000 --> 01:14:56,000
כראוי לשרבב את הערכים של כל אחד מהמשתנים הללו בפה

950
01:14:56,000 --> 01:14:59,000
וגם להכיר \ n להיות הקו החדש שזה

951
01:14:59,000 --> 01:15:02,000
ולא \ n.

952
01:15:02,000 --> 01:15:07,000
שימוש אלה הבודדים נחמד כאשר יש לך

953
01:15:07,000 --> 01:15:10,000
דמויות שעשויות להתפרש כתווים מיוחדים, כי אז אתה לא צריך

954
01:15:10,000 --> 01:15:15,000
לברוח מהם כל זמן.

955
01:15:15,000 --> 01:15:18,000
דברים יכולים לקבל מבולגנים, ולעתים קרובות הדרך אני עושה את זה,

956
01:15:18,000 --> 01:15:24,000
רק כדי לעשות את הדברים קלים, הוא שאם אני הולך לי שום דבר

957
01:15:24,000 --> 01:15:31,000
HTML כמו בקוד שלי אני יהיה לכלול עריכה בתוך גרשיים בודדים

958
01:15:31,000 --> 01:15:36,000
ולאחר מכן להשתמש באופרטור שרשור זה

959
01:15:36,000 --> 01:15:43,000
כדי לשרשר את המשתנים פנימה

960
01:15:43,000 --> 01:15:47,000
זוהי דרך נוספת לעשות את זה

961
01:15:47,000 --> 01:15:52,000
איפה שיש לנו הנקודה שהולכת להתחבר זה הוא מחרוזת

962
01:15:52,000 --> 01:15:56,000
עם זה עם זה עם זה,

963
01:15:56,000 --> 01:15:59,000
ועכשיו אני לא צריך לברוח המרכאות הכפולות הללו.

964
01:15:59,000 --> 01:16:02,000
אני לא צריך להשתמש הבחור הזה לברוח.

965
01:16:02,000 --> 01:16:08,000
הם ממש תהיו הדפיסו כמרכאות כפולות ואז הבחור הזה ממש כאן.

966
01:16:08,000 --> 01:16:11,000
זוהי דרך נוספת של ערבוב את הכל ביחד.

967
01:16:11,000 --> 01:16:14,000
>> [סטודנטים] כמו כן, כאשר אתה הדהדת gettype לא היו מירכאות בכלל.

968
01:16:14,000 --> 01:16:22,000
בסדר, אז הוא סוג של הד מיוחד במובן זה שאתה לא צריך את סוגריים.

969
01:16:22,000 --> 01:16:29,000
אתה לא צריך את המרכאות סביב בהכרח משתנה,

970
01:16:29,000 --> 01:16:37,000
כמו שזה חוקי לומר מהדהד לי $, וזה הולך לפרש זאת כמחרוזת.

971
01:16:37,000 --> 01:16:44,000
זה הולך לעשות את הגבס, ולכן אנחנו יכולים לעשות את זה, וזה חוקי, אבל אנחנו לא צריכים את זה.

972
01:16:44,000 --> 01:16:48,000
זה לא חובה.

973
01:16:48,000 --> 01:16:53,000
בסט בעית שבוע זה לחפש הרבה דברים כאלה

974
01:16:53,000 --> 01:16:58,000
לאן אתה לערבב HTML עם PHP

975
01:16:58,000 --> 01:17:08,000
בדיוק כמו זה, ועכשיו אם אנחנו לגלול אחורה ולהפעיל את זה

976
01:17:08,000 --> 01:17:13,000
אנו יכולים לראות שיש לנו חבורה שלמה של ערכי אפשרויות

977
01:17:13,000 --> 01:17:15,000
שרק צריך הדפיס.

978
01:17:15,000 --> 01:17:20,000
יש לנו את כל זה כי יש HTML שנוצר מהר מאוד עבורנו.

979
01:17:20,000 --> 01:17:22,000
אני אשאיר את זה כתרגיל.

980
01:17:22,000 --> 01:17:24,000
זה מאוד דומה לקריאת הקובץ שעשינו קודם לכן.

981
01:17:24,000 --> 01:17:31,000
>> יש קובץ concentrations.txt שתוכל למשוך למטה מCDN,

982
01:17:31,000 --> 01:17:34,000
ואתה יכול לפתוח אותו באמצעות אותו טריק foreach שעשינו קודם לכן,

983
01:17:34,000 --> 01:17:39,000
וforeach אתה רק צריך להדהד אפשרות ותקע

984
01:17:39,000 --> 01:17:44,000
את הערכים המתאימים, את המפתחות ומדדים המתאימים,

985
01:17:44,000 --> 01:17:49,000
ואז אתה מקבל נפתח שממש יוצר

986
01:17:49,000 --> 01:17:54,000
תכנות עבורך את כל הריכוזים השונים באוניברסיטת הרווארד.

987
01:17:54,000 --> 01:17:57,000
דבר שימושי שיש.

988
01:17:57,000 --> 01:18:02,000
יש הרבה דברי תצורה למשימה זו.

989
01:18:02,000 --> 01:18:07,000
אם עדיין לא עשית את זה כבר ייקח השעה הבאה החצי, שעה,

990
01:18:07,000 --> 01:18:10,000
קצת זמן הלילה בהחלט בטוח,

991
01:18:10,000 --> 01:18:14,000
ללכת דרך מפרט סט הבעיה,

992
01:18:14,000 --> 01:18:20,000
ראה מה קורה עם ההגדרה את vhosts, המארח המקומי, כל הדברים האלה.

993
01:18:20,000 --> 01:18:24,000
דבר אחד שיש לציין הוא שעכשיו

994
01:18:24,000 --> 01:18:30,000
ברוב המערכות בעייתיות שאנחנו מתקדמים לתוך תיקיית ה-Dropbox שלך

995
01:18:30,000 --> 01:18:34,000
ולאחר מכן להוריד את קובץ zip סט הבעיה ולפתוח אותו.

996
01:18:34,000 --> 01:18:36,000
לקבוצה את הבעיה שאתה לא רוצה.

997
01:18:36,000 --> 01:18:40,000
אתה רוצה ללכת לספריית vhosts זה.

998
01:18:40,000 --> 01:18:45,000
אתה רוצה להיכנס לvhosts וללכת לספריית המארח המקומית בתוכה,

999
01:18:45,000 --> 01:18:50,000
וזה שבו אתה רוצה למשוך למטה את קובץ ZIP,

1000
01:18:50,000 --> 01:18:55,000
לפתוח אותו, ולקבל מוכן ללכת.

1001
01:18:55,000 --> 01:18:57,000
תצטרך לבצע את השלבים, בשיתוף פעולה הדוקה.

1002
01:18:57,000 --> 01:19:02,000
>> אם יש לך שאלות, לשלוח דואר אלקטרוני, לפרסם אותו בדיון, הגיע לשעתי עבודה.

1003
01:19:02,000 --> 01:19:08,000
תודה חבר 'ה. השבוע הבא אנחנו הולכים להיות מפגש ביקורת לחידון.

1004
01:19:08,000 --> 01:19:12,000
נהנה מסט הבעיה האחרון שלך. אני מקווה שהכל הולך ממש טוב.

1005
01:19:12,000 --> 01:19:14,000
[CS50.TV]