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

2
00:00:12,510 --> 00:00:13,870
>> ROB: בסדר.

3
00:00:13,870 --> 00:00:16,770
ברוכים הבאים לחלק הראשון.

4
00:00:16,770 --> 00:00:17,480
אני רוב.

5
00:00:17,480 --> 00:00:18,806
>> יוסף: אני יוסף.

6
00:00:18,806 --> 00:00:21,540
>> ROB: כך תהיה לנו לצלול ישר פנימה

7
00:00:21,540 --> 00:00:23,420
דבר ראשון שיש לדבר על
הוא Appliance.

8
00:00:23,420 --> 00:00:27,150
אז אני מקווה שרובכם יש לי
הוריד את זה כבר.

9
00:00:27,150 --> 00:00:37,180
אבל אתה יכול לראות את ההוראות
בcs50.net/appliance.

10
00:00:37,180 --> 00:00:38,430
אוי אלוהים, עכשיו אני מודע לעצמו.

11
00:00:38,430 --> 00:00:44,590

12
00:00:44,590 --> 00:00:45,430
אני עדיין שומע אותו.

13
00:00:45,430 --> 00:00:47,232
>> יוסף: וואו, זה נשמע כמו
זה מבולבל.

14
00:00:47,232 --> 00:00:52,460
>> ROB: אז כמה אנשים כבר יש
בעיות עם זה, אז לא לחכות עד

15
00:00:52,460 --> 00:00:54,940
הרגע האחרון של הבעיה מוגדר
לנסות ולפתור את המכשיר ו

16
00:00:54,940 --> 00:00:56,320
לגלות שזה לא עובד.

17
00:00:56,320 --> 00:00:59,010
>> יוסף: ואם משהו לא עובד
ואתה צריך עזרה, אתה יכול ללכת

18
00:00:59,010 --> 00:01:03,390
cs50.net/discussion איפה אנחנו
יש פורום שבו אתה

19
00:01:03,390 --> 00:01:04,110
יכול לפרסם השאלות שלך.

20
00:01:04,110 --> 00:01:06,655
ואנחנו נגיע אליהם בסופו.

21
00:01:06,655 --> 00:01:07,490
>> ROB: בסדר.

22
00:01:07,490 --> 00:01:12,180
אז זה מה שAppliance
נראה.

23
00:01:12,180 --> 00:01:15,480
שוב, זה רק נפרד לחלוטין
מערכת הפעלה שרצה בתוך

24
00:01:15,480 --> 00:01:19,440
מהי מערכת הפעלה אתה
פועלים על המחשב הנייד שלך.

25
00:01:19,440 --> 00:01:24,450
והדברים העיקריים שאתה יהיה
אשתמש הם gedit.

26
00:01:24,450 --> 00:01:28,050
אז אני מקווה שזה כבר
הפך לאתר מוכר.

27
00:01:28,050 --> 00:01:29,470
המסוף.

28
00:01:29,470 --> 00:01:31,890
>> ואתה גם יכול להריץ כרום
בתוך המכשיר.

29
00:01:31,890 --> 00:01:33,860
היו כמה אנשים
שדיווח באינטרנט

30
00:01:33,860 --> 00:01:35,390
לא יעבוד במכשיר.

31
00:01:35,390 --> 00:01:38,090
וחלק מהם פשוט הנחתי
שיש לא אמור להיות

32
00:01:38,090 --> 00:01:39,190
אינטרנט במכשיר.

33
00:01:39,190 --> 00:01:40,750
אבל כן, יש אמורה
להיות באינטרנט.

34
00:01:40,750 --> 00:01:44,000

35
00:01:44,000 --> 00:01:46,410
>> אני אגיד את זה עכשיו, אבל זה לא
באמת אומר שום דבר.

36
00:01:46,410 --> 00:01:50,680
אם האינטרנט לא עובד,
זה מה שאתה נוטה צריך

37
00:01:50,680 --> 00:01:52,180
לרוץ כדי לתקן את זה.

38
00:01:52,180 --> 00:01:55,602
אם אתה נתקלת בבעיות באינטרנט, לא
זוכר את זה, רק לכתוב את זה על

39
00:01:55,602 --> 00:01:57,560
דיון, ואנו אומרים, להפעיל את זה.

40
00:01:57,560 --> 00:02:00,420
אבל האינטרנט צריך לעבוד.

41
00:02:00,420 --> 00:02:06,650
>> אז הדבר היחיד האחר - כן, שום דבר
השאר הוא באמת רלוונטי.

42
00:02:06,650 --> 00:02:08,979
אבל אני רק רציתי לציין ש--

43
00:02:08,979 --> 00:02:13,290
רואה בפינה ימנית תחתון זה.

44
00:02:13,290 --> 00:02:16,530
אז כל אחד ממכשירי חשמל שלך צריך
יש כתובת IP.

45
00:02:16,530 --> 00:02:22,350
ומאוחר יותר בסמסטר, IP זה
כתובת תהפוך לרלוונטית יותר כאשר

46
00:02:22,350 --> 00:02:27,230
אתה עובד על p-סט האינטרנט, כי
תוכל לגשת

47
00:02:27,230 --> 00:02:32,310
אתר שאתה עובד על משלך
Chrome המקומי באמצעות כתובת ה-IP הזה.

48
00:02:32,310 --> 00:02:35,400
>> אבל מה שאני רוצה להשתמש בכתובת ה-IP
ל-- ואתה לא חייב לעשות את זה, אני

49
00:02:35,400 --> 00:02:37,460
רק רוצה להצביע עליה -

50
00:02:37,460 --> 00:02:39,540
הוא כאן.

51
00:02:39,540 --> 00:02:42,910
אז זהו חלון מסוף ב
Mac שלי, זה לא ב

52
00:02:42,910 --> 00:02:44,580
מכשיר בכלל.

53
00:02:44,580 --> 00:02:47,190
ואתה יכול לחפש את מה
פקודה זו עושה.

54
00:02:47,190 --> 00:02:51,855
אבל אני הולך לSSH ישירות
למכשיר שלי.

55
00:02:51,855 --> 00:02:53,410
אני לא יודע מה ה-IP.

56
00:02:53,410 --> 00:02:54,300
>> יוסף: 168 -

57
00:02:54,300 --> 00:02:56,080
>> 168.224.1.0.

58
00:02:56,080 --> 00:02:59,950
>> ROB: אז ברגע שאני גומר
עם זה, להיכנס פנימה

59
00:02:59,950 --> 00:03:05,450
עכשיו, בעצם, זה זהה ל
חלון מסוף בתוך המכשיר שלי.

60
00:03:05,450 --> 00:03:10,280
אז אף פעם לא עבדתי די הרבה בעצם
מתוך המכשיר עצמו.

61
00:03:10,280 --> 00:03:12,550
אני פשוט תמיד אותו פועל
ברקע ממוזער

62
00:03:12,550 --> 00:03:15,890
וSSHed לתוכה.

63
00:03:15,890 --> 00:03:24,270
>> הבעיה עם זה הוא שאתה לא הולך
כדי להיות מסוגל להשתמש gedit בקלות

64
00:03:24,270 --> 00:03:25,600
ישירות מזה.

65
00:03:25,600 --> 00:03:31,500
אבל אם אתה רוצה להיות מגניב אמיתי
האקר, אז אתה צריך להתרגל ל

66
00:03:31,500 --> 00:03:34,220
עורך פקודת שורת טקסט בכל מקרה.

67
00:03:34,220 --> 00:03:39,620
אז Vim ו Emacs וננו, כל אלה
חלופות שונות.

68
00:03:39,620 --> 00:03:41,560
ננו נוטה להיות הקל ביותר.

69
00:03:41,560 --> 00:03:45,006
ואני חושב שאין לה
הדגשת תחביר.

70
00:03:45,006 --> 00:03:47,620
אה, לא, זה לגמרי עושה.

71
00:03:47,620 --> 00:03:49,870
אז אתה יכול להשתמש Nano, כי
כי אחד די קל.

72
00:03:49,870 --> 00:03:52,000
>> אתה רואה את כל הפקודות הללו
בתחתית.

73
00:03:52,000 --> 00:03:54,750
סמל גזר הקטן הזה.

74
00:03:54,750 --> 00:03:57,620
אם לא ראה את זה קודם, תוכל
כנראה רואה את זה הרבה עכשיו.

75
00:03:57,620 --> 00:04:02,350
זה בדרך כלל אומר את גזר השליטה,
כמו החלק התחתון השמאלי של מקלדת

76
00:04:02,350 --> 00:04:04,130
אופי שליטה.

77
00:04:04,130 --> 00:04:07,260
אז הנה זה אומר לי כאן למטה -

78
00:04:07,260 --> 00:04:08,710
אה, זה לא נותק אם אני זום פנימה

79
00:04:08,710 --> 00:04:11,040
אז בקרה, X הוא איך
אני הולך לצאת.

80
00:04:11,040 --> 00:04:14,710
וזה אומר שאני יכול לפגוע Y עבור
כן, לחיסכון, N למס

81
00:04:14,710 --> 00:04:17,190
אז זה נאנו.

82
00:04:17,190 --> 00:04:22,860
>> Vim ו Emacs נוטים להיות מעט יותר
מסובך ומכריע.

83
00:04:22,860 --> 00:04:28,840
אבל אתה יכול להתרגל לזה,
ואז אתה תאהב את זה.

84
00:04:28,840 --> 00:04:30,590
אז זהו זה.

85
00:04:30,590 --> 00:04:31,720
>> יוסף: אין צורך לעשות את זה.

86
00:04:31,720 --> 00:04:31,840
>> ROB: כן.

87
00:04:31,840 --> 00:04:37,510
אתה חופשי להשתמש gedit עבור
שארית הסמסטר.

88
00:04:37,510 --> 00:04:40,630
אז כל שאלות הקשורות למכשיר?

89
00:04:40,630 --> 00:04:42,820
או האם יש לך מחשבות על מה עוד
צריכה להיות דיבר על כ

90
00:04:42,820 --> 00:04:43,610
המכשיר?

91
00:04:43,610 --> 00:04:43,996
כן.

92
00:04:43,996 --> 00:04:47,720
>> SPEAKER 1: כאשר אתה SSHed אליך
דבר, היה Crimson הסיסמה?

93
00:04:47,720 --> 00:04:48,390
>> ROB: כן.

94
00:04:48,390 --> 00:04:50,170
הסיסמה לכל דבר די הרבה
במכשיר הוא הולך

95
00:04:50,170 --> 00:04:52,473
להיות הארגמן.

96
00:04:52,473 --> 00:04:56,517
>> SPEAKER 2: התקנה כמו IDE אמיתי
על המכשיר, זה יעבוד?

97
00:04:56,517 --> 00:04:59,200

98
00:04:59,200 --> 00:05:07,290
>> ROB: אני מתאר לעצמי Eclipse עושה לי
גרסת פדורה, ובמקרה כזה, כן,

99
00:05:07,290 --> 00:05:08,420
אתה יכול לעשות את זה.

100
00:05:08,420 --> 00:05:10,875
זה כנראה לא ממש שווה את זה.

101
00:05:10,875 --> 00:05:11,742
>> SPEAKER 2: אישור.

102
00:05:11,742 --> 00:05:15,924
אז זה כנראה קל יותר אם אני רוצה
להשתמש באקליפס, פשוט להשתמש היליד ו

103
00:05:15,924 --> 00:05:17,646
לאחר מכן להעלות ל--

104
00:05:17,646 --> 00:05:21,090
>> ROB: אה, זה הוא גם כנראה יותר קל.

105
00:05:21,090 --> 00:05:24,046
אבל אתה יכול לקבל את זה עובד
בתוך המכשיר.

106
00:05:24,046 --> 00:05:27,740
>> יוסף: ולמצלמה, השאלה
היה, אתה יכול להתקין עוד

107
00:05:27,740 --> 00:05:29,490
IDE הפנימי של המכשיר?

108
00:05:29,490 --> 00:05:31,520
>> ROB: Eclipse להיות
דוגמא של IDE.

109
00:05:31,520 --> 00:05:34,800

110
00:05:34,800 --> 00:05:36,050
כל שאלות מכשיר אחרות?

111
00:05:36,050 --> 00:05:38,250

112
00:05:38,250 --> 00:05:38,680
בסדר.

113
00:05:38,680 --> 00:05:44,920
>> אז אנחנו עכשיו נעבור לשורת הפקודה
דברים הקשורים לממשק, כך CLI.

114
00:05:44,920 --> 00:05:47,990
ושוב, אני רק הולך לעבודה ב
כאן, כי זה זהה ל

115
00:05:47,990 --> 00:05:52,780
עובד בתוך חלון מסוף
בתוך המכשיר.

116
00:05:52,780 --> 00:05:54,160
כיצד גופן שמחפש?

117
00:05:54,160 --> 00:05:55,970
האם זה גדול מספיק?

118
00:05:55,970 --> 00:05:57,000
בסדר.

119
00:05:57,000 --> 00:06:02,480
>> אז יש הרבה פקודות ש
אתה צריך לקבל די נהג

120
00:06:02,480 --> 00:06:04,490
במהלך הסמסטר.

121
00:06:04,490 --> 00:06:09,480
שני הגדולים לניווט הם ls, רשימה
הקבצים בספרייה זו, ו

122
00:06:09,480 --> 00:06:11,380
cd, אז לשנות את הספרייה.

123
00:06:11,380 --> 00:06:18,390
אז אני יכול לשנות לשולחן עבודה ולאחר מכן
דפוס נפוץ מאוד הוא cd כדי

124
00:06:18,390 --> 00:06:22,550
ls ספרייה ומייד
מה במדריך.

125
00:06:22,550 --> 00:06:25,540
>> אנשים גם לפעמים לא מבינים
שהשלמת Tab היא דבר.

126
00:06:25,540 --> 00:06:28,370
cd אז כמו, VH, ואז הקש על Tab.

127
00:06:28,370 --> 00:06:30,790
אני כמעט אף פעם לא להקליד את
את הדבר כולו.

128
00:06:30,790 --> 00:06:32,920
ואז אם אני ממשיך להכות Tab
שוב, זה באופן אוטומטי

129
00:06:32,920 --> 00:06:33,670
להתחיל רישום בשבילי.

130
00:06:33,670 --> 00:06:37,000
אז אני יכול vhosts cd, מארח מקומי.

131
00:06:37,000 --> 00:06:39,880
וזה רק הולך -

132
00:06:39,880 --> 00:06:43,380
במקרה שלא שמע את המושג
לפני כן, בספרייה היא רק מילה אחרת

133
00:06:43,380 --> 00:06:45,170
לתיקייה.

134
00:06:45,170 --> 00:06:49,930
אז עכשיו אם אתה רואה -

135
00:06:49,930 --> 00:06:51,810
בואו להביא את זה לראש.

136
00:06:51,810 --> 00:06:55,380
>> אז עכשיו אם אתה רואה בסוגריים, אתה
לראות קצת טילדה, הלוכסן, vhost,

137
00:06:55,380 --> 00:06:56,810
לוכסן, מארח מקומי.

138
00:06:56,810 --> 00:07:00,040
אז טילדה, שמתייחסת
בספרייה הביתית שלי.

139
00:07:00,040 --> 00:07:03,090
זה מדריך שאתה
בעת SSH פנימה

140
00:07:03,090 --> 00:07:05,660
זה המדריך שאתה בכאשר
אתה פותח את מסוף.

141
00:07:05,660 --> 00:07:08,650
זה המקום שבו אתה מתחיל.

142
00:07:08,650 --> 00:07:13,110
ואז אני פנימי של ספריית הבית שלי,
ואני בתוך vhost

143
00:07:13,110 --> 00:07:14,475
בתוך ספרייה של ספריית הבית שלי.

144
00:07:14,475 --> 00:07:19,670
ולאחר מכן אני פנימי של מקומי
תארח ספרייה הפנימית שלו.

145
00:07:19,670 --> 00:07:23,740
>> אז כמה דברים שימושיים אחרים עם דיסק -

146
00:07:23,740 --> 00:07:29,220
או גם, באופן כללי, כך שנקודה תמיד
מתייחס לספרייה הנוכחית.

147
00:07:29,220 --> 00:07:31,130
Cd, נקודה היא פקודה די חסרת ערך.

148
00:07:31,130 --> 00:07:35,150
אבל זה משתנה ל
ספרייה נוכחית.

149
00:07:35,150 --> 00:07:38,230
שימושי יותר אחד במונחים של
cd הוא נקודה, נקודה, שהיא

150
00:07:38,230 --> 00:07:40,220
רק לעלות ספרייה אחת.

151
00:07:40,220 --> 00:07:43,360
>> ושים לב כי אלה -

152
00:07:43,360 --> 00:07:48,610
אני רוצה להגיד שמות בדויים, אבל אלה
סמלים, נקודה, ונקודה, נקודה, עבודה אלה

153
00:07:48,610 --> 00:07:51,740
לכמעט כל פקודה שאתה
הולך לחשוב על הריצה.

154
00:07:51,740 --> 00:07:55,370
cd אז כמו הוא כנראה איפה אתה אהיה
שימוש ביותר, אך אלה אינם

155
00:07:55,370 --> 00:07:56,780
דברים שפשוט cd מבין.

156
00:07:56,780 --> 00:07:59,980
זה פחות או יותר משהו כולו שלך
שורת הפקודה מבינה.

157
00:07:59,980 --> 00:08:01,932
הרבה תוכניות להבין
נקודה ונקודה, נקודה.

158
00:08:01,932 --> 00:08:04,830

159
00:08:04,830 --> 00:08:09,090
>> אז שימושיים אלה אחרים - cd, המקף.

160
00:08:09,090 --> 00:08:13,460
כך שהוא הולך להביא לי
הספרייה האחרונה שהייתי בה

161
00:08:13,460 --> 00:08:15,980
אז לפעמים אני אעשה משהו כמו,
הו, אני עובד כאן.

162
00:08:15,980 --> 00:08:21,110
ואני רואה את שגיאה מסוימת עם משהו, ו
אני אלך לחקור אותו על ידי לחיצה על

163
00:08:21,110 --> 00:08:24,020
כמה ספרייה אקראית במקום כלשהו.

164
00:08:24,020 --> 00:08:25,260
ואני לא יודע אם זה יהיה
תן לי שם.

165
00:08:25,260 --> 00:08:25,720
זה יהיה.

166
00:08:25,720 --> 00:08:27,615
אז אני עושה מה שאני רוצה
במדריך זה.

167
00:08:27,615 --> 00:08:28,950
בלה, בלה, בלה, בלה, בלה.

168
00:08:28,950 --> 00:08:31,770
ואני הייתי כמו, בסדר, אני רוצה
כדי לחזור למקום שהייתי.

169
00:08:31,770 --> 00:08:34,490
cd, מקף, וזה מביא אותי ישר בחזרה.

170
00:08:34,490 --> 00:08:39,970
>> אז אני הולך לזרוק הרבה
אלה עליך היום.

171
00:08:39,970 --> 00:08:43,730
אני לא מצפה ממך לשנן
את כולם.

172
00:08:43,730 --> 00:08:46,170
זה סוג של פשוט יודע
שהם קיימים.

173
00:08:46,170 --> 00:08:48,690
ואז מאוחר יותר כאשר אתה כמו,
הממ, אני רוצה לחזור ל

174
00:08:48,690 --> 00:08:51,870
ספרייה שהייתי רק ב, הו, חכה,
משהו כמו מה שקיים.

175
00:08:51,870 --> 00:08:53,980
אתה לא צריך רק להקליד
בכל המדריך שוב.

176
00:08:53,980 --> 00:08:56,090
>> יוסף: וסופו של דבר אתה פשוט
להשתמש בם שוב ושוב, ו

177
00:08:56,090 --> 00:08:57,830
זה יהפוך זיכרון שריר.

178
00:08:57,830 --> 00:09:00,090
>> ROB: כן.

179
00:09:00,090 --> 00:09:02,930
אז איך שאמרתי קודם, שטילדה
היא ספריית הבית שלך.

180
00:09:02,930 --> 00:09:04,820
אז אני יכול cd, טילדה.

181
00:09:04,820 --> 00:09:07,280
אבל גם אין לי ל
לעשות את זה אם אני רק -

182
00:09:07,280 --> 00:09:09,760
אני אחזור לספרייה ולכן
זה לא דוגמא חסרת טעם.

183
00:09:09,760 --> 00:09:14,560
אבל אם אני רק עושה cd, זה גם
זהה, ללכת לספריית הבית שלי.

184
00:09:14,560 --> 00:09:18,380

185
00:09:18,380 --> 00:09:19,880
אני עושה את הפיקוד, ק

186
00:09:19,880 --> 00:09:24,015
>> יוסף: אתה יכול גם להקליד ברור,
מילה, ואת זה צריך לנקות אותה.

187
00:09:24,015 --> 00:09:28,650
>> רוב: ואני חושב שגם בקרה,
L גם עושה את זה.

188
00:09:28,650 --> 00:09:29,690
אז הרבה דרכים שונות.

189
00:09:29,690 --> 00:09:34,070
אני חושב שיש כמה הבדלים שבו
ברור ובקרה, L יהיה פשוט

190
00:09:34,070 --> 00:09:37,280
באמת לדחוף את זה לראש ו
אני עדיין יכול לגלול אחורה.

191
00:09:37,280 --> 00:09:40,580
פיקוד, K הורס, פשוטו כמשמעו,
כל דבר, ואתה

192
00:09:40,580 --> 00:09:42,960
לא ניתן לגלול בחזרה למעלה.

193
00:09:42,960 --> 00:09:45,530
לכל הפחות, זה
איך זה עובד בiTerm2.

194
00:09:45,530 --> 00:09:48,690
אני לא יודע איך דברים אחרים -

195
00:09:48,690 --> 00:09:49,360
הו.

196
00:09:49,360 --> 00:09:55,450
>> עם SSHing, כך שאם אתה ב-Windows,
אתה הולך צריך להוריד מרק

197
00:09:55,450 --> 00:10:02,360
כדי SSH מאז Windows לא
יש לי כמו כלי מובנה SSH.

198
00:10:02,360 --> 00:10:06,150
ממחשבי מקינטוש, אתה יכול פשוט SSH ישירות
מחלון מסוף.

199
00:10:06,150 --> 00:10:08,755

200
00:10:08,755 --> 00:10:09,690
על אישור.

201
00:10:09,690 --> 00:10:11,840
שאלות?

202
00:10:11,840 --> 00:10:19,260
>> עם ls, אז משהו להתרגל
עם רוב של פקודות אלה היא -

203
00:10:19,260 --> 00:10:20,060
כן, אני פשוט עושה אחד.

204
00:10:20,060 --> 00:10:21,310
Ls, מקף, אני.

205
00:10:21,310 --> 00:10:26,330
אז המקף, l הוא מה אנחנו הולכים
לקרוא לדגל לls.

206
00:10:26,330 --> 00:10:30,770
והרבה פקודות אלה יש דגלים
שאתה יכול לעבור אליהם.

207
00:10:30,770 --> 00:10:35,020
אז במקרה הזה, מקף, l הוא דגל
שאומר לו שייתן לי מלא

208
00:10:35,020 --> 00:10:37,850
רישום של כל המידע
של קבצים אלה.

209
00:10:37,850 --> 00:10:44,790
>> אז אנחנו רואים כאן ששולחן העבודה הייתה
הותאם יום 30 ביולי בשעה 12:54.

210
00:10:44,790 --> 00:10:47,160
הורדות שונה ב -6 בספטמבר.

211
00:10:47,160 --> 00:10:52,350
אלה הם גודלו הנוכחי ו
בתים של ספריות אלה.

212
00:10:52,350 --> 00:10:54,412
אתה לא צריך להבין
את כל זה.

213
00:10:54,412 --> 00:11:00,380
>> החומר הזה בצד השמאל, drwx של אלה,
שיהפוך להרבה יותר רלוונטי

214
00:11:00,380 --> 00:11:02,290
מאוחר יותר, כאשר יש לך להתמודד עם -

215
00:11:02,290 --> 00:11:05,900
כי יש לעשות עם מי שיש לו הרשאות
להסתכל על קבצים אלה.

216
00:11:05,900 --> 00:11:09,880
ולכן אם לא היית משתמש רק ב
מחשב זה, אתה יהיה מסוגל

217
00:11:09,880 --> 00:11:13,345
נניח, בסדר, אני צריך להיות רק אחד
מותר להסתכל על קובץ זה או אני

218
00:11:13,345 --> 00:11:14,870
הולך כדי לאפשר לכולם
להסתכל על קובץ זה.

219
00:11:14,870 --> 00:11:17,710
אז מישהו אחר במחשב שלי
יכול להסתכל בקובץ זה.

220
00:11:17,710 --> 00:11:22,190

221
00:11:22,190 --> 00:11:25,600
אני אפילו לא יודע מה זה -
מה זה עושה?

222
00:11:25,600 --> 00:11:26,840
>> יוסף: אני לא ממש בטוח, בעצם.

223
00:11:26,840 --> 00:11:27,705
>> רוב: אין לי מושג.

224
00:11:27,705 --> 00:11:30,530
>> יוסף: אבל אם אתה לא יודע, יש
הפקודה מועילה שאתה יכול להשתמש

225
00:11:30,530 --> 00:11:31,680
להגיד לך מה הפלט אומר.

226
00:11:31,680 --> 00:11:33,780
ואם תקלידו באדם
לפני הפקודה -

227
00:11:33,780 --> 00:11:35,000
כך M--N. ROB: אדם.

228
00:11:35,000 --> 00:11:37,690
אז איש הוא עוד אחד
כי הוא מאוד שימושי.

229
00:11:37,690 --> 00:11:39,540
ואדם, ls.

230
00:11:39,540 --> 00:11:47,320
אז הדפים בנאדם, יש להם שני
פקודות שאתה הולך להיות באמצעות

231
00:11:47,320 --> 00:11:50,330
בשורת הפקודה, ויש להם גם
פונקציות שתהיינה רלוונטי

232
00:11:50,330 --> 00:11:52,530
עם ג אז אתה יכול אדם -

233
00:11:52,530 --> 00:11:53,720
ואני התעלמתי 3.

234
00:11:53,720 --> 00:11:57,410
אבל איש printf 3 הוא הולך להביא
את גרסת C של printf.

235
00:11:57,410 --> 00:12:01,030
אבל אם אני פשוט עושה את printf איש, זה
הולך להביא את printf הפקודה

236
00:12:01,030 --> 00:12:03,540
זה קורה בשורת הפקודה.

237
00:12:03,540 --> 00:12:05,730
>> אז גבר, ls.

238
00:12:05,730 --> 00:12:09,030
דפי האדם יכולים להיות די
מכריע.

239
00:12:09,030 --> 00:12:12,770
כאן, לעומת זאת, תוכל לראות רשימה זו
של כל הדגלים הללו שls

240
00:12:12,770 --> 00:12:14,300
מבין.

241
00:12:14,300 --> 00:12:17,876
אז אם אנחנו הולכים למקף, l, ו--

242
00:12:17,876 --> 00:12:19,300
אני רק הולך לזרוק את זה עליך.

243
00:12:19,300 --> 00:12:23,050
אבל, לשם חיפוש, אתה רוצה
לראשון פגע בשאלה

244
00:12:23,050 --> 00:12:24,780
סימן או על לחצן קו נטוי.

245
00:12:24,780 --> 00:12:26,040
אז לחתוך.

246
00:12:26,040 --> 00:12:29,000
>> ואז אני יכול לחפש
לכל מה שאני רוצה.

247
00:12:29,000 --> 00:12:33,780
אז אני הולך לקצץ למקף, אני.

248
00:12:33,780 --> 00:12:35,110
והוא היה שם.

249
00:12:35,110 --> 00:12:37,450
אז להשתמש בפורמט רישום ארוך.

250
00:12:37,450 --> 00:12:40,060
זה לא עוזר לי להבין מה
עמודה מסוימת שהתכוונה, אבל אני

251
00:12:40,060 --> 00:12:44,480
מניח במקום כלשהו בכאן
זה יכול להסביר את זה.

252
00:12:44,480 --> 00:12:48,740
אז להשתמש בדפי האדם לכל פקודה
כי אתה לא מבין מייד.

253
00:12:48,740 --> 00:12:51,080
>> אני די בטוח שאתה יכול אפילו גבר, גבר.

254
00:12:51,080 --> 00:12:53,070
ממשק לאינטרנט
מדריכים.

255
00:12:53,070 --> 00:12:57,700

256
00:12:57,700 --> 00:13:03,570
אה, האחרון אחד זה אולי מעט
ls הרלוונטי הוא, מקף,.

257
00:13:03,570 --> 00:13:08,490
אז שם לב אם אני פשוט עושה את ls,
אני מקבל את חמשת הקבצים הללו.

258
00:13:08,490 --> 00:13:11,480
אם אני עושה ls, מקף,, אני
תקבל הרבה יותר קבצים.

259
00:13:11,480 --> 00:13:15,350
אז הדבר במשותף בין כל אלה
קבצים חדשים הוא הנקודה מראש.

260
00:13:15,350 --> 00:13:21,220
>> אז האמנה היא שקובץ ש
מתחיל עם נקודה נסתרת.

261
00:13:21,220 --> 00:13:25,300
כך שאתה לא רוצה לראות קובץ זה, אתה
לא רוצה שיהיה לו להתעסק עם

262
00:13:25,300 --> 00:13:26,750
הרישום בספרייה שלך.

263
00:13:26,750 --> 00:13:30,020
זה רק כאשר הבקשה המפורשת שלך,
בסדר, ls, המקף,, תראה לי.

264
00:13:30,020 --> 00:13:32,830
מייצג את כל הקבצים,
כולל אלה מוסתרים.

265
00:13:32,830 --> 00:13:37,260

266
00:13:37,260 --> 00:13:39,270
אז כמה פקודות אחרות.

267
00:13:39,270 --> 00:13:41,323
אה, שאלות בשלב זה?

268
00:13:41,323 --> 00:13:41,746
כן.

269
00:13:41,746 --> 00:13:45,914
>> SPEAKER 3: כאשר אתה עושה ls,
, מה זה הנקודה, הנקודה?

270
00:13:45,914 --> 00:13:46,870
>> ROB: אוה.

271
00:13:46,870 --> 00:13:48,780
אז זה מה שאני מדבר.

272
00:13:48,780 --> 00:13:50,890
זה אותו הדבר שבו
אני יכול כמו CD, נקודה, נקודה.

273
00:13:50,890 --> 00:13:56,790
אז מבחינה טכנית, נקודה ונקודה, נקודה הן
קבצים שקיימים בכל אחד

274
00:13:56,790 --> 00:14:03,620
ספרייה שבה קובץ הנקודה מתייחס
לספרייה הנוכחית.

275
00:14:03,620 --> 00:14:06,930
אז אם אני cd, נקודה, אני רק הולך
כדי להישאר בספרייה.

276
00:14:06,930 --> 00:14:10,870
ונקודה, נקודה תמיד מתייחסת
רמה מעלה קודם במדריך אחד.

277
00:14:10,870 --> 00:14:18,200
אז אם אני נכנסתי ליומנים וls, מקף, אל,
אני תראה את הנקודה, נקודה. cd לנקודה, נקודה

278
00:14:18,200 --> 00:14:20,390
מביא אותי לספרייה הקודמת.

279
00:14:20,390 --> 00:14:24,530

280
00:14:24,530 --> 00:14:25,780
כן.

281
00:14:25,780 --> 00:14:27,160

282
00:14:27,160 --> 00:14:28,110
על אישור.

283
00:14:28,110 --> 00:14:33,070
>> אז עוד די חשוב
הפקודה rm.

284
00:14:33,070 --> 00:14:35,650
אז זה מה שאנחנו הולכים
כדי להשתמש בו כדי להסיר.

285
00:14:35,650 --> 00:14:38,100
ותן לי בעצם לעשות עוד
הפקודה ראשונה.

286
00:14:38,100 --> 00:14:39,610
אז mkdir.

287
00:14:39,610 --> 00:14:42,770
Mkdir הוא איך אתה יכול
יצירת תיקיות.

288
00:14:42,770 --> 00:14:47,530
ואני ליצור ספרייה זמנית
ונכנס לזה בספרייה זמנית.

289
00:14:47,530 --> 00:14:49,590
וכצפוי, זה ריק.

290
00:14:49,590 --> 00:14:53,680
אבל אם אני ls, מקף,, עדיין יש לי נקודה
ונקודה, נקודה, כי נקודה מתייחסת

291
00:14:53,680 --> 00:14:54,480
הספרייה הנוכחית.

292
00:14:54,480 --> 00:14:56,170
ונקודה, נקודה מתייחסת
ספרייה קודמת.

293
00:14:56,170 --> 00:14:58,700
ואלה תמיד יהיו קיימים לא משנה
הספרייה בו אתה נמצא

294
00:14:58,700 --> 00:15:01,910

295
00:15:01,910 --> 00:15:09,010
>> וזו היא מיותרת לחלוטין
הפקודה, אבל מגע.

296
00:15:09,010 --> 00:15:11,880
אני רק משתמש בו, כי זה
דרך קלה ליצור קבצים.

297
00:15:11,880 --> 00:15:16,180
אז לגעת, לגעת b, c הוא רק לגעת
הולך ליצור שלושה קבצים שנקראים,

298
00:15:16,180 --> 00:15:17,845
b, ו-c הם ריקים לחלוטין.

299
00:15:17,845 --> 00:15:20,450

300
00:15:20,450 --> 00:15:24,980
אז הנקודה שלי יצירת אלה ב
המקום הראשון הוא פשוט כל כך rm שהוא

301
00:15:24,980 --> 00:15:26,250
איך אנחנו יכולים להסיר אותם.

302
00:15:26,250 --> 00:15:27,850
אז rm,.

303
00:15:27,850 --> 00:15:30,960
זה הולך לשאול אותי, להסיר
קובץ ריק רגיל?

304
00:15:30,960 --> 00:15:33,170
ואז אני אגיד כן.

305
00:15:33,170 --> 00:15:39,090
>> אז אם אני יודע בודאות שאני רוצה
למחוק את הקובץ שמבלי להיות

306
00:15:39,090 --> 00:15:44,500
תתבקש לעשות זאת, להסיר את הקובץ ריק רגיל?,
אז rm, מקף, ו הולך להיות

307
00:15:44,500 --> 00:15:48,230
דגל שאומר, לכפות להסיר ללא
גם מה שגרם לי, אה, אתה

308
00:15:48,230 --> 00:15:49,710
בטוח שברצונך למחוק את הקובץ?

309
00:15:49,710 --> 00:15:50,810
כן, אני בטוח.

310
00:15:50,810 --> 00:15:56,050
אז rm, מקף, fb פשוט יהיה
לעשות את זה בלי לשאול.

311
00:15:56,050 --> 00:15:57,950
>> אז בואו נעשה כמה מדריכים יותר.

312
00:15:57,950 --> 00:16:03,670
mkdir, tmp2, CD, tmp2,
לגעת, לגעת ב.

313
00:16:03,670 --> 00:16:04,300
על אישור.

314
00:16:04,300 --> 00:16:08,180
אז עכשיו אני רוצה להסיר
tmp2 כמדריך.

315
00:16:08,180 --> 00:16:10,316
tmp2 אז rm.

316
00:16:10,316 --> 00:16:12,920
לא ניתן להסיר tmp2,
זה מדריך.

317
00:16:12,920 --> 00:16:21,370
אז הבעיה כאן היא שrm לא
עובדים באופן מיידי על ספריות.

318
00:16:21,370 --> 00:16:26,530
זה נועד רק עבור קבצים כמו
קבצים שאינו בספרייה.

319
00:16:26,530 --> 00:16:30,800
>> ואז מה אנחנו יכולים לעשות
כאן הוא rm, מקף, r.

320
00:16:30,800 --> 00:16:35,160
שעומד, לאופן רקורסיבי אשר עשויים
לא אומר לך משהו עדיין.

321
00:16:35,160 --> 00:16:38,280
אבל כשאתה מגיע לרקורסיה,
זה יהיה מתכוון יותר.

322
00:16:38,280 --> 00:16:43,540
אז rm, מקף, r, tmp2 הולך
באופן רקורסיבי להיכנס לספרייה זו.

323
00:16:43,540 --> 00:16:45,540
ירידה לתוך tmp2 ספרייה?

324
00:16:45,540 --> 00:16:47,330
כן, בואו ניכנס לזה.

325
00:16:47,330 --> 00:16:49,360
האם אנו רוצים להסיר tmp2 /?

326
00:16:49,360 --> 00:16:49,745
כן.

327
00:16:49,745 --> 00:16:51,830
האם אנו רוצים להסיר tmp2 / b?

328
00:16:51,830 --> 00:16:52,840
כן.

329
00:16:52,840 --> 00:16:55,170
עכשיו אנחנו רוצים להסיר
tmp2 הספרייה?

330
00:16:55,170 --> 00:16:56,040
כן.

331
00:16:56,040 --> 00:16:58,410
ואז עכשיו הספרייה
והכל בפנים

332
00:16:58,410 --> 00:16:59,660
שלו הוסר.

333
00:16:59,660 --> 00:17:02,850

334
00:17:02,850 --> 00:17:07,250
>> יש מבחינה טכנית rmdir הפקודה
כי אתה יכול להשתמש בו כדי להסיר את

335
00:17:07,250 --> 00:17:11,670
ספריות, אבל זה עובד רק
על ספריות ריקות בכל מקרה.

336
00:17:11,670 --> 00:17:14,109
ולראות את זה, בוא פשוט
לעשות mkdir, tmp2 שוב.

337
00:17:14,109 --> 00:17:15,940
Tmp2, לגעת.

338
00:17:15,940 --> 00:17:16,800
על אישור.

339
00:17:16,800 --> 00:17:22,770
אז אם אני מנסה להסיר dirtmp2, זה יהיה
אומר, ספרייה אינה ריק.

340
00:17:22,770 --> 00:17:29,540
אז אני פחות או יותר לא להשתמש בהסרה
פקודת dir כל מקרה, כי rm, מקף,

341
00:17:29,540 --> 00:17:35,140
r יעבוד על ספריות ריקות
וספריות שאינן ריקות.

342
00:17:35,140 --> 00:17:37,760
>> וגם, אם אני לא רוצה צריך
לעבור את כל תהליך של

343
00:17:37,760 --> 00:17:40,720
יורד לתוך הספרייה ו
הסרת כל קובץ בודד, RM,

344
00:17:40,720 --> 00:17:44,190
מקף, RF, tmp2.

345
00:17:44,190 --> 00:17:45,670
ועכשיו זה נעלם.

346
00:17:45,670 --> 00:17:51,220
>> משהו להיות זהיר
עליו הוא rm, מקף, RF.

347
00:17:51,220 --> 00:17:53,660
וזה מפחיד אותי אפילו להקליד את זה,
כי אם אני בטעות

348
00:17:53,660 --> 00:17:55,090
על Enter או משהו.

349
00:17:55,090 --> 00:18:02,735
אז rm, מקף, RF, טילדה היית, ללא
מה שגרם לי, ו לא ינחה

350
00:18:02,735 --> 00:18:05,670
לי, זה יהיה באופן אוטומטי להסיר
ספריית הבית כולו שלי ו

351
00:18:05,670 --> 00:18:06,780
כל אשר בו.

352
00:18:06,780 --> 00:18:11,460
אז אתה עשוי לחשוב כי זה
דבר טיפשי לעשות.

353
00:18:11,460 --> 00:18:12,830
וכן, זה הוא.

354
00:18:12,830 --> 00:18:18,600
>> אבל זה יכול לקרות בקלות רבה על ידי
תאונה אם, נניח, אני רוצה להסיר

355
00:18:18,600 --> 00:18:21,640
הקו הנטוי שלי, ספריית vhost.

356
00:18:21,640 --> 00:18:26,610
ורק בהקלדה מהירה,
אני עושה את טעות הזאת.

357
00:18:26,610 --> 00:18:31,880
כי יסיר באופן רקורסיבי שני
ספריית בית והספרייה vhost

358
00:18:31,880 --> 00:18:35,450
בספרייה המיוחדת הזה שרק
קורה שלא קיים כרגע.

359
00:18:35,450 --> 00:18:39,520
אבל זה הייתי עדיין להסיר
ספריית הבית כולו שלי.

360
00:18:39,520 --> 00:18:43,090
לפחות בכך שלא f,
זה יביא אותי קודם.

361
00:18:43,090 --> 00:18:45,670
ואני אהיה כמו, אה, לא, אני
לא רוצה לעשות את זה.

362
00:18:45,670 --> 00:18:50,570
אבל אנשים, לוכסן, ובכלל זה
שלי נוטה להיכנס

363
00:18:50,570 --> 00:18:53,090
הרגל תמיד RF-ing.

364
00:18:53,090 --> 00:18:58,713
אפילו קבצים רגילים שאני רק יכול RM,
ג, אני נוטה פשוט rm, מקף, RF, ג.

365
00:18:58,713 --> 00:19:01,330
רק להיזהר כשאתה RF-ing.

366
00:19:01,330 --> 00:19:03,160
>> 4 SPEAKER: מה C עושה?

367
00:19:03,160 --> 00:19:11,570
>> ROB: C הוא אני מדבר על שקובץ C מדבר
במדריך זה, rm ש, ג.

368
00:19:11,570 --> 00:19:15,730
>> יוסף: ויותר מסוכן, אם אתה משתמש
כוכב, הוא מתייחס לכל דבר ב

369
00:19:15,730 --> 00:19:16,450
המדריך.

370
00:19:16,450 --> 00:19:20,040
אז מה שאני בדרך כלל נוטה לעשות הוא אני
להיכנס לספרייה ואני רוצה

371
00:19:20,040 --> 00:19:21,510
להסיר את כל הקבצים שם.

372
00:19:21,510 --> 00:19:23,640
אז rm, מקף, RF, כוכב.

373
00:19:23,640 --> 00:19:25,700
>> ROB: כן.

374
00:19:25,700 --> 00:19:26,780
Rm, מקף, RF, כוכב.

375
00:19:26,780 --> 00:19:29,530
>> יוסף: אם אתה לא זהיר ו
מה בספרייה אתה ב--

376
00:19:29,530 --> 00:19:33,340
אני לא היה בזמני, אבל אני היה בטעות
בספרייה הבית שלי,

377
00:19:33,340 --> 00:19:35,450
אז אני להסיר את כל מה
בספרייה הבית שלי.

378
00:19:35,450 --> 00:19:39,095
ובאמת עשיתי את זה בעבר, ו
אני חושב שעשית את זה לפני או

379
00:19:39,095 --> 00:19:40,640
ג'יי עשתה את זה בעבר.

380
00:19:40,640 --> 00:19:42,480
>> ROB: אני כבר הוסר בטעות -

381
00:19:42,480 --> 00:19:44,480
כך להתעלם מפקודה שקצת.

382
00:19:44,480 --> 00:19:45,800
>> יוסף: לא כיף.

383
00:19:45,800 --> 00:19:52,650
>> ROB: אז בספריית bin הקו הנטוי הוא
חבורה של קבצים בינאריים שבו יש עוד

384
00:19:52,650 --> 00:19:54,840
יהיה מוכרים אלה כמו צלצול.

385
00:19:54,840 --> 00:20:00,740
ובכן, מצלצל ובעצם כל אלה
דברים שאני מפעיל בפקודה

386
00:20:00,740 --> 00:20:02,060
קו הוא בספרייה bin קו נטוי זה.

387
00:20:02,060 --> 00:20:03,090
>> יוסף: כמו ls הוא כאן.

388
00:20:03,090 --> 00:20:06,285
>> ROB: אז נקודה, לוכסן, ls הייתי
רשימה בספרייה זו.

389
00:20:06,285 --> 00:20:08,120
>> יוסף: חדר גם הוא בספרייה זו.

390
00:20:08,120 --> 00:20:12,770
>> רוב: יש לי RM טעות, בן RF-ed,
אשר הסיר כל פקודה שאני יכול

391
00:20:12,770 --> 00:20:14,380
אולי אי פעם תרצה.

392
00:20:14,380 --> 00:20:18,085
אשר לאחר מכן אני פשוט להתקין מחדש
מכשיר חדש בשלב זה.

393
00:20:18,085 --> 00:20:20,170
>> יוסף: אז להיזהר מאוד בעת
שימוש בפקודה זו.

394
00:20:20,170 --> 00:20:21,120
>> קהל: [לא ברור]?

395
00:20:21,120 --> 00:20:22,640
>> ROB: כן.

396
00:20:22,640 --> 00:20:24,135
זה גם הרגל רעה להיכנס.

397
00:20:24,135 --> 00:20:27,920

398
00:20:27,920 --> 00:20:30,170
אם תשימו לב, אני עכשיו -

399
00:20:30,170 --> 00:20:33,580
כן, אתה לא יכול להבחין בכך, אבל
זום בי אולי יכול.

400
00:20:33,580 --> 00:20:35,360
אז אני עכשיו @ שורש מכשיר.

401
00:20:35,360 --> 00:20:39,790
אז jharvard הוא המשתמש שאנחנו רוצים
לך להיות תמיד משתמש בה.

402
00:20:39,790 --> 00:20:43,820
שורש הוא המשתמש שיש לו הרשאה
לעשות כל דבר.

403
00:20:43,820 --> 00:20:50,260
>> אז שם לב כשאני jharvard,
אם אני מנסה cd -

404
00:20:50,260 --> 00:20:52,461
מה במדריך זה?

405
00:20:52,461 --> 00:20:53,980
אה, שורש הוא דוגמא טובה.

406
00:20:53,980 --> 00:20:54,950
אז cd, שורש.

407
00:20:54,950 --> 00:20:56,030
הרשאה נדחה.

408
00:20:56,030 --> 00:21:00,060
כי אם אנחנו מסתכלים על רשימה זו -

409
00:21:00,060 --> 00:21:02,410
ושוב, אין לך
לגמרי מבין את זה.

410
00:21:02,410 --> 00:21:09,210
אבל שלושת המקפים האלה אומרים
שלא נותנים לכל דבר אחר

411
00:21:09,210 --> 00:21:11,120
משתמש לתוך ספרייה זו.

412
00:21:11,120 --> 00:21:14,540
והספרייה שקורה לי
להיות בבעלות שורש משתמש.

413
00:21:14,540 --> 00:21:20,310
>> אז העובדה שאני jharvard ולא
זה שהוא לא שורש מותר ל

414
00:21:20,310 --> 00:21:23,490
במדריך זה, זה אומר שאני
הולך לקבל רשות נדחתה כש

415
00:21:23,490 --> 00:21:25,160
אנסה cd לתוך זה.

416
00:21:25,160 --> 00:21:31,370
לכן, כאשר אני שורש, יש לי אישור
לעשות שום דבר, כוללים

417
00:21:31,370 --> 00:21:34,660
למחוק קבצים חיוניים
למכשיר ו

418
00:21:34,660 --> 00:21:36,640
להרוס את הדבר כולו.

419
00:21:36,640 --> 00:21:41,240
>> כך שזה הרגל רע להיכנס
רק שיטוט שלך

420
00:21:41,240 --> 00:21:43,650
מערכת הפעלה כמו שורש.

421
00:21:43,650 --> 00:21:46,520
אני עושה את זה בכל מקרה.

422
00:21:46,520 --> 00:21:48,710
שאלות?

423
00:21:48,710 --> 00:21:52,230
ואני לצאת שורש, להישאר כjharvard.

424
00:21:52,230 --> 00:21:54,510
על אישור.

425
00:21:54,510 --> 00:21:55,820
>> פקודות רלוונטיות יותר.

426
00:21:55,820 --> 00:22:03,975
אז חוזר לטמפ 'שלנו,
MV הפקודה עומדת על מהלך.

427
00:22:03,975 --> 00:22:05,450
באפשרותך להעביר.

428
00:22:05,450 --> 00:22:07,610
עכשיו אנחנו רוצים לקרוא לזה ב,
אז עכשיו קורא לזה ב.

429
00:22:07,610 --> 00:22:10,650
או שאולי אנחנו רוצים לעבור
ב מדריך אחת.

430
00:22:10,650 --> 00:22:12,730
אז עכשיו ריק של ספרייה זו.

431
00:22:12,730 --> 00:22:15,410
אני אחזור לספריית הבית שלי, ו
אנו רואים כי ב הוא בפה, כי

432
00:22:15,410 --> 00:22:19,230
ספריית הבית הייתה ספרייה אחת מעל
הספרייה שב הייתה פנימה

433
00:22:19,230 --> 00:22:24,710

434
00:22:24,710 --> 00:22:26,580
>> יש גם cp.

435
00:22:26,580 --> 00:22:33,210
אז cp הוא להעתיק קטע סופר,
נקודה, טקסט.

436
00:22:33,210 --> 00:22:35,750
אני יכול לקרוא לזה, נקודה, טקסט.

437
00:22:35,750 --> 00:22:39,780
עכשיו יש לנו שני הסעיף סופר,
נקודה, טקסט; וים, נקודה, טקסט.

438
00:22:39,780 --> 00:22:41,340
זה עובד גם בספריות.

439
00:22:41,340 --> 00:22:44,040

440
00:22:44,040 --> 00:22:46,560
אני RF-ed קובץ יחיד.

441
00:22:46,560 --> 00:22:48,200
אז cp -

442
00:22:48,200 --> 00:22:51,710
טוב, קודם בואו ננסה cp, tmp, tmp2.

443
00:22:51,710 --> 00:22:53,220
אז השמטת tmp ספרייה.

444
00:22:53,220 --> 00:22:57,440
כל כך דומה ל RM, התנהגות ברירת המחדל
הוא לא לעבוד בספריות.

445
00:22:57,440 --> 00:23:01,570
>> ושוב, בדומה ל RM, ברירת המחדל
התנהגות - טוב, מקבל אותו לעבודה

446
00:23:01,570 --> 00:23:04,230
עם ספריות הוא, מקף-r משם.

447
00:23:04,230 --> 00:23:09,240
אז להעתיק באופן רקורסיבי הזמני
מדריך לtmp2.

448
00:23:09,240 --> 00:23:13,700
וכך יש לנו עכשיו שני tmp וtmp2,
וזה לא שמועיל מאז tmp

449
00:23:13,700 --> 00:23:16,814
היה ריק במקום הראשון.

450
00:23:16,814 --> 00:23:18,660
Tmp2.

451
00:23:18,660 --> 00:23:22,680
>> עכשיו בואו להעתיק tmp לtmp2.

452
00:23:22,680 --> 00:23:27,900
ואנחנו רואים שtmp2 יש גם את הקובץ
, כי הספרייה ו

453
00:23:27,900 --> 00:23:32,220
הכל בתוך כי
מדריך הועתק.

454
00:23:32,220 --> 00:23:36,000
וזה יכול להיות מועיל במידה מסוימת
אם, תניח שאתה עובד

455
00:23:36,000 --> 00:23:38,860
על בעיה להגדיר אחד -

456
00:23:38,860 --> 00:23:41,320
או בעצם, ערכות בעיה מאוחר יותר הן
אפילו יותר חשוב, כי יש

457
00:23:41,320 --> 00:23:43,660
תהיה כל חבורה
של קבצים ודברים.

458
00:23:43,660 --> 00:23:47,010
>> אבל אתה רק רוצה, לשבריר
שני, אתה כמו, בסדר, אני

459
00:23:47,010 --> 00:23:50,210
הולך לנסות משהו אחר.

460
00:23:50,210 --> 00:23:57,860
תן לי רק להעתיק כל pset1
מדריך לגיבוי pset1 כך שאם

461
00:23:57,860 --> 00:24:01,490
אני בסופו של דבר דופק את דברים, אני יכול
לחזור לספריית הגיבוי שלי.

462
00:24:01,490 --> 00:24:07,340
ישנן דרכים מתאימות יותר של
גרסאות גיבוי הקוד שלך, אבל

463
00:24:07,340 --> 00:24:10,610
זה תמיד דרך מהירה רק כדי להפוך את
בטוח שיש לך עותק של משהו

464
00:24:10,610 --> 00:24:11,860
שאתה עומד לשנות.

465
00:24:11,860 --> 00:24:16,974

466
00:24:16,974 --> 00:24:27,090
>> אז הד הוא גם פקודה חד פעמית ש
סוג של sillily פשוט להדפיס

467
00:24:27,090 --> 00:24:31,540
שורת הפקודה בדיוק מה
אתה רוצה להדהד.

468
00:24:31,540 --> 00:24:32,680
אז הד היי.

469
00:24:32,680 --> 00:24:35,420
אנחנו פשוט להדפיס היי.

470
00:24:35,420 --> 00:24:38,030
הד שלום עולם.

471
00:24:38,030 --> 00:24:39,800
אנו נדפיס hello world.

472
00:24:39,800 --> 00:24:44,350
שנכנס לשימוש בעת
להתחיל שילוב פקודות.

473
00:24:44,350 --> 00:24:48,300
>> ושוב, לא מצפה ממך לגמרי
מבין את זה עדיין, אבל זה

474
00:24:48,300 --> 00:24:49,910
משהו לראות.

475
00:24:49,910 --> 00:24:52,470
ואז אם אתה Googling עבור דוגמאות
או שאתה מבין שאתה רוצה לעשות

476
00:24:52,470 --> 00:24:55,030
משהו, זה יכול להיות מועיל.

477
00:24:55,030 --> 00:24:59,020
אז בואו, כדוגמא,
כך ls, מקף, אני.

478
00:24:59,020 --> 00:25:01,160
אז הנה אני רואה את הפלט
של ls, מקף, אני.

479
00:25:01,160 --> 00:25:06,560
ואני אומר, אוקיי, אני רוצה
לאחסן את זה בקובץ.

480
00:25:06,560 --> 00:25:11,620
כל פלט זה כאן, אני רוצה
לשים לקובץ נפרד.

481
00:25:11,620 --> 00:25:16,080
>> אז זה קצת יותר מאשר סמל
זה מה שאנחנו הולכים לקרוא.

482
00:25:16,080 --> 00:25:18,570
אנחנו הפניית
פלט לקובץ.

483
00:25:18,570 --> 00:25:21,680
בואו לקרוא בלה הקובץ, כי זה
מה שאני נוטה תמיד קורא לזה.

484
00:25:21,680 --> 00:25:26,430
אז עכשיו אנחנו רואים שיש לנו
להגיש בלה ממש כאן.

485
00:25:26,430 --> 00:25:30,270
ואם אני פותח אותו, אני תראה את זה
הפלט בדיוק מהפקודה

486
00:25:30,270 --> 00:25:31,990
כי אני פשוט רצתי.

487
00:25:31,990 --> 00:25:36,020
ובאופן דומה, אתה יכול -

488
00:25:36,020 --> 00:25:41,260
אם זה היה פלט לקובץ, זה
הוא לקבל קלט מקובץ.

489
00:25:41,260 --> 00:25:45,790

490
00:25:45,790 --> 00:25:47,050
מהי הפקודה שאני -

491
00:25:47,050 --> 00:25:49,620
>> יוסף: אני חושב שאתה יכול להשתמש
פחות או יותר, כנראה.

492
00:25:49,620 --> 00:25:53,031
>> רוב: אבל מה לגבי רק פחות בלה?

493
00:25:53,031 --> 00:25:53,930
אני לא יודע.

494
00:25:53,930 --> 00:25:57,870
אם אתה בא לתרחיש זה, כמו
יש psets שזה שימושי ל.

495
00:25:57,870 --> 00:25:59,950
>> יוסף: אתה יכול צינור אותו להד.

496
00:25:59,950 --> 00:26:02,920
צינור את הקובץ להד לראות את זה.

497
00:26:02,920 --> 00:26:04,060
>> רוב: זה צינור.

498
00:26:04,060 --> 00:26:04,860
>> יוסף: מצטער.

499
00:26:04,860 --> 00:26:06,190
>> ROB: בסדר.

500
00:26:06,190 --> 00:26:12,720
אז זה פלט לקובץ.

501
00:26:12,720 --> 00:26:18,700
זה הוא מקבל את הטקסט מהקובץ
ולמסור אותו לתכנית.

502
00:26:18,700 --> 00:26:20,560
ותראה גם את הבחור הזה.

503
00:26:20,560 --> 00:26:24,410
אז זה עושה את שניהם סוג של בבת אחת.

504
00:26:24,410 --> 00:26:28,310
ובעצם, אני אציג את שני חדש
פקודות רק כדי לעשות בו שימוש.

505
00:26:28,310 --> 00:26:33,060
>> ההיסטוריה היא פקודה שימושית שהיא רק
הולך להדפיס את הרשימה של

506
00:26:33,060 --> 00:26:34,940
כל דבר שאי פעם להריץ שורת פקודה.

507
00:26:34,940 --> 00:26:38,290
אז אנחנו רואים כאן את כל מה שיש לי
כבר פועל כל הזמן הזה.

508
00:26:38,290 --> 00:26:39,540
הרבה ls של.

509
00:26:39,540 --> 00:26:41,570

510
00:26:41,570 --> 00:26:48,470
>> ועוד פקודה שימושית היא grep כי
מטרתו היא לחפש מעל

511
00:26:48,470 --> 00:26:52,060
טקסט מחפש דפוסים, טוב,
מחפש את מה שאתה

512
00:26:52,060 --> 00:26:53,310
רוצה אותו לחפש.

513
00:26:53,310 --> 00:26:59,770
וכן שימוש שימושי כאן הוא, למשל
אנחנו רוצים לתפוס את ההיסטוריה.

514
00:26:59,770 --> 00:27:03,860
ואני רוצה לחפש את הפקודות
איפה אני - מה

515
00:27:03,860 --> 00:27:05,000
שימושי אחד לחפש?

516
00:27:05,000 --> 00:27:06,898
>> יוסף: [לא ברור]?

517
00:27:06,898 --> 00:27:09,710
>> רוב: או בואו נחפש את כל
נוגע, מכל סיבה שהיא.

518
00:27:09,710 --> 00:27:13,850
אז זה מה שזה ייראה.

519
00:27:13,850 --> 00:27:15,560
ואין לך לחלוטין
מבין את זה.

520
00:27:15,560 --> 00:27:20,570
אבל הרעיון הוא כאן, ההיסטוריה נותנת
את אותו הפלט שהוא עשה כאן

521
00:27:20,570 --> 00:27:25,030
איפה זה מדפיס את כל
ההיסטוריה של כל מה שאי פעם לרוץ.

522
00:27:25,030 --> 00:27:27,030
לאחר מכן, אנו עוברים את זה -

523
00:27:27,030 --> 00:27:30,230
אז במקום להדפיס אותו למסך,
אנחנו רוצים להעביר את זה ל

524
00:27:30,230 --> 00:27:34,640
grep פיקוד המחפש
כל המופעים של מילת המגע.

525
00:27:34,640 --> 00:27:40,280
>> וזאת באמצעות השילוב הזה של
היסטוריה כלים וgrep, אני יכול לראות, בסדר,

526
00:27:40,280 --> 00:27:44,820
הנה כל הפקודות יש לי אי פעם
לרוץ, והנה אחת משותף במקצת.

527
00:27:44,820 --> 00:27:45,510
אנחנו בתחתית.

528
00:27:45,510 --> 00:27:47,930
וזה גם נותן לי את הפקודה
אני פשוט רצתי כי הייתי לי

529
00:27:47,930 --> 00:27:51,240
מילת מגע בו.

530
00:27:51,240 --> 00:27:58,500
אבל הצינור הוא דבר די שימושי
לשילוב מספר רב של תוכניות.

531
00:27:58,500 --> 00:28:04,670
ובעצם, זה קיצור לבואו
שלי היסטוריה פלט להגיש בלה, ו

532
00:28:04,670 --> 00:28:10,190
תן לי grep באמצעות בלה הקובץ
כמו מה שאני רוצה להסתכל למעלה.

533
00:28:10,190 --> 00:28:13,460
אז הצינור הוא פשוט קיצור דרך
לשתי פקודות אלה.

534
00:28:13,460 --> 00:28:13,950
כן.

535
00:28:13,950 --> 00:28:15,306
>> 4 SPEAKER: [לא ברור]?

536
00:28:15,306 --> 00:28:16,556
>> ROB: כן.

537
00:28:16,556 --> 00:28:20,142

538
00:28:20,142 --> 00:28:21,110
מה הוא -

539
00:28:21,110 --> 00:28:21,858
אה.

540
00:28:21,858 --> 00:28:24,820
בואו לבדוק.

541
00:28:24,820 --> 00:28:29,170
אז חתול, כלב, דגים.

542
00:28:29,170 --> 00:28:33,770
אז אני רוצה grep.

543
00:28:33,770 --> 00:28:37,680
דאש, r, שוב, הולך להיות
באופן רקורסיבי, כך אני רוצה לרדת למטה

544
00:28:37,680 --> 00:28:38,870
כל הספריות.

545
00:28:38,870 --> 00:28:43,210
אני רוצה grep באופן רקורסיבי לכל -
ותן לי באופן זמני לקבל

546
00:28:43,210 --> 00:28:44,460
את זה בדרך.

547
00:28:44,460 --> 00:28:48,650

548
00:28:48,650 --> 00:28:50,740
להתעלם ממני.

549
00:28:50,740 --> 00:28:51,360
על אישור.

550
00:28:51,360 --> 00:28:56,740
>> אז אני רוצה grep באופן זמני עבור
כל המופעים של מילת הדגים.

551
00:28:56,740 --> 00:29:00,510
ואז הנה מה שאני עושה הוא grepping
באופן רקורסיבי למילה הדג.

552
00:29:00,510 --> 00:29:05,410
וכוכב אומר על כל אלה
קבצים בספרייה זו.

553
00:29:05,410 --> 00:29:08,930
ואז זה נתן לי הרשאה נדחתה,
משום שהוא אינו רשאי לקרוא את זה

554
00:29:08,930 --> 00:29:10,060
קובץ מסוים.

555
00:29:10,060 --> 00:29:14,040
אבל זה מצא דגים בקובץ, המבחן.

556
00:29:14,040 --> 00:29:18,450
>> גם אני יכול לומר, באופן ספציפי, אני רק
רוצה להיראות בבלה הקובץ, ב

557
00:29:18,450 --> 00:29:19,580
ומקרה זה לא מצא שום דבר.

558
00:29:19,580 --> 00:29:20,990
אני רוצה רק להסתכל בקובץ, המבחן.

559
00:29:20,990 --> 00:29:22,240
זה יהיה למצוא דגים.

560
00:29:22,240 --> 00:29:25,980

561
00:29:25,980 --> 00:29:29,260
כלומר הפקודה די שימושית
לדעת באופן כללי.

562
00:29:29,260 --> 00:29:31,640
יש כמה חלופות לgrep
שאמורים להיות יותר

563
00:29:31,640 --> 00:29:36,780
מתכנת ידידותי, אבל אני נוטה
עדיין ליפול על גב grep.

564
00:29:36,780 --> 00:29:38,030
שאלות?

565
00:29:38,030 --> 00:29:39,965

566
00:29:39,965 --> 00:29:40,919
על אישור.

567
00:29:40,919 --> 00:29:42,520
>> האם יש פקודות אחרות?

568
00:29:42,520 --> 00:29:45,270
אה.

569
00:29:45,270 --> 00:29:48,370
רק אחד חד פעמית שאני תמיד
מוצא להיות כיף קאל.

570
00:29:48,370 --> 00:29:55,610
אז שם לב כשאני בזה יפה
מצב של מסך מלא, אין לי דף כמו

571
00:29:55,610 --> 00:29:56,720
סרגל כלים או כל דבר.

572
00:29:56,720 --> 00:29:59,530
אז קאל רק נותן לי קטן ונחמד
לוח שנה זה נכון

573
00:29:59,530 --> 00:30:02,380
החברה מנותקת, אני מניח.

574
00:30:02,380 --> 00:30:04,770
אבל פקודה קטנה ונחמדה.

575
00:30:04,770 --> 00:30:06,540
>> יוסף: זה [לא ברור].

576
00:30:06,540 --> 00:30:09,170
פקודות אחרות שאולי יש לך
ראיתי כולל צלצול ולעשות.

577
00:30:09,170 --> 00:30:11,180
אנחנו נלך עליהם ב
פירוט בהמשך.

578
00:30:11,180 --> 00:30:13,400
אבל אם אתה כבר עובד על
PSET, אתה צריך להיות

579
00:30:13,400 --> 00:30:15,160
מכיר את אלה.

580
00:30:15,160 --> 00:30:16,640
>> ROB: בסדר.

581
00:30:16,640 --> 00:30:18,520
שאלות על דברים שורת הפקודה?

582
00:30:18,520 --> 00:30:22,450

583
00:30:22,450 --> 00:30:23,260
בסדר.

584
00:30:23,260 --> 00:30:27,416
אז בואו נעבור לכמה
דברים הקשורים ל-C.

585
00:30:27,416 --> 00:30:28,666
מתמטיקה משתנים.

586
00:30:28,666 --> 00:30:39,078

587
00:30:39,078 --> 00:30:40,060
על אישור.

588
00:30:40,060 --> 00:30:45,230
אז בדיוק כמו שהיו לנו במתמטיקה בגרד,
אתה יכול גם להשתמש במתמטיקה ב C.

589
00:30:45,230 --> 00:30:49,270
>> לפני שנגיע לזה לגמרי,
כל כך משתנה.

590
00:30:49,270 --> 00:30:53,920
זכור כי כל פעם שמצהיר
משתנה כמו int x או y לצוף, אתה

591
00:30:53,920 --> 00:30:56,710
צריך לתת לו להקליד לפני
השם המשתנה.

592
00:30:56,710 --> 00:31:03,020
אז סוגים שראינו עד כה הם int,
לצוף, כפול, ארוך ארוך, שבו אני

593
00:31:03,020 --> 00:31:06,150
לא ממש יודע אם יש לנו
ראה את זה עד כה.

594
00:31:06,150 --> 00:31:07,700
>> יש כמה כאלה אחרים.

595
00:31:07,700 --> 00:31:09,990
אנחנו כבר רואים את התו.

596
00:31:09,990 --> 00:31:13,920
יש קצר, שזה כמו שזה
ההפך מארוך ארוך שבו זה

597
00:31:13,920 --> 00:31:16,650
קטן יותר ממספר שלם.

598
00:31:16,650 --> 00:31:18,580
ראינו גם מחרוזת.

599
00:31:18,580 --> 00:31:23,070
אז מה מיוחד במחרוזת?

600
00:31:23,070 --> 00:31:25,350
למה אני הייתי אומר שזה
לא בדיוק כמו int?

601
00:31:25,350 --> 00:31:27,030
>> 4 SPEAKER: זה לא באמת קיים.

602
00:31:27,030 --> 00:31:27,990
>> ROB: כן.

603
00:31:27,990 --> 00:31:31,820
אז הסיבה היחידה שיש לנו מחרוזת
משום שכאשר אתה עושה

604
00:31:31,820 --> 00:31:33,215
חשיש, כולל cs50.h.

605
00:31:33,215 --> 00:31:36,530

606
00:31:36,530 --> 00:31:42,670
ואנו רואים דוגמאות לכך בהמשך -
אה, זה לא להתמודד עם זה היטב -

607
00:31:42,670 --> 00:31:46,160
בי cs50.h עושה משהו
לאורך הקווים מסוג

608
00:31:46,160 --> 00:31:49,230
def, כוכב char, מחרוזת.

609
00:31:49,230 --> 00:31:53,280
>> ואז זה אומר שאנחנו אפילו לא
יודע מה כוכב char הוא עדיין.

610
00:31:53,280 --> 00:31:56,770
אבל זה אומר שאנחנו רוצים מחרוזת.

611
00:31:56,770 --> 00:32:00,250
כל מקום שאתה כבר משתמש מחרוזת, אתה
ניתן היה באמצעות כוכבים char,

612
00:32:00,250 --> 00:32:04,670
אשר למעשה הוא סוג ש
קיים בשפת C.

613
00:32:04,670 --> 00:32:06,680
אבל אנחנו עוד נגיע לזה.

614
00:32:06,680 --> 00:32:07,860
אה, וזה הולך ימינה בחזרה.

615
00:32:07,860 --> 00:32:10,170
מסודר.

616
00:32:10,170 --> 00:32:15,370
>> אז אותו דבר עם bool
שבו אמת ושקר.

617
00:32:15,370 --> 00:32:22,510
כי הוא לא באמת סוג מובנה בג
במקום זאת, זה פשוט, זה צריך

618
00:32:22,510 --> 00:32:23,740
ערך אפס?

619
00:32:23,740 --> 00:32:26,200
אז אנחנו פשוט רואים
זה יהיה שקר.

620
00:32:26,200 --> 00:32:27,350
האם יש לזה ערך -

621
00:32:27,350 --> 00:32:30,530
כן, זה צריך כל
ערך שאינו אפס?

622
00:32:30,530 --> 00:32:32,200
אז נשקול את זה כדי להיות אמיתי.

623
00:32:32,200 --> 00:32:35,940
אז אחד הוא נכון, שתי נכון,
כל דבר שאינו אפס הוא נכון.

624
00:32:35,940 --> 00:32:38,710

625
00:32:38,710 --> 00:32:42,790
אז מי הם אותם.

626
00:32:42,790 --> 00:32:47,624
שאלות על משתני הכרזה ו
סוגים משתנים וכל זה?

627
00:32:47,624 --> 00:32:48,100
כן.

628
00:32:48,100 --> 00:32:52,384
>> 4 SPEAKER: במשך זמן רב זמן רב, בספר,
הוא אמר שזה היה צריך להיות int הארוך ארוך.

629
00:32:52,384 --> 00:32:54,288
אבל רק ארוך ארוך יעבוד?

630
00:32:54,288 --> 00:32:58,210

631
00:32:58,210 --> 00:33:01,470
>> ROB: אז מכפילי סוג אלה.

632
00:33:01,470 --> 00:33:04,170
אז int x.

633
00:33:04,170 --> 00:33:07,710
אז אנחנו גם יכולים להגיד x int חתום.

634
00:33:07,710 --> 00:33:09,640
אנחנו יכולים לומר x int הקצר.

635
00:33:09,640 --> 00:33:12,570
אנחנו יכולים לומר ארוכים ארוכים int x.

636
00:33:12,570 --> 00:33:17,250
אבל פחות או יותר את כל הדברים האלה אני
רק אמר, int חתום, int הקצר,

637
00:33:17,250 --> 00:33:21,480
ארוך ארוך int, אתה יכול להיפטר
int וזה יהיה פשוט להניח

638
00:33:21,480 --> 00:33:22,510
שהתכוונת int.

639
00:33:22,510 --> 00:33:26,045
x אז לא חתום, שרק אומר -

640
00:33:26,045 --> 00:33:29,400
אתה יודע איך בדרך כלל עם int,
אתה יכול להגיד x שווה 3 שליליים?

641
00:33:29,400 --> 00:33:31,636
עם int חתום, אתה לא יכול.

642
00:33:31,636 --> 00:33:34,480
>> יוסף: ושוב, למצלמה,
השאלה הייתה, מה ההבדל

643
00:33:34,480 --> 00:33:37,796
בין int הארוך הארוך
ורק ארוך ארוך?

644
00:33:37,796 --> 00:33:38,410
>> ROB: כן.

645
00:33:38,410 --> 00:33:42,850
אז אני כמעט אף פעם לא
לכתוב ארוך int הארוך.

646
00:33:42,850 --> 00:33:44,100
אני אכתוב עוד ארוך.

647
00:33:44,100 --> 00:33:47,770

648
00:33:47,770 --> 00:33:50,636
>> יוסף: יש שאלות?

649
00:33:50,636 --> 00:33:51,886
>> רוב: אישור.

650
00:33:51,886 --> 00:33:56,180

651
00:33:56,180 --> 00:34:02,390
תזכורת קטנה כל כך מטופשת של ככה
אנו מכריזים על משתנה ולאתחל

652
00:34:02,390 --> 00:34:04,450
משתנה ולהכריז אחר
משתנה ולאתחל

653
00:34:04,450 --> 00:34:05,870
את כל זה בצעד אחד.

654
00:34:05,870 --> 00:34:09,370
אז ההכרזה על משתנה ו
משתנה האתחול אין לי

655
00:34:09,370 --> 00:34:11,120
לאבל יכולה להיות באותה השורה.

656
00:34:11,120 --> 00:34:15,409

657
00:34:15,409 --> 00:34:20,060
>> אז יש לנו מפעילי מתמטיקה סטנדרטיים
שאתה רגיל -

658
00:34:20,060 --> 00:34:22,199
פלוס, מינוס, חילוק, פעמים.

659
00:34:22,199 --> 00:34:24,389
יש גם מודולו, שבו אנו נראה.

660
00:34:24,389 --> 00:34:29,060
אין, לפחות ב
C, מתח מובנה

661
00:34:29,060 --> 00:34:31,765
מפעיל קארה העלאה בחזק.

662
00:34:31,765 --> 00:34:33,770
ובכן, יש מפעיל קארה,
אבל זה לא כוח.

663
00:34:33,770 --> 00:34:34,239
>> יוסף: אבל זה לא העלאה בחזקה,
כן.

664
00:34:34,239 --> 00:34:36,210
>> ROB: אל תשתמש בסימן הכניסה
להניח שזה אומר

665
00:34:36,210 --> 00:34:39,980
כמו בריבוע או משהו כזה.

666
00:34:39,980 --> 00:34:42,289
אז כמה דברים שכדאי
חשוב על החלוקה.

667
00:34:42,289 --> 00:34:46,282

668
00:34:46,282 --> 00:34:48,880
אני אעמוד.

669
00:34:48,880 --> 00:34:51,315
אז הכריז תשובה לאתחל.

670
00:34:51,315 --> 00:34:54,670
אז אנחנו אומרים תשובה לצוף
שווה 1 מחולק ב10.

671
00:34:54,670 --> 00:34:57,500
הדפס תשובה לשתי ספרות אחרי נקודה עשרונית.

672
00:34:57,500 --> 00:35:02,180
>> וזה מסוג הדברים שאני
יאייש printf כדי להבין כי

673
00:35:02,180 --> 00:35:05,110
מה לעזאזל עושה%, נקודה, 2f אומר?

674
00:35:05,110 --> 00:35:07,930
וזה רק אומר, טוב,
התעלמות 0.2.

675
00:35:07,930 --> 00:35:10,420
ו%, f היא מה שאנו משתמשים
להדפיס לצוף.

676
00:35:10,420 --> 00:35:15,370
0.2 אומרים, הדפסה ש
לצוף לשני מקומות אחרי נקודה עשרונית.

677
00:35:15,370 --> 00:35:19,600
אז תכנית זו יש באג, ואתה עלול
ראיתי את זה בעבר בכמה

678
00:35:19,600 --> 00:35:20,870
כמובן CS קודם.

679
00:35:20,870 --> 00:35:22,170
אבל מה הוא באג ש?

680
00:35:22,170 --> 00:35:23,050
>> SPEAKER 5: אפס.

681
00:35:23,050 --> 00:35:24,130
>> ROB: כן.

682
00:35:24,130 --> 00:35:29,630
לכן, כאשר אנחנו אומרים, תשובה שווה
1 מחולק ב10, אנחנו רוצים

683
00:35:29,630 --> 00:35:31,610
תענה להיות 0.1.

684
00:35:31,610 --> 00:35:37,450
אבל 1 מחולק ב10, הוא 1
מספר שלם, 10 הוא מספר שלם.

685
00:35:37,450 --> 00:35:41,060
וכך, כאשר אנו עושים מספר שלם מחולק
שלם, אנחנו הולכים לחזור

686
00:35:41,060 --> 00:35:42,190
מספר שלם.

687
00:35:42,190 --> 00:35:43,660
אז 1 מחולק ב10 הוא 0.1.

688
00:35:43,660 --> 00:35:46,760
>> מאחר שהוא צריך לתת לנו מספר שלם,
זה רק הולך לזרוק כי

689
00:35:46,760 --> 00:35:49,410
מקום עשרוני ולומר כי
התשובה היא 0.

690
00:35:49,410 --> 00:35:55,314
ולכן כאשר אנו עונים כאן להדפיס,
זה הולך להדפיס 0.00.

691
00:35:55,314 --> 00:35:58,430
>> יוסף: ולא רק כהערה, זה ממש
זורק מה שאחרי

692
00:35:58,430 --> 00:35:59,390
נקודה עשרונית.

693
00:35:59,390 --> 00:36:03,180
אז אם אתה במקום היה 6 מחולק ב10,
אולי אתה חושב שזה היה נותן לך

694
00:36:03,180 --> 00:36:05,200
0.6 ואז היית לעגל כלפי מעלה ל -1.

695
00:36:05,200 --> 00:36:10,520
אבל בעצם, מה קורה כאשר הוא מקליד
משימותיו היא שהוא יורד מה הוא

696
00:36:10,520 --> 00:36:11,470
לאחר הנקודה העשרונית.

697
00:36:11,470 --> 00:36:13,020
אז 0.6 הופכים להיות 0.

698
00:36:13,020 --> 00:36:13,370
>> ROB: כן.

699
00:36:13,370 --> 00:36:15,160
ואנחנו נגיד חתוכים לזה.

700
00:36:15,160 --> 00:36:21,760
אז בכל פעם שאתה מטיל לint,
העשרוני מקוצץ.

701
00:36:21,760 --> 00:36:23,980
אז את התיקון לזה - יש
בעצם שתיים.

702
00:36:23,980 --> 00:36:27,890
ואני הולך לעשות את השנייה, כי
זה אחד הוא תיקון הרבה יותר קל.

703
00:36:27,890 --> 00:36:32,670
>> אז תיקון אחד הוא להשתמש צף
בחטיבה.

704
00:36:32,670 --> 00:36:34,720
ובאמת, יש לך רק כדי
להפוך את אחד מהם לצוף.

705
00:36:34,720 --> 00:36:37,400
אבל זה ברור יותר במידה מה רק
כדי להפוך את שניהם צף.

706
00:36:37,400 --> 00:36:41,170
אז 1.0 מחולק 10.0 הוא
חלוקת שני מצופים.

707
00:36:41,170 --> 00:36:43,970
אז התשובה תהיה בסופו של דבר להיות
לצוף, וכך תוכלו

708
00:36:43,970 --> 00:36:48,050
נכון להדפיס 0.10 כאן.

709
00:36:48,050 --> 00:36:52,220
>> משהו שלא עובד כל כך טוב
על זה הוא, ובכן, בטח, זה היה קל

710
00:36:52,220 --> 00:36:56,240
מספיק כדי להמיר 1 עד
לצוף בכך שהוא 1.0.

711
00:36:56,240 --> 00:37:02,180
אבל מה אם במקום שהיו לנו שני מספרים שלמים
כמו int x שווה y 1 ו int

712
00:37:02,180 --> 00:37:05,660
שווה 10, ולאחר מכן אנחנו רוצים
לעשות x מחולק בy?

713
00:37:05,660 --> 00:37:10,420
כך שזה לא קל פשוט
לעשות x.0 או משהו.

714
00:37:10,420 --> 00:37:12,790
>> אז את התיקון לזה הוא ליהוק.

715
00:37:12,790 --> 00:37:19,780
אז ליהוק הוא דרך ב-C להמיר
מסוג משתנה אחד למשנו.

716
00:37:19,780 --> 00:37:22,320
אז הנה, 1 הוא מספר שלם.

717
00:37:22,320 --> 00:37:27,050
ועל ידי הצבת מצוף זה מול
את זה, אנחנו מטילים 1 למצוף.

718
00:37:27,050 --> 00:37:30,350
ואז זה יהיה להמיר
1 עד 1.0.

719
00:37:30,350 --> 00:37:33,380
וזה יהיה להמיר
10 ל10.0.

720
00:37:33,380 --> 00:37:36,790
>> ואז דברים מתנהגים באופן דומה ל
גרסה קודמת רק הראינו

721
00:37:36,790 --> 00:37:42,190
שבו, כצפוי, אנחנו מקבלים 0.10
וזה יהיה להדפיס את זה.

722
00:37:42,190 --> 00:37:44,120
ואנחנו יכולים לעשות את זה עם
משתנים, יותר מדי.

723
00:37:44,120 --> 00:37:47,376
אז אנו יכולים לומר, x לצוף
מחולק על ידי y לצוף.

724
00:37:47,376 --> 00:37:48,626
>> יוסף: יש שאלות?

725
00:37:48,626 --> 00:37:54,182

726
00:37:54,182 --> 00:38:00,090
>> ROB: אז בדיוק כמו במתמטיקה רגילה,
יש לנו עדיפות על מפעיל.

727
00:38:00,090 --> 00:38:06,960
אז בשיעור מתמטיקה, אתה צפוי
לקרוא לזה סדר פעולות.

728
00:38:06,960 --> 00:38:09,890
כאן, המונח הרשמי הוא
קדימות מפעיל.

729
00:38:09,890 --> 00:38:15,230
אבל קדימות המפעיל, או רוב
מפעילים, הוא כפי שהיית מצפה.

730
00:38:15,230 --> 00:38:22,660
>> אז בדיוק כמו במתמטיקה, 2 פעמים 10 הוא
הולך להיות מקובצים באופן הדוק יותר מאשר

731
00:38:22,660 --> 00:38:25,410
10 זה מחולק על ידי 2 ולאחר מכן 2.

732
00:38:25,410 --> 00:38:29,745
סדר פעולות, הוא יעשה 2
פעמים 10, 10 מחולקים לפי 2, ולאחר מכן

733
00:38:29,745 --> 00:38:32,720
זה יעשה 20 עוד 5 ועוד 2.

734
00:38:32,720 --> 00:38:37,020
אז זה כצפוי, ואתה יכול להשתמש
בסוגריים כדי ביטויי קבוצה.

735
00:38:37,020 --> 00:38:41,063
אתה לא יכול להשתמש בסוגריים מרובעים
לביטויי קבוצה.

736
00:38:41,063 --> 00:38:41,544
כן?

737
00:38:41,544 --> 00:38:43,468
>> SPEAKER 5: האם אתה יכול באמת
פשוט לחזור שנייה אחת?

738
00:38:43,468 --> 00:38:47,316
האם אתה יכול להטיל int למחרוזת?

739
00:38:47,316 --> 00:38:53,330
>> ROB: אז ב-C, אתה יכול להפיל כל דבר
אתה רוצה מה שאתה רוצה.

740
00:38:53,330 --> 00:38:55,600
זה לא אומר שזה
דבר טוב לעשות.

741
00:38:55,600 --> 00:38:59,760
לכן, כאשר אתה מטיל int כדי
מחרוזת, שפירושו -

742
00:38:59,760 --> 00:39:03,240
ואנחנו נגיע לזה
הרבה יותר ביסודיות -

743
00:39:03,240 --> 00:39:03,720
>> יוסף: הרבה יותר מאוחר.

744
00:39:03,720 --> 00:39:06,840
>> רוב: אני לא רוצה להגיד הרבה יותר מאוחר,
אז ניסיתי לשנות את המשפט שלי.

745
00:39:06,840 --> 00:39:13,370
אנחנו נגיע לזה הרבה יותר ביסודיות
מאוחר יותר שבו באמת כאשר יש לך

746
00:39:13,370 --> 00:39:14,810
משתנה מחרוזת -

747
00:39:14,810 --> 00:39:17,160
כך מחרוזת יכולה להיות באופן שרירותי
ארוך, נכון?

748
00:39:17,160 --> 00:39:21,850
ואנחנו אומרים את זה כבר int הוא
ארבעה בתים וארוכים ארוך הוא שמונה

749
00:39:21,850 --> 00:39:23,620
בתים ולצוף הוא ארבעה בתים.

750
00:39:23,620 --> 00:39:29,520
אז מחרוזת, בדיוק כמו int, רק יש
מספר מסוים של בתים אליה.

751
00:39:29,520 --> 00:39:31,800
ושיהיו ארבעה בתים.

752
00:39:31,800 --> 00:39:34,750
>> אבל מחרוזת יכולה להיות די
ארוך באופן שרירותי, נכון?

753
00:39:34,750 --> 00:39:40,190
אז שלום עולם כבר, אם זה 10
תווים או משהו כזה, זה כבר

754
00:39:40,190 --> 00:39:42,670
הולך להיות מעל 4 הבתים
אני יכול להתאים למחרוזת.

755
00:39:42,670 --> 00:39:51,140
ואז איך מיתרים באמת עובדים הוא כי
הם שבו בזיכרון מחרוזת

756
00:39:51,140 --> 00:39:52,380
נשמר.

757
00:39:52,380 --> 00:39:57,290
>> וכן כאן, כשאני אומר x המחרוזת
שווה עולם שלום, חלק פנימי של x הוא

758
00:39:57,290 --> 00:40:01,840
רק אומר, הו, שלום העולם מאוחסן
במקום המסוים הזה בזיכרון.

759
00:40:01,840 --> 00:40:07,060
אז אם אנחנו מנסים להפיל שלמים כדי
מחרוזת, אז אנחנו מנסים לפרש

760
00:40:07,060 --> 00:40:10,500
כמה חלק מזיכרון אקראי
כמחרוזת.

761
00:40:10,500 --> 00:40:14,465
וזה כמעט תמיד שובר דברים.

762
00:40:14,465 --> 00:40:17,040
>> יוסף: אבל אם מבלבל כי
לך, אנחנו נהיה כיסוי זה

763
00:40:17,040 --> 00:40:17,550
יותר לעומק מאוחר יותר.

764
00:40:17,550 --> 00:40:17,850
>> ROB: כן.

765
00:40:17,850 --> 00:40:20,540
זה מקום בו אתה הולך
להיכנס למצביעים.

766
00:40:20,540 --> 00:40:25,485
וזה הוא נתח משמעותי
שבועיים של קורס זה.

767
00:40:25,485 --> 00:40:28,275
>> SPEAKER 6: האם זה עובד כמו אובייקטים
בשפות אחרות, או לא ממש?

768
00:40:28,275 --> 00:40:34,050
>> ROB: אז בשפות, חפצים אחרים
יהיה מיוצג על שימוש במצביעים.

769
00:40:34,050 --> 00:40:37,070

770
00:40:37,070 --> 00:40:38,793
למרות שזה לא אותו הדבר,.

771
00:40:38,793 --> 00:40:42,110

772
00:40:42,110 --> 00:40:42,910
כל מחשבות?

773
00:40:42,910 --> 00:40:43,760
>> יוסף: לא.

774
00:40:43,760 --> 00:40:44,185
לא מחשבות.

775
00:40:44,185 --> 00:40:44,980
>> רוב: אישור.

776
00:40:44,980 --> 00:40:46,994
>> יוסף: בשלב הבא.

777
00:40:46,994 --> 00:40:48,255
>> ROB: פשוט ללכת עם זה.

778
00:40:48,255 --> 00:40:48,670
בסדר.

779
00:40:48,670 --> 00:40:51,120
אז מודולו.

780
00:40:51,120 --> 00:40:53,900
בדיוק כמו שיש לנו בתוספת, מינוס,
לחלק ולהכפיל.

781
00:40:53,900 --> 00:40:56,720
אז מודולו הוא אחד שאתה יכול
לא ראה בעבר.

782
00:40:56,720 --> 00:40:59,540
וזה רק אומר, תן לי
שלי את יתרת.

783
00:40:59,540 --> 00:41:02,850
אז 55% 10.

784
00:41:02,850 --> 00:41:06,840
שארית עושה 55 מחולקת
על ידי 10 יהיו 5.

785
00:41:06,840 --> 00:41:09,630
אז 55% 10 הוא 5.

786
00:41:09,630 --> 00:41:12,260
ו -3% 5 יהיו 3.

787
00:41:12,260 --> 00:41:14,180
8% 8 יהיו 0.

788
00:41:14,180 --> 00:41:15,903
16% 15 יהיו 1.

789
00:41:15,903 --> 00:41:20,670
>> יוסף: דבר אחד לציין עם זה,
גם זה זה לא יכול לעבוד כצפוי

790
00:41:20,670 --> 00:41:22,700
אם אתה משתמש במספר שלילי.

791
00:41:22,700 --> 00:41:26,215
5% אז שליליים 4, חלק מאנשים
עלול לחשוב שהוא -

792
00:41:26,215 --> 00:41:28,890

793
00:41:28,890 --> 00:41:33,808
מה היית חושב שלילי
5% 4 יהיו?

794
00:41:33,808 --> 00:41:34,792
>> SPEAKER 5: אחד.

795
00:41:34,792 --> 00:41:37,920
>> יוסף: אז יש אנשים שאומרים אחד,
יש אנשים שאומרים שלילי אחד.

796
00:41:37,920 --> 00:41:38,450
אבל מה -

797
00:41:38,450 --> 00:41:40,820
>> ROB: אני אפילו לא צריך
אמר אחד מהם.

798
00:41:40,820 --> 00:41:42,370
>> יוסף: שני, מצטער.

799
00:41:42,370 --> 00:41:43,240
יש אנשים שאומרים -

800
00:41:43,240 --> 00:41:43,450
>> ROB: שלוש.

801
00:41:43,450 --> 00:41:43,800
>> יוסף: שלוש?

802
00:41:43,800 --> 00:41:44,890
>> ROB: שלילי -

803
00:41:44,890 --> 00:41:45,950
מה שהיה - חמש שלילי -

804
00:41:45,950 --> 00:41:47,100
>> יוסף: שלוש, שלוש, שלוש.

805
00:41:47,100 --> 00:41:48,450
סליחה.

806
00:41:48,450 --> 00:41:51,910
בגלל מודולו, בדרך כלל, כאשר יש לך
ראיתי את זה במקומות אחרים, זה בדרך כלל אומר

807
00:41:51,910 --> 00:41:54,000
להחזיר מספר חיובי, נכון?

808
00:41:54,000 --> 00:42:01,160
>> ROB: לכן, כאשר אנו אומרים במתמטיקה, 10% ב,
הם נוטים רוצים לתת לך -

809
00:42:01,160 --> 00:42:05,980
אם אנחנו mod ידי 10, אז אנחנו מצפים
מקבל מספר בין 0 ל 9.

810
00:42:05,980 --> 00:42:09,860
בפה, שזה לא המקרה, כי אתה
יקבל חזרה מספרים שליליים.

811
00:42:09,860 --> 00:42:15,898
>> יוסף: 5% אז שליליים
4 יהיו שליליים 1.

812
00:42:15,898 --> 00:42:19,325
>> רוב: אבל זה נדיר שאתה mod-ing
מספרים שליליים מלכתחילה.

813
00:42:19,325 --> 00:42:25,490

814
00:42:25,490 --> 00:42:25,970
דלגתי על זה.

815
00:42:25,970 --> 00:42:27,314
>> יוסף: כן.

816
00:42:27,314 --> 00:42:29,420
>> ROB: Meh.

817
00:42:29,420 --> 00:42:29,990
על אישור.

818
00:42:29,990 --> 00:42:36,400
אז דבר אחד אחרון כדי להצביע על
צף הוא זה התנהגות מסוכנת,

819
00:42:36,400 --> 00:42:39,850
אבל צף לא מדויק
ייצוג.

820
00:42:39,850 --> 00:42:46,190
אז חוזר לבתים שוב, זכור
כי int הוא תמיד ארבעה בתים ו

821
00:42:46,190 --> 00:42:47,830
מצוף הוא תמיד ארבעה בתים.

822
00:42:47,830 --> 00:42:51,340
אז הדוגמא של לוקאס היא די טובה.

823
00:42:51,340 --> 00:42:55,730
>> אז תחשוב על 1 חלקי 3.

824
00:42:55,730 --> 00:42:57,800
אז .3333333.

825
00:42:57,800 --> 00:43:03,540
אם יש לי רק 32 ביטים, איך יכול
אני מאחסן .33333 בדיוק?

826
00:43:03,540 --> 00:43:07,250
ואולי, מכל סיבה שהיא, אתה אומר,
בסדר, טוב, בואו נגיד

827
00:43:07,250 --> 00:43:13,210
ש1011001 מסוימים הזה, בואו
רק אומר שצריך להיות .333333.

828
00:43:13,210 --> 00:43:16,960
ובכן, יש לך רק מספר סופי של
ביטים אלה, כך שזה בלתי אפשרי

829
00:43:16,960 --> 00:43:22,550
מייצג כל אחד ונקודה צפי
הערך נתון רק 32 סיביות.

830
00:43:22,550 --> 00:43:25,580
>> ובכן, אי אפשר לייצג את כל
נתן ערך נקודה צפה אינסופי -

831
00:43:25,580 --> 00:43:28,480
כן, בהתחשב בכל מספר סופי של ביטים.

832
00:43:28,480 --> 00:43:38,265
אז הבעיה כאן היא, ובכן, כאשר אנו משמשים
כדי להדפיס על שני מקומות אחרי נקודה עשרונית,

833
00:43:38,265 --> 00:43:42,000
אנחנו בצורה נכונה לא לקבל את התשובה 0.10.

834
00:43:42,000 --> 00:43:47,510
אבל מתחת למכסת המנוע, זה ממש
יאוחסן קרוב ככל האפשר ל

835
00:43:47,510 --> 00:43:51,790
0.10 כמו פיסות אלה יכולים לייצג.

836
00:43:51,790 --> 00:43:53,200
האם זה בשקופית הבאה?

837
00:43:53,200 --> 00:43:53,830
או שזה לא?

838
00:43:53,830 --> 00:43:54,660
>> יוסף: כן, זה עד כדי כך.

839
00:43:54,660 --> 00:43:55,750
>> ROB: Blegh, blegh.

840
00:43:55,750 --> 00:43:57,760
>> יוסף: כן, אתה יכול פשוט
למשוך את ההערות קצת.

841
00:43:57,760 --> 00:43:59,700
>> ROB: אני רק הולך לזום
על שעבר על זה.

842
00:43:59,700 --> 00:44:00,950
אוי ואבוי, זה [לא ברור].

843
00:44:00,950 --> 00:44:06,089

844
00:44:06,089 --> 00:44:08,300
אז את המספר הזה.

845
00:44:08,300 --> 00:44:12,300
זה מה שיודפס
אם אנו מפעילים תכנית זו.

846
00:44:12,300 --> 00:44:20,340
ושים לב שזה לא ממש ביג דיל
אם אנחנו אכפת רק כמו

847
00:44:20,340 --> 00:44:21,920
02:58 מקומות אחרי נקודה עשרונית.

848
00:44:21,920 --> 00:44:26,700
כמו שרק נדפסו במקור 0.10,
ובגלל זה אנחנו לא ראינו שום דבר לא בסדר.

849
00:44:26,700 --> 00:44:31,380
אבל ברגע שאנחנו מתחילים להיכנס
מדויק, מספר מדויק שזה

850
00:44:31,380 --> 00:44:35,660
מייצג, אנו רואים כי אין בו
בדיוק מייצג 0.1.

851
00:44:35,660 --> 00:44:40,900
>> וחלק מהבעיה כאן הוא כמו,
בסדר, זה בסדר, אבל, טוב,

852
00:44:40,900 --> 00:44:46,120
ראשון, מה אם מה שניסינו לעשות,
תשובה שווה שווה 0.1?

853
00:44:46,120 --> 00:44:49,200
האם זה הולך להחזיר אמת או שקר?

854
00:44:49,200 --> 00:44:51,850
ולכן קשה לומר.

855
00:44:51,850 --> 00:44:53,330
אני חושב שזה ממש יכול לחזור נכון.

856
00:44:53,330 --> 00:44:55,265
זה יהיה ראשון -

857
00:44:55,265 --> 00:44:56,180
אני לא יודע.

858
00:44:56,180 --> 00:45:00,090
התשובה היא ברגע שאתה מתחיל התמודדות
עם ערכי נקודה צופה, אתה די

859
00:45:00,090 --> 00:45:05,150
הרבה לא צריך להיות באמצעות שוויון
בגלל חוסר הדיוק הזה.

860
00:45:05,150 --> 00:45:09,470
>> ולכל מה שאתה יודע, זה מאית
מקום עשרוני כי

861
00:45:09,470 --> 00:45:13,670
נקודה צפה לא הייתה מסוגלת
כדי להתמודד בצורה נכונה.

862
00:45:13,670 --> 00:45:18,180
וכך השוויון יהיה פשוט להיכשל אפילו
למרות המספר - אם היית

863
00:45:18,180 --> 00:45:24,450
שימוש במספרים מדויקים, המספרים צריכים
היה בדיוק אותו הדבר.

864
00:45:24,450 --> 00:45:27,790
זה במהלך 50 כמו
חישובים באמצעות צף אלה

865
00:45:27,790 --> 00:45:30,270
ערכי נקודה, השגיאה יכולה לבנות
מעלה מעלה ומעלה, ו

866
00:45:30,270 --> 00:45:31,125
דברים פשוט לא נכונים.

867
00:45:31,125 --> 00:45:33,870
>> יוסף: והיו באמת
דוגמאות המפורסמות של זה קורה.

868
00:45:33,870 --> 00:45:37,190
כמו מהנדסי נאס"א מקבלים את זה
רקטות הלא נכונות, וגרמו להתפוצץ ב

869
00:45:37,190 --> 00:45:38,665
האוויר אחרי שהם כבר יצאו לדרך.

870
00:45:38,665 --> 00:45:41,490
והרבה נושאים כאלה.

871
00:45:41,490 --> 00:45:41,956
אז כן.

872
00:45:41,956 --> 00:45:45,218
>> SPEAKER 6: כשאתה אומר 0.3 f,
זה לחתוך את השאר?

873
00:45:45,218 --> 00:45:46,468
או שהיא לעגל כלפי מעלה או כלפי מטה?

874
00:45:46,468 --> 00:45:48,800

875
00:45:48,800 --> 00:45:50,200
>> ROB: האם printf בסיבוב זה?

876
00:45:50,200 --> 00:45:52,180
>> יוסף: אני חושב שחותך printf.

877
00:45:52,180 --> 00:45:52,640
>> רוב: אישור.

878
00:45:52,640 --> 00:45:59,890
אז אנחנו יכולים ללכת באופן דומה את ההפך
כיוון שבו זה, במקרה הזה,

879
00:45:59,890 --> 00:46:03,320
הכי קרוב זה יכול לייצג
0.1 היו עם מספר זה.

880
00:46:03,320 --> 00:46:06,820
הכי קרוב זה עלול להיות מסוגל
מייצגים 0.2 הוא בהפך

881
00:46:06,820 --> 00:46:11,420
כיוון, .199999996356
או משהו.

882
00:46:11,420 --> 00:46:17,480
אז אם הלכנו בכיוון זה של
דברים, אז f 0.3 printf יחזרו

883
00:46:17,480 --> 00:46:20,866
1.99 במקום 2.00.

884
00:46:20,866 --> 00:46:22,960
>> יוסף: ואני לא לגמרי
בטוח בזה.

885
00:46:22,960 --> 00:46:25,430
אולי אתה רוצה לכתוב קטן, קטן
תכנית רק כדי לבדוק את זה.

886
00:46:25,430 --> 00:46:29,370
>> ROB: אמנם, מה שאנחנו בטוחים כי
אם ניסית להטיל של

887
00:46:29,370 --> 00:46:33,660
int, והליהוק לint הולך
לגרום לו לחתוך העשרוני, אם

888
00:46:33,660 --> 00:46:38,140
אתה מנסה להטיל 1.9999999
לint, תקבל 1.

889
00:46:38,140 --> 00:46:41,440
ואז אתה צריך בדרך כלל להשתמש
פונקציה עגולה בספריית המתמטיקה.

890
00:46:41,440 --> 00:46:44,190

891
00:46:44,190 --> 00:46:45,440
שאלות?

892
00:46:45,440 --> 00:46:47,660

893
00:46:47,660 --> 00:46:48,982
על אישור.

894
00:46:48,982 --> 00:46:54,000
>> יוסף: אז נע על תנאים
וביטויים בוליאנית.

895
00:46:54,000 --> 00:46:58,120
אז שראית אלה בעבר.

896
00:46:58,120 --> 00:47:07,420
ובאמת, תן לי לעשות את שלי בטוח
מחשב הוא בפורמט הנכון כאן.

897
00:47:07,420 --> 00:47:08,670
חלל.

898
00:47:08,670 --> 00:47:10,630

899
00:47:10,630 --> 00:47:13,870
מצטער, אנחנו הולכים צריכים להתמודד
קצת עם חיתוך בקצוות.

900
00:47:13,870 --> 00:47:15,830
>> אבל כן, אתם ראיתם
זה לפני בגרד.

901
00:47:15,830 --> 00:47:19,930
אז זכות זו כאן היא ביטוי
אשר משמש

902
00:47:19,930 --> 00:47:21,250
הצהרה על תנאי.

903
00:47:21,250 --> 00:47:23,930
אז תענה גדול מאפס רצון
להגיד לך אמת או שקר.

904
00:47:23,930 --> 00:47:26,530
ואלה הם באמת חשובים, כי
הם מאפשרים לנו להציג את

905
00:47:26,530 --> 00:47:28,670
היגיון לקוד שלנו.

906
00:47:28,670 --> 00:47:32,820
>> כך למשל, מדובר בתכנית
נכתב בסריטות ששואלת את המשתמש

907
00:47:32,820 --> 00:47:36,980
למספר שלם ואומר להם אם
השלם שהם נתנו לך היה

908
00:47:36,980 --> 00:47:38,690
מספר חיובי או שלילי.

909
00:47:38,690 --> 00:47:42,980
והמרה כאן כדי לראות היא
תדפיס ראשון מתוך ההצהרה,

910
00:47:42,980 --> 00:47:43,870
תן לי את מספר שלם.

911
00:47:43,870 --> 00:47:45,980
ואז אתה שואל אותם למספר שלם.

912
00:47:45,980 --> 00:47:49,870
>> ולאחר מכן אתה משתמש בהיגיון מותנה מעל
כאן כדי לבדוק אם המספר הזה

913
00:47:49,870 --> 00:47:52,030
היה ממש גדול מאפס או לא.

914
00:47:52,030 --> 00:47:58,960
אז הנה יש לנו ביטוי בוליאני
בתוך מותנה אם הצהרה.

915
00:47:58,960 --> 00:48:00,660
האם יש שאלות?

916
00:48:00,660 --> 00:48:03,030
האם יש שאלות על זה?

917
00:48:03,030 --> 00:48:03,950
על אישור.

918
00:48:03,950 --> 00:48:06,140
>> אז יש יותר מסתם
גדול יותר מאשר, כמובן.

919
00:48:06,140 --> 00:48:10,385
אתה יכול לבנות ביטויים בוליאנית
באמצעות רוב מיני דברים שאתה

920
00:48:10,385 --> 00:48:11,150
היה חושב במתמטיקה.

921
00:48:11,150 --> 00:48:12,370
אז גדול יותר.

922
00:48:12,370 --> 00:48:13,740
זה צריך להיות פחות מ.

923
00:48:13,740 --> 00:48:14,990
סליחה.

924
00:48:14,990 --> 00:48:18,520

925
00:48:18,520 --> 00:48:19,760
ואת המרווח.

926
00:48:19,760 --> 00:48:22,971
>> ROB: החס וחליל שאתה עוזב אותו.

927
00:48:22,971 --> 00:48:23,620
>> יוסף: בסדר.

928
00:48:23,620 --> 00:48:25,950
אז גדול יותר, פחות מ, גדול יותר
מ, או שווה, פחות

929
00:48:25,950 --> 00:48:27,070
מ, או שווה ל.

930
00:48:27,070 --> 00:48:31,980
אנו משתמשים בשווים כפולים כדי לבדוק
שוויון, משום שאחד שווה לאמצעי

931
00:48:31,980 --> 00:48:32,810
משימה, נכון?

932
00:48:32,810 --> 00:48:33,140
כן.

933
00:48:33,140 --> 00:48:37,130
ואז אנחנו יכולים גם לא שווים על ידי
שימוש בסימן קריאה, שווה.

934
00:48:37,130 --> 00:48:41,530
>> וסמל סימן קריאה זה יכול
להיות גם מורחב, כך שאם אתה רוצה

935
00:48:41,530 --> 00:48:44,050
כדי להפוך כל סוג של בוליאנית
ביטוי, אתה יכול לעשות את זה.

936
00:48:44,050 --> 00:48:48,530
אז זה יהיה TRUE
רק אם התשובה היא פחות

937
00:48:48,530 --> 00:48:51,240
או שווה לאפס.

938
00:48:51,240 --> 00:48:53,950
כל שאלות על זה?

939
00:48:53,950 --> 00:48:55,180
על אישור.

940
00:48:55,180 --> 00:48:58,840
>> אז אתה יכול גם לשלב הבאים
ביטויים באמצעות הגיוני ו

941
00:48:58,840 --> 00:48:59,790
לוגי או.

942
00:48:59,790 --> 00:49:03,530
אז זה רק הסמל ו,
שאמור להיות Shift, 7.

943
00:49:03,530 --> 00:49:07,720
וזו היא סמל הצינור, שהוא
לא באותיות קטנה ל 'זה אחד

944
00:49:07,720 --> 00:49:09,440
זה ממש מעל מקש Enter שלך.

945
00:49:09,440 --> 00:49:12,870
אז אתה משתמש בשני אלה כדי לסמל
הגיוני והלוגי או.

946
00:49:12,870 --> 00:49:18,180
>> אז זה רק יחזיר true אם תשובה
אחד, שתיים, שלוש, או ארבעה.

947
00:49:18,180 --> 00:49:23,030
וזה רק יחזיר true אם תשובה
הוא מעבר לזה משני הצדדים.

948
00:49:23,030 --> 00:49:26,190
כך שזה לא אחד, שתיים, שלוש, או ארבעה.

949
00:49:26,190 --> 00:49:28,385
והדרך היית להשתמש
כי בביטוי -

950
00:49:28,385 --> 00:49:29,990
>> ROB: או אפס או חמש.

951
00:49:29,990 --> 00:49:32,200
>> יוסף: אפס או חמש.

952
00:49:32,200 --> 00:49:32,380
סליחה.

953
00:49:32,380 --> 00:49:33,320
כן, כן, כן.

954
00:49:33,320 --> 00:49:34,180
על אישור.

955
00:49:34,180 --> 00:49:38,980
והנה עכשיו, באותה הדרך שאתה
הייתי להשתמש בביטוי זה, קטן יותר

956
00:49:38,980 --> 00:49:42,000
ביטוי בצד של אם מותנה
הצהרה, שהיית גם להשתמש בו

957
00:49:42,000 --> 00:49:47,800
אותה דרך רק על ידי לשים את זה בתוך
הסוגריים של ההצהרה אם.

958
00:49:47,800 --> 00:49:54,020
אז printf זה יהיה רק ​​אש אם תשובה
אחד, שתיים, שלוש, או ארבעה.

959
00:49:54,020 --> 00:49:56,002
כל שאלות על שילוב
ביטויים?

960
00:49:56,002 --> 00:50:00,450

961
00:50:00,450 --> 00:50:04,240
>> אז יש עוד תנאי
לבנות האנחנו קוראים אם / אחר.

962
00:50:04,240 --> 00:50:08,120
כך שלמעשה, זה עכשיו פירושו, אוקיי, אם
משהו שאני רוצה לבדוק שלא היה

963
00:50:08,120 --> 00:50:11,600
נכון, ואז ללכת לעוד ו
לבצע את אותה פעולה אחרת.

964
00:50:11,600 --> 00:50:15,570
אז במקרה הספציפי הזה, שאלתי את
המשתמש למספר שלם.

965
00:50:15,570 --> 00:50:17,790
האם השלם גדול מאפס?

966
00:50:17,790 --> 00:50:18,310
כן?

967
00:50:18,310 --> 00:50:20,100
טוב, אז הם הרימו
מספר חיובי.

968
00:50:20,100 --> 00:50:22,320
אם לא, אז זה חייב להיות
היה שלילי או אפס.

969
00:50:22,320 --> 00:50:27,530
אז בחרת מספר שלילי
או אפס במקרה זה.

970
00:50:27,530 --> 00:50:29,235
כן.

971
00:50:29,235 --> 00:50:30,485
או אפס.

972
00:50:30,485 --> 00:50:36,320

973
00:50:36,320 --> 00:50:39,300
>> ולאחר מכן יש לנו גם אם / אחר,
אם ואלזה.

974
00:50:39,300 --> 00:50:45,640
אז זה מאפשר לנו לבצע רצף של
דברים רק אם הראשונים להיכשל.

975
00:50:45,640 --> 00:50:49,540
אז במקרה הזה, עכשיו אנחנו עושים
האחרון שאתה בוחר לאפס.

976
00:50:49,540 --> 00:50:53,080
אז אם הם לא הרימו חיוביים ולא
מספר שלילי, אז הם חייבים

977
00:50:53,080 --> 00:50:53,640
יש הרים אפס.

978
00:50:53,640 --> 00:50:56,720
אז זה פשוט יורד
שרשרת כמו זה.

979
00:50:56,720 --> 00:50:59,960
>> אז דוגמא לאופן
אם הוא שונה מ--

980
00:50:59,960 --> 00:51:02,590
אם / אחר שונה מ
רק רצף של IFS.

981
00:51:02,590 --> 00:51:07,680
וזו היא שאלה נפוצה ש
אנשים שואלים אותו, כן, אם אתה מקבל כמו

982
00:51:07,680 --> 00:51:11,265
95 בCS50, מה יהיה זה
תכנית אומרת לך?

983
00:51:11,265 --> 00:51:12,600
>> SPEAKER 5: יש לך א

984
00:51:12,600 --> 00:51:13,490
>> יוסף: כן.

985
00:51:13,490 --> 00:51:14,960
יש לך כל אחד
אחד מאותם הנכונים.

986
00:51:14,960 --> 00:51:17,130
יש לך, יש לך ב ',
יש C ו D, נכון?

987
00:51:17,130 --> 00:51:19,770
אז כל אלה מקבלים מוערכים
לפי סדר.

988
00:51:19,770 --> 00:51:23,570
אז בזמן ש95 גדול מ 90, זה
גם גדול יותר מ80, זה גם

989
00:51:23,570 --> 00:51:25,790
יותר מ -70, וזה
גם גדול יותר מ60.

990
00:51:25,790 --> 00:51:27,620
אז יש לך את כל הציונים האלה.

991
00:51:27,620 --> 00:51:31,630
ואני מניח שהיית עושה
רק רוצה א

992
00:51:31,630 --> 00:51:34,060
>> הדרך לתקן את זה היא להחליף
בעלי / של אם אחר.

993
00:51:34,060 --> 00:51:37,540
אז בתרחיש זה, שהוא רואה ש95 הוא
יותר מ 90, ולאחר מכן הוא עושה

994
00:51:37,540 --> 00:51:38,885
לא להעריך את שאר
של הדוחות.

995
00:51:38,885 --> 00:51:41,900

996
00:51:41,900 --> 00:51:43,150
כל שאלות על זה?

997
00:51:43,150 --> 00:51:48,580

998
00:51:48,580 --> 00:51:52,470
>> אז יש עוד סוג מותנה של
מבנה שיש לנו כאן שאנחנו

999
00:51:52,470 --> 00:51:53,390
קורא לשמירה על מתג.

1000
00:51:53,390 --> 00:51:57,390
אז זה מאפשר לך בעצם לבדוק
מה הערך של מספר שאתה מכניס

1001
00:51:57,390 --> 00:51:59,000
לשמירה על המתג.

1002
00:51:59,000 --> 00:52:03,200
אז בתרחיש זה, אנחנו מיתוג
על n, ושאנחנו אומרים, או, אם n הוא

1003
00:52:03,200 --> 00:52:04,710
אחד, ולאחר מכן להדפיס את האמירה הזאת.

1004
00:52:04,710 --> 00:52:07,910
ואז לשבור, מה שאומר שיציאה
מתוך שמירה על המתג.

1005
00:52:07,910 --> 00:52:12,670
>> אם זה לא היה אחד, אז, טוב, רק
סופו של דבר לבדוק את כל המקרים הללו.

1006
00:52:12,670 --> 00:52:16,280
וכך הוא בודק אם זה אחד או שתיים או
שלוש, והיא מדפיסה בהתאם.

1007
00:52:16,280 --> 00:52:19,780
ומה מילת המפתח ברירת מחדל זה כאן למטה
אמצעי הוא אם הם לא להיכנס לכל

1008
00:52:19,780 --> 00:52:21,690
של אלה, ולאחר מכן אומרים לא חוקיים.

1009
00:52:21,690 --> 00:52:25,910
אז בואו נגיד שאני שואל עבור n ו
המשתמש נותן לי ארבעה.

1010
00:52:25,910 --> 00:52:29,470
ובכן, זה תואם אף אחד מהמקרים האלה,
כך שזה יהיה להדפיס את מה שיש ב

1011
00:52:29,470 --> 00:52:30,540
סעיף ברירת מחדל.

1012
00:52:30,540 --> 00:52:31,180
כן, שאלה?

1013
00:52:31,180 --> 00:52:32,614
>> SPEAKER 5: האם אתה יכול להשתמש בוליאנית
ביטויים במקום

1014
00:52:32,614 --> 00:52:33,570
אחד, שתיים, או שלוש?

1015
00:52:33,570 --> 00:52:36,940
>> יוסף: אז השאלה היא האם אתה יכול להשתמש
ביטויים בוליאנית במקום אחד,

1016
00:52:36,940 --> 00:52:37,940
שני, ושלוש?

1017
00:52:37,940 --> 00:52:40,520
ובC, אני מאמין לך
לא יכול לעשות את זה.

1018
00:52:40,520 --> 00:52:44,320
אבל בשפות אחרות, שאולי לך
נתקל בסוף

1019
00:52:44,320 --> 00:52:46,460
סמסטר כמו JavaScript, אתה יכול.

1020
00:52:46,460 --> 00:52:50,050
ובכן, היית צריך לחשב ראשון
ערך זה ולאחר מכן להשתמש בו ב

1021
00:52:50,050 --> 00:52:50,650
לעבור הצהרה.

1022
00:52:50,650 --> 00:52:50,930
כן?

1023
00:52:50,930 --> 00:52:54,760
>> ROB: אז חלק מהיתרון של מתג
ההצהרות היא לחשוב על אם אתה עשית את זה

1024
00:52:54,760 --> 00:52:58,680
כאם / אחר, אז כמו שאם n שווה
שווה לאחד או משהו כזה.

1025
00:52:58,680 --> 00:53:00,300
אחר / אם n שווה שווה שתיים, שיהיה.

1026
00:53:00,300 --> 00:53:01,960
אחר / אם n שווה שווה שלוש.

1027
00:53:01,960 --> 00:53:05,930
לכן דרך התכנית תרוץ זה
רצף היה יורד רשימה

1028
00:53:05,930 --> 00:53:07,500
ולבדוק, הוא n אחד?

1029
00:53:07,500 --> 00:53:08,040
לא ולא.

1030
00:53:08,040 --> 00:53:09,070
האם n שתיים?

1031
00:53:09,070 --> 00:53:09,490
לא ולא.

1032
00:53:09,490 --> 00:53:10,940
האם n שלוש?

1033
00:53:10,940 --> 00:53:11,710
כן.

1034
00:53:11,710 --> 00:53:12,610
לעשות את זה.

1035
00:53:12,610 --> 00:53:15,270
>> ואילו עם הצהרות מתג, זה
תוכל למעשה לקמפל את זה כדי להיות

1036
00:53:15,270 --> 00:53:16,360
ממש מהר.

1037
00:53:16,360 --> 00:53:19,550
וברגע שזה אומר מתג, זה
אומר, בסדר, n הוא שתיים, אני

1038
00:53:19,550 --> 00:53:23,060
מייד הולך לקפוץ למקום שבי
אני אמור להתחיל בביצוע.

1039
00:53:23,060 --> 00:53:26,080
אני לא הולך לבדוק תחילה,
הוא n אחד, הוא n שניים?

1040
00:53:26,080 --> 00:53:28,860
זה מייד יכול להתחיל לעשות
מה שהוא אמור לעשות.

1041
00:53:28,860 --> 00:53:33,830
>> ובגלל זה, זה לא יכול
לקחת תנאים בוליאני.

1042
00:53:33,830 --> 00:53:36,480
או אחר זה היית צריך לעשות
רציף, כמו, בסדר, הוא n

1043
00:53:36,480 --> 00:53:37,820
גדול מאפס?

1044
00:53:37,820 --> 00:53:41,140
השאר הוא n גדול מ 10 או משהו כזה.

1045
00:53:41,140 --> 00:53:44,780
>> יוסף: במקרה זה, אם השתמש
אם / אחר,, ולאחר מכן את המתג היית אם של

1046
00:53:44,780 --> 00:53:47,792
לרוץ שלוש פעמים כ
מהר יותר, אם אם / אחר.

1047
00:53:47,792 --> 00:53:53,060

1048
00:53:53,060 --> 00:53:56,040
אנחנו יכולים לארגן את המתג בכזה
אופן שבו אנחנו לא לשבור

1049
00:53:56,040 --> 00:53:57,520
לאחר כל אחד מהמקרים.

1050
00:53:57,520 --> 00:54:00,960
אז במקרה הזה, אני מחיצות
מספרים שאנו בוחרים לאחד ו

1051
00:54:00,960 --> 00:54:04,250
שני לא להיות מספרים גבוהים ו
שלושה להיות מספר גבוה.

1052
00:54:04,250 --> 00:54:08,290
>> אז במקרה הזה, אם n הוא אחד או שתיים, זה
יפגע במקרה ואז זה יהיה

1053
00:54:08,290 --> 00:54:10,640
נופל דרך, כי
אין הפסקה.

1054
00:54:10,640 --> 00:54:11,610
וזה יהיה סופו של דבר כאן.

1055
00:54:11,610 --> 00:54:15,360
אז אם אנחנו בוחרים אחד, הוא יעשה printf
ואז לשבור כל כך שאף אחד

1056
00:54:15,360 --> 00:54:17,610
זה מבוצע.

1057
00:54:17,610 --> 00:54:21,870
וכמובן, אם הם נכנסים בשלושה
או משהו אחר, ואז הוא ידלג

1058
00:54:21,870 --> 00:54:25,320
אלה ולא ללכת לשם, וזה
יבצע במקום

1059
00:54:25,320 --> 00:54:27,490
מתאים קו.

1060
00:54:27,490 --> 00:54:29,390
האם יש שאלות על זה?

1061
00:54:29,390 --> 00:54:29,780
כן?

1062
00:54:29,780 --> 00:54:32,642
>> 4 SPEAKER: האם אתה מקבל הודעת שגיאה אם ​​אתה
הייתה הפסקה אחרי מקרה אחד, אבל זה

1063
00:54:32,642 --> 00:54:34,550
לא היה לי משהו בשביל לעשות את זה?

1064
00:54:34,550 --> 00:54:37,820
>> יוסף: אז השאלה היא שאתה מקבל
שגיאה אם ​​יש לך הפסקה לאחר

1065
00:54:37,820 --> 00:54:39,730
מקרה אחד, אבל אין מה לעשות?

1066
00:54:39,730 --> 00:54:41,520
והתשובה היא לא.

1067
00:54:41,520 --> 00:54:43,172
אתה לא ממש מקבל שגיאה.

1068
00:54:43,172 --> 00:54:44,590
כן, מ"מ הממ.

1069
00:54:44,590 --> 00:54:54,540
>> אז כמו סוג של שינוי קטן כאן,
אני הולך לשים את printf כאן.

1070
00:54:54,540 --> 00:54:55,790
אופס.

1071
00:54:55,790 --> 00:55:00,994

1072
00:55:00,994 --> 00:55:04,880
אז מה זה הייתי להדפיס אם
שמתי אחד כבקלט?

1073
00:55:04,880 --> 00:55:07,530

1074
00:55:07,530 --> 00:55:07,770
כן.

1075
00:55:07,770 --> 00:55:10,360
זה הייתי אומר לך שזה לא לקח
מספר גבוה פי שתיים, נכון?

1076
00:55:10,360 --> 00:55:13,500
כי זה יפגע שבמקרה הראשון,
זה לא ישבור, וזה היה נופל

1077
00:55:13,500 --> 00:55:15,730
עד למקרה השני.

1078
00:55:15,730 --> 00:55:16,950
כל שאלות על זה?

1079
00:55:16,950 --> 00:55:18,280
>> ROB: האם יש לך עוד שאלה?

1080
00:55:18,280 --> 00:55:20,840
>> יוסף: אוקיי, מגניב.

1081
00:55:20,840 --> 00:55:22,400
בסדר.

1082
00:55:22,400 --> 00:55:25,780
אז יש עוד משהו שאנחנו קוראים
מפעיל משולש שהוא בעצם

1083
00:55:25,780 --> 00:55:29,010
תחביר חלופי לעושים
אם ולאחר מכן אחר.

1084
00:55:29,010 --> 00:55:30,470
וזה מאפשר לך לעשות את כל זה בשורה אחת.

1085
00:55:30,470 --> 00:55:34,110
אז בתכנית מסוימת זו,
אני שואל את המשתמש עבור n.

1086
00:55:34,110 --> 00:55:37,190
ואם n הוא גדול יותר מאשר 100, אני אומר לי
שלהם הם בחרו מספר גבוה.

1087
00:55:37,190 --> 00:55:39,560
אחר אני אומר להם שהם
הרים מספר נמוך.

1088
00:55:39,560 --> 00:55:43,030
>> אז אנחנו יכולים להשתמש בתחביר באמת הארוך הזה,
מחרוזת, S, ולאחר מכן בדוק אם n הוא

1089
00:55:43,030 --> 00:55:45,260
יותר מ 100 ולהקצות
אותו בהתאם.

1090
00:55:45,260 --> 00:55:49,450
אבל אנחנו יכולים לעשות את זה הרבה יותר תמציתי
על ידי שימוש בתחביר מפעיל משולש זה

1091
00:55:49,450 --> 00:55:52,090
הכולל שאלה
סימן ומעי גס.

1092
00:55:52,090 --> 00:55:55,070
אז סימן השאלה הוא במהותו
שואל שאלה, נכון?

1093
00:55:55,070 --> 00:55:56,625
>> ROB: הגדלה אולי על זה.

1094
00:55:56,625 --> 00:55:57,372
>> יוסף: כן.

1095
00:55:57,372 --> 00:56:00,210
נקודה טובה.

1096
00:56:00,210 --> 00:56:02,550
אז זה המפעיל המשולש.

1097
00:56:02,550 --> 00:56:06,100
אני ראשון ששואל את השאלה,
הוא n גדול מ 100?

1098
00:56:06,100 --> 00:56:09,770
אם כן, אז אני מבצע ראשון
חלק לפני המעי הגס.

1099
00:56:09,770 --> 00:56:13,360
אם זה לא, אז אני מבצע
חלק שני אחרי הנקודתיים.

1100
00:56:13,360 --> 00:56:16,640
אז אם n הוא גדול יותר מאשר 100,
אז זה מרים גבוה ומעמיד

1101
00:56:16,640 --> 00:56:18,360
כי למחרוזת s.

1102
00:56:18,360 --> 00:56:22,170
אם n הוא פחות מ 100, זה מרים נמוך
ואז מכניס את זה לתוך מחרוזת s.

1103
00:56:22,170 --> 00:56:30,186
אז זה יהיה לעבות נתח הגדול הזה
למטה לתוך בדיוק את זה בשורה אחת.

1104
00:56:30,186 --> 00:56:32,010
>> SPEAKER 5: האם זה פופולרי?

1105
00:56:32,010 --> 00:56:36,070
>> יוסף: כן, זה הוא די פופולרי עבור
דברים בו בעצם אתה רוצה

1106
00:56:36,070 --> 00:56:38,700
אין משימה המבוססת על
איזה מצב.

1107
00:56:38,700 --> 00:56:43,110
ובמקרה הזה, אנחנו מנסים
כדי להקצות ערך למחרוזת s.

1108
00:56:43,110 --> 00:56:44,840
זה לא כל כך -

1109
00:56:44,840 --> 00:56:47,670
אני מניח שאני לא באמת מעדיף
שלה במקרים אחרים.

1110
00:56:47,670 --> 00:56:49,390
אבל זה שימושי במיוחד
למשימה הזאת.

1111
00:56:49,390 --> 00:56:54,490
>> רוב: זה דפוס די נפוץ
שבו יש לך קצת משתנים כי

1112
00:56:54,490 --> 00:56:58,200
אתה הולך לומר, אם משהו, להגדיר
משתנה זה לערך אחד; אחר, שנקבע

1113
00:56:58,200 --> 00:56:59,810
משתנה זה לערך אחר.

1114
00:56:59,810 --> 00:57:03,360
וזה התרחיש
שבו ישתמש משולש.

1115
00:57:03,360 --> 00:57:05,220
>> יוסף: ואתה שומר
המון קווים, נכון?

1116
00:57:05,220 --> 00:57:08,090
וזה רק גורם קוד שלך לטעון
קצת יותר קריא.

1117
00:57:08,090 --> 00:57:08,635
כן, שאלה?

1118
00:57:08,635 --> 00:57:12,384
>> SPEAKER 6: למשולש, אתה יכול ללכת,
שווים של מחרוזת s, סימן שאלה?

1119
00:57:12,384 --> 00:57:15,280
ואז אתה יכול להיות, למשל,
חמש אפשרויות שונות.

1120
00:57:15,280 --> 00:57:18,310
ותלוי מה מספר n
היה, היית בוחר אחד מאותם?

1121
00:57:18,310 --> 00:57:22,210
>> יוסף: אז השאלה היא, האם יש
סוג של תחביר שבו אתה יכול לעשות את המחרוזת

1122
00:57:22,210 --> 00:57:25,910
ים שווה n, ואז יש להם יותר משני
אפשרויות לאחר שסימן השאלה?

1123
00:57:25,910 --> 00:57:29,740
ותשובה פשוטה היא לא, אין
באמת דרך טובה לעשות את זה, אלא אם כן

1124
00:57:29,740 --> 00:57:33,850
אתה רוצה משולש מרובה קן
מפעילים פנימיים של כל אחד אחר.

1125
00:57:33,850 --> 00:57:38,050
>> אתה יכול לעשות כמו n גדול מ 100,
סימן שאלה, ואז עוד אחד

1126
00:57:38,050 --> 00:57:41,850
מפעיל משולש, n גדול מ 50,
סימן שאלה, וקן זה ככה.

1127
00:57:41,850 --> 00:57:45,240
אבל בתרחיש זה, הקוד שלך הוא
מקבל סוג של בלתי קריא ומבולגן,

1128
00:57:45,240 --> 00:57:47,920
וזה יכול להיות טוב יותר רק כדי ללכת ל
הצהרה אם / אחרת בשלב זה.

1129
00:57:47,920 --> 00:57:54,530
>> רוב: וגם, כהערה צדדית, PHP
באופן שגוי מיישם המשולש

1130
00:57:54,530 --> 00:57:58,053
מפעיל כזה שternaries המקונן
אפילו לא עובד כמו שצריך.

1131
00:57:58,053 --> 00:57:58,840
>> יוסף: כן.

1132
00:57:58,840 --> 00:58:01,170
אז זה נהיה קצת מבלבל,
במיוחד כשאתה הולך

1133
00:58:01,170 --> 00:58:02,145
לשפות שונות.

1134
00:58:02,145 --> 00:58:04,810
>> ROB: זה מבלבל מספיק, כי
שפות טועים בקשר לזה.

1135
00:58:04,810 --> 00:58:08,030

1136
00:58:08,030 --> 00:58:11,510
>> יוסף: אז בעצם, רק כדי להבהיר,
יודע כל מה ש

1137
00:58:11,510 --> 00:58:13,900
% S עושה כאן?

1138
00:58:13,900 --> 00:58:15,650
כל שאלות על זה?

1139
00:58:15,650 --> 00:58:19,760
אני מניח שרק בשביל המצלמה,% s
בעצם מאפשר לנו לשים מציין מיקום

1140
00:58:19,760 --> 00:58:20,790
למחרוזת.

1141
00:58:20,790 --> 00:58:23,920
ואז בסוף, אנו מציינים כי
משתנה שאנחנו רוצים לשים לזה

1142
00:58:23,920 --> 00:58:25,500
בעל מקום הוא ים.

1143
00:58:25,500 --> 00:58:27,730
אז זה לוקח ים בעצם
וזה מכניס אותו לכאן.

1144
00:58:27,730 --> 00:58:32,130
ואז זה יהיה להדפיס, בחרת
גבוה או שבחרת מספר נמוך.

1145
00:58:32,130 --> 00:58:33,770
על אישור.

1146
00:58:33,770 --> 00:58:36,970
>> אז לולאות נאפשר לך לבצע דברים
בתנועות מעגליות, נכון?

1147
00:58:36,970 --> 00:58:40,300
ייתכן שנתקלת בכך ב
שריטה בצורה של Forever לולאות

1148
00:58:40,300 --> 00:58:45,650
או חזור על הפעולה עד או חזור בפרט
מספר פעמים.

1149
00:58:45,650 --> 00:58:47,540
אז למה זה טוב לנו?

1150
00:58:47,540 --> 00:58:51,500
ובכן, ב-C, נניח שיש לנו את זה
שיר בוצע בגרד ש

1151
00:58:51,500 --> 00:58:53,450
שרה, זה השיר
כי אף פעם לא נגמר.

1152
00:58:53,450 --> 00:58:55,710
זה פשוט נמשך ונמשך ו
לעולם ועד.

1153
00:58:55,710 --> 00:58:59,395
ובכן, אתה לא באמת יכול לעשות את תכנית
שיש מספר אינסופי של printf

1154
00:58:59,395 --> 00:59:00,850
הצהרות בזה, נכון?

1155
00:59:00,850 --> 00:59:04,900
>> אז בתרחיש מסוים זה, בדרך זו
כי אתה יכול לעשות את העבודה הזאת ו

1156
00:59:04,900 --> 00:59:09,330
כדי להפוך אותו להדפיס לנצח הוא
במקום להשתמש בלולאה בזמן.

1157
00:59:09,330 --> 00:59:13,640
אז לולאה בזמן שתבצע מה
בגופם של שתי פלטות ה

1158
00:59:13,640 --> 00:59:17,250
שייך לזה על סמך מה
התנאי הוא.

1159
00:59:17,250 --> 00:59:21,170
אז בדוגמא זו בפרט לפני, אם
אנחנו רוצים להדפיס לנצח זה, מה

1160
00:59:21,170 --> 00:59:23,590
אולי אנחנו עושים?

1161
00:59:23,590 --> 00:59:25,190
טוב, ברור, נכון?

1162
00:59:25,190 --> 00:59:32,290
>> אז זה סוג של משלב את הרעיון
של כמה ביטוי בוליאני

1163
00:59:32,290 --> 00:59:33,610
יחד עם לולאה.

1164
00:59:33,610 --> 00:59:35,780
ולמדנו על וליאנית
ביטויים קודם לכן.

1165
00:59:35,780 --> 00:59:39,650
אז בכל פעם שמצבו הפנימי של
בעוד שנשאר נכון, לולאה זו

1166
00:59:39,650 --> 00:59:41,480
יבצע על ועל ועל.

1167
00:59:41,480 --> 00:59:44,640
ובמקרה זה, אם אנחנו רק מספקים אותו
עם זה נכון, זה גורם אינסופי

1168
00:59:44,640 --> 00:59:49,310
לולאה שמדפיסה את השיר הלאה וכן הלאה
ועל כמו שאנחנו רצויים לפני בלי

1169
00:59:49,310 --> 00:59:52,410
יש תכנית שיש לי אינסופי
מספר הצהרות printf, שהוא

1170
00:59:52,410 --> 00:59:55,220
לא אפשרי.

1171
00:59:55,220 --> 00:59:57,810
>> כך יותר משכנע, אם כי,
אתה יכול להשתמש בזה עם

1172
00:59:57,810 --> 00:59:59,710
משתנה ומצבו.

1173
00:59:59,710 --> 01:00:04,420
אז בואו נגיד שאנחנו רוצים לחזור
ביטוי, מסוחרר לחלוטין, 10 פעמים.

1174
01:00:04,420 --> 01:00:08,380
אז מה אתה יכול לעשות עם לולאה בזמן שהוא
ראשון שאתה יכול לאתחל דלפק

1175
01:00:08,380 --> 01:00:10,860
מחוץ משתנה של
בעוד לולאה עד 10.

1176
01:00:10,860 --> 01:00:14,360
ואז בעצם, בכל פעם שאתה הולך
דרך הלולאה בזמן, אתה מדפיס

1177
01:00:14,360 --> 01:00:19,090
המשפט, ואז אתה מקטין
דלפק משתנה עד שבסופו של הדבר,

1178
01:00:19,090 --> 01:00:23,020
בשלב מסוים, ברגע שאנחנו לחסרי מספיק
פעמים, 1 מ מספיק פעמים -

1179
01:00:23,020 --> 01:00:27,290
ורק כדי להבהיר, אני מינוס מינוס
אומר שאני שווה אני מינוס 1.

1180
01:00:27,290 --> 01:00:31,280
>> שבעצם יביא אותי ל
נקודה שבה ברגע שאני מכה אפס, זה

1181
01:00:31,280 --> 01:00:35,260
מצב הוא כבר לא נכון ו
כך שזה יוצא מחוץ לעניינים.

1182
01:00:35,260 --> 01:00:37,045
אז לגמרי מסוחרר רק מדפיס 10 פעמים.

1183
01:00:37,045 --> 01:00:39,550

1184
01:00:39,550 --> 01:00:41,080
כל שאלות על לולאה בעוד?

1185
01:00:41,080 --> 01:00:44,580

1186
01:00:44,580 --> 01:00:46,790
על אישור.

1187
01:00:46,790 --> 01:00:50,550
>> אז יש דרך שאנחנו יכולים לעשות את מה שאנחנו פשוט
עשה בצורה תמציתית יותר עם

1188
01:00:50,550 --> 01:00:51,715
מה שאנחנו קוראים ללולאה.

1189
01:00:51,715 --> 01:00:55,750
אז לולאה למורכבת
אתחול, מצב, ו

1190
01:00:55,750 --> 01:00:58,950
עדכון, בדיוק כמו שהיו לנו לפני
בבעוד לולאה זו.

1191
01:00:58,950 --> 01:00:59,890
אז בואו נסתכל.

1192
01:00:59,890 --> 01:01:02,900
בבעוד לולאה זו, הייתה לנו
אתחול, ולאחר מכן היה לנו

1193
01:01:02,900 --> 01:01:04,260
תנאי שבדקנו.

1194
01:01:04,260 --> 01:01:06,450
ואז היה לנו עדכון
צעד בראש.

1195
01:01:06,450 --> 01:01:10,060
>> עם לולאה ל, זה בעצם לוקח
שלושת הדברים האלה ומתעבה אותו

1196
01:01:10,060 --> 01:01:11,370
למטה לתוך שורה אחת.

1197
01:01:11,370 --> 01:01:15,130
אז הדבר הראשון שהיא עושה ב
ללולאת האתחול.

1198
01:01:15,130 --> 01:01:19,090
ואז אתה עושה פסיק, ולאחר מכן
אתה עושה את מצבו, שהוא אני

1199
01:01:19,090 --> 01:01:22,200
גדול מאפס הולך לשם,
ואז שלב העדכון.

1200
01:01:22,200 --> 01:01:26,470
אז זה מקבל בוצע ב
הסוף של גוף הלולאה.

1201
01:01:26,470 --> 01:01:28,790
אז שתי תוכניות אלה הן
למעשה שווה ערך.

1202
01:01:28,790 --> 01:01:31,960

1203
01:01:31,960 --> 01:01:33,870
>> כל שאלה?

1204
01:01:33,870 --> 01:01:37,000
אז מה הוא הבדל אחד
בין שני אלה?

1205
01:01:37,000 --> 01:01:38,000
האם מישהו יכול להצביע עליה?

1206
01:01:38,000 --> 01:01:40,480
זה יכול להיות קצת עדין.

1207
01:01:40,480 --> 01:01:41,930
זה פשוט הבדל קטן מאוד.

1208
01:01:41,930 --> 01:01:42,330
כן?

1209
01:01:42,330 --> 01:01:49,008
>> SPEAKER 5: אתה לא תוכל להשתמש
אני משתנה מחוץ ללולאה

1210
01:01:49,008 --> 01:01:49,962
[לא ברור]?

1211
01:01:49,962 --> 01:01:50,900
>> יוסף: בדיוק.

1212
01:01:50,900 --> 01:01:53,550
אז זה משהו שאנחנו נתחיל את
מאוחר יותר נקרא היקף משתנה.

1213
01:01:53,550 --> 01:01:56,610
אבל בעצם, זה int אני חיי
מחוץ ללולאה בזמן הזה.

1214
01:01:56,610 --> 01:01:59,800
אז ברגע שבעוד לולאה זה נעשה
ביצוע, אני אהיה מסוגל להשתמש מאוחר יותר

1215
01:01:59,800 --> 01:02:00,880
בתכנית.

1216
01:02:00,880 --> 01:02:05,430
>> ואילו עם זה ללולאה, אני int זה
הוא scoped בתוך זה ללולאה.

1217
01:02:05,430 --> 01:02:10,240
ובגלל זה הוא חלק פנימי של חלק זה
של לולאה לקבלת, שמתחיל

1218
01:02:10,240 --> 01:02:13,200
בסוגריים ומסתיים עם
הסד המתולתל שם.

1219
01:02:13,200 --> 01:02:16,120
כל דבר שהוא הצהיר בתוך
כאן לא ניתן להשתמש בחוץ.

1220
01:02:16,120 --> 01:02:20,420
אז אם אני מנסה להשתמש אני בחוץ, זה יהיה
תגיד לי, סמל הבלתי מוכרז.

1221
01:02:20,420 --> 01:02:22,420
ובעצם, לא הייתי
תוכל להשתמש בו.

1222
01:02:22,420 --> 01:02:28,460
>> ROB: וכן, לפני 10 שנים, ב
פשוטו כמשמעו, בכל המקרים, סוגריים מסולסלים הם

1223
01:02:28,460 --> 01:02:31,140
מה שאתה משמש לקביעה
היקף משתנה.

1224
01:02:31,140 --> 01:02:37,240
אז לשם, int אני שווה 10
הוא הצהיר בתוך זה

1225
01:02:37,240 --> 01:02:38,520
קבוצה של סוגריים מסולסלים.

1226
01:02:38,520 --> 01:02:42,530
וכן לאחר מכן, כל עוד אתה מנסה להשתמש אני
לפני סד מתולתל זה, זה בסדר.

1227
01:02:42,530 --> 01:02:47,090

1228
01:02:47,090 --> 01:02:51,460
ייתכן שאתה רואה כשאתה מקליד לעשות, אתה
תראה את המקף, מקף, STD, שווה, C99.

1229
01:02:51,460 --> 01:02:57,100
>> אז זה הוא גרסה מתקדמת יותר של C כי
GCC יישם שגם נותן לי

1230
01:02:57,100 --> 01:02:58,740
קיצור זה.

1231
01:02:58,740 --> 01:03:03,505
אז זה היה אמור לא להיות מותר בג ו
אתה יכול להבין למה, כי זה int

1232
01:03:03,505 --> 01:03:07,600
אני הוא מחוץ לסד המתולתל הזה, אבל
זה עדיין נחשב ב

1233
01:03:07,600 --> 01:03:09,750
היקף הסוגריים המסולסלים האלה.

1234
01:03:09,750 --> 01:03:14,120
אבל זה דבר מאוד נוח,
ואז זה סיומת טובה.

1235
01:03:14,120 --> 01:03:15,370
>> יוסף: יש שאלות?

1236
01:03:15,370 --> 01:03:17,550

1237
01:03:17,550 --> 01:03:19,260
על אישור.

1238
01:03:19,260 --> 01:03:22,820
אז מה יותר שימושי הוא שלפעמים
אתה רוצה סוג של דינמיות ב

1239
01:03:22,820 --> 01:03:23,410
הלולאה שלך, נכון?

1240
01:03:23,410 --> 01:03:26,350
אתה לא רוצה רק בהכרח להדפיס
לגמרי מסוחרר כל הזמן, אתה

1241
01:03:26,350 --> 01:03:28,650
רוצה לספור למטה מ
10 או משהו.

1242
01:03:28,650 --> 01:03:32,010
ואז אתה יכול להשתמש במשתנת counter
כמו גם בתוך הלולאה ש.

1243
01:03:32,010 --> 01:03:35,530
ובמקרה הזה, תכנית זו רק
סופר לאחור מ10 כל הדרך למטה.

1244
01:03:35,530 --> 01:03:39,260
ומה זה לא מדפיס?

1245
01:03:39,260 --> 01:03:42,790
זה לא מדפיס אפס,
צודק, משום שכאשר -

1246
01:03:42,790 --> 01:03:45,460
כן, זה גם לא מדפיס 11.

1247
01:03:45,460 --> 01:03:49,200
>> אז זה לא מדפיס אפס, כי כאשר
אני הוא אפס, זוכר, זה מעריך

1248
01:03:49,200 --> 01:03:52,170
המצב לפני שהוא ממשיך
כדי לבצע את גוף הלולאה.

1249
01:03:52,170 --> 01:03:56,820
וכשאני הוא אפס, זה שקר, ולכן
זה לא להדפיס את הספירה לאחור

1250
01:03:56,820 --> 01:04:00,200
אפס, זה פשוט מדפיס את הספירה
למטה 10 כל הדרך למטה עד 1.

1251
01:04:00,200 --> 01:04:03,420
אם אנחנו באמת רוצים אותה כדי להדפיס אפס,
אז היינו לשים סימן שוויון

1252
01:04:03,420 --> 01:04:04,750
אחרי זה גדול יותר משלט.

1253
01:04:04,750 --> 01:04:09,400

1254
01:04:09,400 --> 01:04:10,130
על אישור.

1255
01:04:10,130 --> 01:04:16,410
>> אז דרך אחת לעשות את אימות קלט, אשר
הוא כשאתה שואל את המשתמש לעשות

1256
01:04:16,410 --> 01:04:18,620
משהו, אתה רוצה להפוך אותם בטוחים
עקבו אחר ההוראות שלך, הוא להשתמש

1257
01:04:18,620 --> 01:04:19,400
הלולאה בזמן, נכון?

1258
01:04:19,400 --> 01:04:22,990
אז במקרה הספציפי הזה, אני מבקש
למספר חיובי ואז אני

1259
01:04:22,990 --> 01:04:23,810
מחכה לקלט.

1260
01:04:23,810 --> 01:04:28,210
>> ואז בדקתי בזמן שהקלט הוא
פחות מאפס, כל זמן שואל אותם.

1261
01:04:28,210 --> 01:04:32,100
אז כל עוד הם נותנים לי מספר
זה לא חיובי, להמשיך לשאול,

1262
01:04:32,100 --> 01:04:33,600
כל זמן שואל, חוזר ושואל.

1263
01:04:33,600 --> 01:04:35,860
אבל מה הוא סוג של מוזר על זה?

1264
01:04:35,860 --> 01:04:38,570
או מה שלא נראה אופטימלי על
מבנה זה כאן?

1265
01:04:38,570 --> 01:04:44,282

1266
01:04:44,282 --> 01:04:44,758
אף אחד?

1267
01:04:44,758 --> 01:04:45,234
כן?

1268
01:04:45,234 --> 01:04:47,614
>> SPEAKER 6: אתה חוזר
ההדרכה פעמיים.

1269
01:04:47,614 --> 01:04:48,100
>> יוסף: נכון.

1270
01:04:48,100 --> 01:04:50,090
אז יש לנו שתי הצהרות printf
כאן, נכון?

1271
01:04:50,090 --> 01:04:53,440
אז יש דרך בה אנו יכולים לקבל את זה רק
עד אחד שיגרום לנו

1272
01:04:53,440 --> 01:04:57,170
קוד קל יותר לקריאה ו
קצת יותר נקי.

1273
01:04:57,170 --> 01:05:00,180
ואז אנחנו לא נצטרך
יש קבל בפעמים גם כן.

1274
01:05:00,180 --> 01:05:03,740
ודרך אחת אתה יכול לעשות זאת היא
באמצעות לולאת Do-אמנם.

1275
01:05:03,740 --> 01:05:07,670
>> ולולאת Do-אמנם היא בעצם
צורה שונה של לולאה בזמן שבו

1276
01:05:07,670 --> 01:05:11,460
כל מה שבתוך הסוגריים המסולסלים
מקבל להורג לפחות פעם אחת.

1277
01:05:11,460 --> 01:05:14,840
אז הנה, אני מצהיר, int
קלט, מחוץ ראשון.

1278
01:05:14,840 --> 01:05:18,100
ואז אני פשוט אומר, לעשות את זה
הוראות תוך קלט

1279
01:05:18,100 --> 01:05:19,140
הוא פחות מאפס.

1280
01:05:19,140 --> 01:05:20,530
אז הוא פוגע בלעשות קודם.

1281
01:05:20,530 --> 01:05:24,190
זה תמיד יהיה לבצע את זה לפחות
פעם אחת, כך שזה תמיד לשאול את המשתמש

1282
01:05:24,190 --> 01:05:25,960
עבור קלט לפחות פעם אחת.

1283
01:05:25,960 --> 01:05:29,390
ואז זה מעריך את הקלט ש,
וזה ממשיך במעגל.

1284
01:05:29,390 --> 01:05:30,135
כן, שאלה?

1285
01:05:30,135 --> 01:05:32,602
>> SPEAKER 6: האם יש דרך לעשות את זה
[לא ברור] סוגים, כמו שאם אתה אומר,

1286
01:05:32,602 --> 01:05:34,268
GetString, ומישהו [לא ברור]

1287
01:05:34,268 --> 01:05:35,220
האם יש דרך ל[ לא ברור]

1288
01:05:35,220 --> 01:05:40,060
>> יוסף: אז השאלה היא, האם יש
דרך לעשות אימות קלט אם המשתמש

1289
01:05:40,060 --> 01:05:41,850
לא לשים בצד הימין
סוג משתנה?

1290
01:05:41,850 --> 01:05:44,460
אז אם אנו מבקשים int והם
לתת לנו מחרוזת במקום.

1291
01:05:44,460 --> 01:05:49,110
ובפונקציות שאנו מקיימים
בשבילך, GetInt, GetString בכל

1292
01:05:49,110 --> 01:05:52,680
פונקציות אלה, הם למעשה כבר
לעשות סוג כזה של קלט בסיסי סוג

1293
01:05:52,680 --> 01:05:54,120
אימות מתחת למכסת המנוע.

1294
01:05:54,120 --> 01:05:57,390
אז אם אתה משתמש בפונקציות שאנחנו
נתתי לך, לא באמת שיש לך.

1295
01:05:57,390 --> 01:06:01,380
>> אבל אם אתה רוצה להיראות יותר לתוך כיצד
אתה באמת יכול לעשות את זה, אתה יכול להסתכל

1296
01:06:01,380 --> 01:06:03,360
מתחת למכסת המנוע בקובץ I/O--

1297
01:06:03,360 --> 01:06:07,990
לא הגיש, פונקציות קלט / פלט הסטנדרטי
כמו לקרוא מקלט סטנדרטי ו

1298
01:06:07,990 --> 01:06:08,580
פלט סטנדרטי.

1299
01:06:08,580 --> 01:06:10,630
ואתה יכול לקבל תחושה טובה יותר
איך אתה יכול לעשות את זה.

1300
01:06:10,630 --> 01:06:13,670
>> ROB: נושא אחד, אם כי, הוא במיוחד
עם הדוגמא אתה

1301
01:06:13,670 --> 01:06:17,070
אמר, אתה מצפה מחרוזת
ואני נכנסתי int.

1302
01:06:17,070 --> 01:06:20,110
איך היית לראות את ההבדל
בין בכוונה רוצה

1303
01:06:20,110 --> 01:06:23,130
מחרוזת 123 לעומת רוצה 123 int?

1304
01:06:23,130 --> 01:06:29,230
אז מחרוזת, זה פחות או יותר אין
אימות, זה רק מה שהם

1305
01:06:29,230 --> 01:06:31,600
נכנס לך תפרש
כמחרוזת.

1306
01:06:31,600 --> 01:06:35,790
>> Int הוא קל יותר, כי לא משנה
קלט שאתה לוקח מהמשתמש, אתה

1307
01:06:35,790 --> 01:06:37,470
תמיד לוקח את מחרוזת.

1308
01:06:37,470 --> 01:06:40,650
וכן מחרוזת כי אז אתה יכול
לבדוק, הם כל אלה

1309
01:06:40,650 --> 01:06:44,218
ספרות מספרית בעצם?

1310
01:06:44,218 --> 01:06:45,170
>> יוסף: על אישור.

1311
01:06:45,170 --> 01:06:46,420
כל שאלות על לולאת Do-אמנם?

1312
01:06:46,420 --> 01:06:49,170
>> ROB: אה, וזה גם -

1313
01:06:49,170 --> 01:06:55,130
חוזר לההיקף, נפוץ למדי
טעות מנסה להשתמש בכמה מקומי

1314
01:06:55,130 --> 01:06:59,540
משתנה מתוך Do-אמנם זה
לולאה הפנימית של מצב זה.

1315
01:06:59,540 --> 01:07:02,850
ובעצם, אם רק נפטרתי מ
וזה אמר, קלט int שווה

1316
01:07:02,850 --> 01:07:06,990
GetInt, אז המהדר צועק על
לנו, כי קלט אינו קיימת

1317
01:07:06,990 --> 01:07:08,900
מחוץ להיקף של
הסוגריים מסולסלים האלה.

1318
01:07:08,900 --> 01:07:10,792
>> יוסף: ובגלל זה אנחנו
צריך מערך זה כאן.

1319
01:07:10,792 --> 01:07:13,620

1320
01:07:13,620 --> 01:07:14,630
על אישור.

1321
01:07:14,630 --> 01:07:17,530
אז אתה גם יכול לפרוץ את
הלולאה מוקדם אם אתם רוצים.

1322
01:07:17,530 --> 01:07:21,240
אז זו דרך של שונה
יישום מה שאנחנו פשוט ליישם.

1323
01:07:21,240 --> 01:07:24,340
ובמקום להשתמש במצב
בתוך הסוגריים, אנחנו משתמשים

1324
01:07:24,340 --> 01:07:26,920
אם הצהרה הפנימית של הגוף
של Do-בעוד הלולאה.

1325
01:07:26,920 --> 01:07:30,000
>> ובעצם, כאשר הקלט סוף הסוף
גדול מאפס, נעשינו את זה

1326
01:07:30,000 --> 01:07:31,000
לפרוץ את הלולאה.

1327
01:07:31,000 --> 01:07:33,420
וכך אנחנו נלך כל
עד לכאן.

1328
01:07:33,420 --> 01:07:37,920
ואתם יכולים לראות שהיית עושים את זה
כנראה העדיף בזה

1329
01:07:37,920 --> 01:07:39,870
תרחיש, כי זה קצת
מנקה קצת וקצת

1330
01:07:39,870 --> 01:07:41,380
קצת יותר קל לקריאה.

1331
01:07:41,380 --> 01:07:45,210
ואילו זה, אתה סוג של
יש קווים נוספים בו.

1332
01:07:45,210 --> 01:07:47,890
זה רק קצת יותר מכוער,
אני מניח, במובן מסוים.

1333
01:07:47,890 --> 01:07:48,530
כן, שאלה?

1334
01:07:48,530 --> 01:07:52,178
>> 4 SPEAKER: אשבור רק לקבל
אותך מקבוצה אחת של פלטה?

1335
01:07:52,178 --> 01:07:53,080
>> יוסף: נכון.

1336
01:07:53,080 --> 01:07:58,100
אז השאלה היא תשבור רק
להוציא אותך מלולאה אחת?

1337
01:07:58,100 --> 01:07:59,280
והתשובה היא כן.

1338
01:07:59,280 --> 01:08:04,290
אז אם יש לך מקונן ללולאות, עבור
דוגמא, אם יש לי לint אני שווה 0

1339
01:08:04,290 --> 01:08:09,040
עד 10 ולאחר מכן לInt J שווה 0
עד 10, אם אני לפרוץ את פנימי

1340
01:08:09,040 --> 01:08:12,310
לולאה, אני עדיין הולך
ללולאה החיצונית.

1341
01:08:12,310 --> 01:08:15,760
אז זה ישמור את ביצוע
פעולות בצד החיצוני.

1342
01:08:15,760 --> 01:08:17,640
כל שאלות על זה?

1343
01:08:17,640 --> 01:08:18,000
כן?

1344
01:08:18,000 --> 01:08:21,760
>> SPEAKER 5: אבל לשבור פונקציות בלבד
לסוגריים מסולסלים, ולא לאחרים

1345
01:08:21,760 --> 01:08:22,230
הצהרות?

1346
01:08:22,230 --> 01:08:22,700
[לא ברור]

1347
01:08:22,700 --> 01:08:27,620
>> יוסף: אז השאלה היא תשבור
רק פונקציה עבור לולאות לעומת

1348
01:08:27,620 --> 01:08:29,014
הצהרות אחרות כמו אם?

1349
01:08:29,014 --> 01:08:32,950
וכן, זה המקרה, כי
אתה שבירה מתוך לולאה, ימינה,

1350
01:08:32,950 --> 01:08:33,630
במובן מסוים.

1351
01:08:33,630 --> 01:08:37,215
>> רוב: ברוב המכריע של המקרים, זה
זה הסוג של משהו אם,

1352
01:08:37,215 --> 01:08:37,660
לאחר מכן הפסקה.

1353
01:08:37,660 --> 01:08:41,580
אז אתה לא צריך לשבור לחול
אם כי הוא כורך סביבו.

1354
01:08:41,580 --> 01:08:45,250
וגם, זה לא הרבה של לולאה,
אך יש לזכור כי בוררים הם גם

1355
01:08:45,250 --> 01:08:46,340
פרץ על ידי הפסקות.

1356
01:08:46,340 --> 01:08:48,390
ראינו בשימוש הפסקות
עם מתגים בעבר.

1357
01:08:48,390 --> 01:08:52,189
>> יוסף: ואתה יכול גם להשתמש בם
בלולאות בזמן וללולאות.

1358
01:08:52,189 --> 01:08:54,560
כל שאלה?

1359
01:08:54,560 --> 01:08:55,830
על אישור.

1360
01:08:55,830 --> 01:08:57,779
אז עד הבא הוא פונקציות.

1361
01:08:57,779 --> 01:09:01,500
אז ייתכן שהשתמשת באחד מאלה BYOB
בלוקים בפרויקט Scratch שלך.

1362
01:09:01,500 --> 01:09:04,569
וזה בעצם מאפשר
לך להגדיר סט של

1363
01:09:04,569 --> 01:09:05,680
הוראות להיות אחריו.

1364
01:09:05,680 --> 01:09:09,569
>> ומה שאני מתכוון זה בואו נחשוב
בחזרה למתמטיקה, נכון, אלגברה.

1365
01:09:09,569 --> 01:09:13,370
יש לך מה שאנו מכנים פונקציה של x,
כמה משתנים, ובואו נגיד את זה

1366
01:09:13,370 --> 01:09:16,080
פונקציה היא f של x שווה X ועוד 5.

1367
01:09:16,080 --> 01:09:20,410
אז אתה יכול לחשוב על f של x כמו זה שחור
תיבה שלוקחת 15 ובאז

1368
01:09:20,410 --> 01:09:22,590
מייצר 20.

1369
01:09:22,590 --> 01:09:26,630
>> אז באופן כללי יותר, פונקציה היא
משהו שלוקח כמה כניסות ו

1370
01:09:26,630 --> 01:09:27,880
לאחר מכן מייצר כמה יציאות.

1371
01:09:27,880 --> 01:09:31,920

1372
01:09:31,920 --> 01:09:32,960
ולמה פונקציות הן טובות?

1373
01:09:32,960 --> 01:09:35,189
הם טובים עבור מספר הסיבות.

1374
01:09:35,189 --> 01:09:40,470
אז מישהו רוצה לקחת לדקור
במה שארגון אומר?

1375
01:09:40,470 --> 01:09:42,630
במונחים של הסיבה פונקציות מועילות?

1376
01:09:42,630 --> 01:09:43,090
כן?

1377
01:09:43,090 --> 01:09:44,735
>> 4 SPEAKER: זה גורם לך
קוד קריא יותר.

1378
01:09:44,735 --> 01:09:45,399
>> יוסף: נכון.

1379
01:09:45,399 --> 01:09:47,670
אז אחד הדברים הוא שהוא עושה
הקוד שלך קריא יותר, נכון?

1380
01:09:47,670 --> 01:09:53,710
במקום שיש כמו int x שווה x
פעמים x פעמים x, אני יכול לקבל את קובייה של x,

1381
01:09:53,710 --> 01:09:57,190
שהוא יותר קריא ויותר
מובן לקורא.

1382
01:09:57,190 --> 01:10:01,150
>> ארגון גם הוא במונחים של
פיצול הקוד שלך לניהול

1383
01:10:01,150 --> 01:10:05,610
מנות, כך שבמקום לנסות
ליישם את כל זה בקטע אחד ארוך

1384
01:10:05,610 --> 01:10:09,070
בעיקרי, אתה יכול סוג של לפצל אותה
למעין, אוקיי, בואו לכתוב פונקציה

1385
01:10:09,070 --> 01:10:11,910
לקוביית משהו, בואו נכתוב
לתפקד לרבע משהו.

1386
01:10:11,910 --> 01:10:15,950
ככה אתה יכול לפצל אותו לקטנטן,
חלקים קטנים שאתה יכול להתמודד

1387
01:10:15,950 --> 01:10:18,944
בניגוד למנסה להתמודד
בעיה גדולה בבת אחת.

1388
01:10:18,944 --> 01:10:21,806
>> חלקים או אפילו זעירים, קטנים ש: ROB
אתה ושותף יכולים להתמודד.

1389
01:10:21,806 --> 01:10:22,283
>> יוסף: כן.

1390
01:10:22,283 --> 01:10:23,855
>> ROB: אז במקום שניהם
אתה מנסה להשתיל אחד

1391
01:10:23,855 --> 01:10:27,170
לתפקד באותו הזמן.

1392
01:10:27,170 --> 01:10:28,800
>> יוסף: פישוט.

1393
01:10:28,800 --> 01:10:30,050
כל מי שרוצה לקחת ניחוש?

1394
01:10:30,050 --> 01:10:33,080

1395
01:10:33,080 --> 01:10:33,410
כן?

1396
01:10:33,410 --> 01:10:34,675
>> SPEAKER 5: עוד חזרות.

1397
01:10:34,675 --> 01:10:35,260
>> יוסף: נכון.

1398
01:10:35,260 --> 01:10:39,210
אז דבר אחד שאתה יכול לעשות עם
פישוט הוא שזה סוג של על

1399
01:10:39,210 --> 01:10:42,520
אותם הקווים כמו מחדש שימושיות הוא כי
ברגע שאני כותב פונקצית קובייה, שאני יכול

1400
01:10:42,520 --> 01:10:45,410
פשוט להשתמש בזה שוב ושוב ושוב
שוב בתכנית שלי במקום הקלדה

1401
01:10:45,410 --> 01:10:49,610
x פעמים פעמים x על x ו
שוב ושוב.

1402
01:10:49,610 --> 01:10:52,980
ופישוט כאן גם פשוט
אומר שזה עושה סוג של הקוד שלך

1403
01:10:52,980 --> 01:10:55,900
קל יותר לאתר באגים ברגע שאתה לפצל
את זה לפונקציות.

1404
01:10:55,900 --> 01:10:58,250
כי אז אתה יכול למקם בי
הבעיות שלך הן סוג של.

1405
01:10:58,250 --> 01:11:00,910

1406
01:11:00,910 --> 01:11:02,160
כל שאלה?

1407
01:11:02,160 --> 01:11:04,200

1408
01:11:04,200 --> 01:11:06,540
>> אז רעיון אחר הוא הפשטה, נכון?

1409
01:11:06,540 --> 01:11:07,390
הקופסה שחורה הזאת.

1410
01:11:07,390 --> 01:11:11,360
כמו שאתה יודע מה עושה GetInt
כדי לקבל קלט מהמשתמש?

1411
01:11:11,360 --> 01:11:12,510
יש לנו לא ממש אמרתי לך, נכון?

1412
01:11:12,510 --> 01:11:15,670
כל מה שאמרנו לך הוא GetInt עושה
בדיוק מה שזה אומר שהיא עושה.

1413
01:11:15,670 --> 01:11:18,440
אז גם אם אנחנו לא אגיד לך איך
זה עובד, אתה עדיין יודע.

1414
01:11:18,440 --> 01:11:21,670
>> אז במקרה הספציפי הזה, זה הוא
פונקציה מרובעת שעושה

1415
01:11:21,670 --> 01:11:24,520
דברים שונים לקלט
כדי לייצר תפוקה.

1416
01:11:24,520 --> 01:11:28,050
ואתה יכול לרבע מספר
ידי הכפלתו ארבע.

1417
01:11:28,050 --> 01:11:30,790
או שאתה יכול מה שאנו מכנים
קצת להזיז אותו על ידי שתיים.

1418
01:11:30,790 --> 01:11:32,960
ואנו לכסות את זה
קצת מאוחר יותר.

1419
01:11:32,960 --> 01:11:36,570
ואין צורך לדעת איך זה
פונקציה באמת עובדת כל עוד זה

1420
01:11:36,570 --> 01:11:37,640
עובד כאמור.

1421
01:11:37,640 --> 01:11:40,740
>> אז מתחת למכסת המנוע, אני יכול להיות
כמו, לחזור קלט פעמים

1422
01:11:40,740 --> 01:11:41,690
שמונה מחולקים על ידי שתי.

1423
01:11:41,690 --> 01:11:42,510
ולא היית יודע, נכון?

1424
01:11:42,510 --> 01:11:44,970
כל מה שאתה צריך לדעת הוא
הוא עושה מה שהוא אומר.

1425
01:11:44,970 --> 01:11:48,070
אז זה הדבר שימושי
על הפשטה.

1426
01:11:48,070 --> 01:11:52,910
>> ועוד דבר הוא סוג של הרעיון הזה
ללוקליזציה של הקוד שלך לאחד

1427
01:11:52,910 --> 01:11:54,280
סעיף מסוים.

1428
01:11:54,280 --> 01:11:57,450
אז אם יש לי בעיה שאתה, אתה לא
צריך ללכת בכל רחבי את הקוד שלך מנסה

1429
01:11:57,450 --> 01:11:58,730
כדי לתקן את הבעיה שבה הייתה.

1430
01:11:58,730 --> 01:12:00,990
אז במקרה הזה, אני יישמנו
קובייה הלא נכון.

1431
01:12:00,990 --> 01:12:02,820
חשבתי שהקובייה הייתה הכפלה
על ידי שלוש.

1432
01:12:02,820 --> 01:12:05,760
>> אז במקרה הזה, זה תכנית אחת
כי רק הכפלה בשלוש

1433
01:12:05,760 --> 01:12:06,750
בכל מקום.

1434
01:12:06,750 --> 01:12:10,910
ויש תכנית אחרת שיש לו
קובייה בחשבון אל פונקציה.

1435
01:12:10,910 --> 01:12:14,040
ואז עכשיו אם אני רוצה לתקן טעות שלי
כאן, אני חייב לתקן את כל קו

1436
01:12:14,040 --> 01:12:15,620
של קוד בתכנית זו.

1437
01:12:15,620 --> 01:12:19,190
ואילו מהצד השני, אם אני משתמש
פונקציה, אני רק צריכה לשנות

1438
01:12:19,190 --> 01:12:20,650
מה לא בסדר במקום אחד.

1439
01:12:20,650 --> 01:12:25,330

1440
01:12:25,330 --> 01:12:28,730
>> אז במדעי מחשב, אנחנו
קוראים לכניסות ויציאות.

1441
01:12:28,730 --> 01:12:31,640
תשומות נקראות פרמטרים או
טיעונים, ותפוקות נקראים

1442
01:12:31,640 --> 01:12:32,950
מחזיר ערכים.

1443
01:12:32,950 --> 01:12:39,000
ואנו רואים איך זה עוזר לנו סוג
מלהגדיר פונקציה בשנייה.

1444
01:12:39,000 --> 01:12:41,430
אז זו הגדרת פונקציה
לעקוב.

1445
01:12:41,430 --> 01:12:45,110
אז זה לוקח קלט, ולאחר מכן
היא מחזירה את זה פעמים מספר

1446
01:12:45,110 --> 01:12:47,020
עצמו שלוש פעמים.

1447
01:12:47,020 --> 01:12:48,020
אז בואו לשבור את זה.

1448
01:12:48,020 --> 01:12:53,090
>> אז יש לנו כותרת פונקציה, אשר
בעצם מורכב משלושה דברים.

1449
01:12:53,090 --> 01:12:56,050
אז יש לנו את הפרמטרים, אשר
הם, כפי שאמרתי קודם,

1450
01:12:56,050 --> 01:12:57,680
תשומות לפונקציה זו.

1451
01:12:57,680 --> 01:12:59,300
ואז אנחנו נותנים את הפונקציה שם.

1452
01:12:59,300 --> 01:13:00,740
במקרה זה, זה נקרא קובייה.

1453
01:13:00,740 --> 01:13:03,860
ואז לציין מה הסוג
של ערך ההחזרה הוא.

1454
01:13:03,860 --> 01:13:06,760
>> אז במקרה הזה, פונקצית הקובייה שלי
לוקח במספר שלם וזה גם

1455
01:13:06,760 --> 01:13:07,890
מחזיר מספר שלם.

1456
01:13:07,890 --> 01:13:11,510
אז אם אני עובר בשניים, שתיים הוא מספר שלם,
היא מחזירה לי שמונה, אשר

1457
01:13:11,510 --> 01:13:13,250
הוא מספר שלם.

1458
01:13:13,250 --> 01:13:15,420
אז להחזיר את שם פרמטרים סוג.

1459
01:13:15,420 --> 01:13:16,670
שאלות על זה?

1460
01:13:16,670 --> 01:13:19,440

1461
01:13:19,440 --> 01:13:24,230
>> ולאחר מכן את ערך ההחזרה הוא למעשה
צוין בסוף באומר תמורה

1462
01:13:24,230 --> 01:13:27,540
ולאחר מכן חוזר כל מה
מכיל את הערך המוחזר.

1463
01:13:27,540 --> 01:13:30,940
אז במקרה הזה, אם אנחנו שמים את כל זה
יחד, פונקציה לוקחת ב

1464
01:13:30,940 --> 01:13:35,100
פרמטרים, זה נקרא משהו, ו
היא מחזירה משהו שהוא הסוג

1465
01:13:35,100 --> 01:13:36,350
שאנחנו אומרים שזה הולך להיות.

1466
01:13:36,350 --> 01:13:39,830

1467
01:13:39,830 --> 01:13:41,080
כל שאלה?

1468
01:13:41,080 --> 01:13:43,710

1469
01:13:43,710 --> 01:13:45,080
>> אז איך אנחנו משתמשים בפונקציה?

1470
01:13:45,080 --> 01:13:49,230
ובכן, אנחנו כותבים פונקציה ולאחר מכן
אנחנו משתמשים בו בתכנית שלנו, נכון?

1471
01:13:49,230 --> 01:13:51,565
אז קראתי לו קובייה, ו
אז אני יכול להשתמש בקובייה.

1472
01:13:51,565 --> 01:13:54,200
>> אבל מה שחשוב לציין
הוא שענייני הסדר.

1473
01:13:54,200 --> 01:13:58,100
אם יש לי קובייה מתחת עיקרי, זה
הולך לרוץ לתוך קובייה.

1474
01:13:58,100 --> 01:14:00,360
ובשלב זה, אין שום דבר
נקרא קובייה בתכנית, וזה

1475
01:14:00,360 --> 01:14:02,550
פשוט הולך להיות כמו, יש לי
אין לי מושג מה הוא קובייה.

1476
01:14:02,550 --> 01:14:05,060
>> אז הוא יגיד לך, משתמע
הכרזה על הפונקציה.

1477
01:14:05,060 --> 01:14:06,690
זה השגיאה שמופיעה.

1478
01:14:06,690 --> 01:14:10,230
ולכן במקרה זה, קובייה היא מתחת
עיקרי, כך שזה לא הולך

1479
01:14:10,230 --> 01:14:12,006
לדעת על זה.

1480
01:14:12,006 --> 01:14:14,724
>> SPEAKER 5: אז עיקרי הוא בדרך כלל
הפונקציה האחרונה מוגדרת?

1481
01:14:14,724 --> 01:14:17,290
>> יוסף: אז השאלה היא,
הוא עיקרי בדרך כלל שעבר

1482
01:14:17,290 --> 01:14:18,170
דבר שהיית מגדיר?

1483
01:14:18,170 --> 01:14:19,730
ולא.

1484
01:14:19,730 --> 01:14:22,280
זה בגלל שאנחנו בדרך כלל אוהבים עיקריים
כדי להיות בראש, נכון?

1485
01:14:22,280 --> 01:14:24,640
כי זה הדבר הראשון שאתה
רוצה מתכנת הפתיחה

1486
01:14:24,640 --> 01:14:25,640
תכנית כדי לראות.

1487
01:14:25,640 --> 01:14:29,950
ואז איך אנחנו פותרים את הבעיה שלנו
רוצה עיקרי להיות בחלק העליון, אבל

1488
01:14:29,950 --> 01:14:33,750
פונקציות שאנחנו רוצים, אנחנו רוצים אותם
להיות מתחת עיקרי עדיין תוכל להשתמש

1489
01:14:33,750 --> 01:14:34,930
אותם בתוך עיקרי?

1490
01:14:34,930 --> 01:14:36,870
>> ובכן, אנחנו משתמשים במה שאנו מכנים
אב טיפוס פונקציה.

1491
01:14:36,870 --> 01:14:40,830
אז מה בעצם אב טיפוס פונקציה
הוא שזה לוקח את מה שראשון

1492
01:14:40,830 --> 01:14:45,060
החתימה או כותרת הפונקציה
ממה שאנחנו רוצים ליישם את

1493
01:14:45,060 --> 01:14:47,420
כאן, ואנחנו שמים את זה ב
החלק העליון של תכנית.

1494
01:14:47,420 --> 01:14:51,400
>> אז במקרה הזה, אנו אומרים כי, טובים,
מאוחר יותר בתכנית שלנו, אנחנו הולכים

1495
01:14:51,400 --> 01:14:55,010
כדי להפוך את ההבטחה ליישם את זה
פונקציה שנקראת קוביית int, אשר לוקחת

1496
01:14:55,010 --> 01:14:56,260
קלט מספר שלם.

1497
01:14:56,260 --> 01:15:00,870
אז עכשיו, בגלל שהוא מעל עיקרי,
עיקרי, זה הולך לומר, נו, טוב,

1498
01:15:00,870 --> 01:15:03,910
מאוחר יותר בתכנית, שהולך להיות
יש כל כך שאני יכול להתייחס אליו, אז אני

1499
01:15:03,910 --> 01:15:05,230
פשוט תנו לזה לעבור לעת עתה.

1500
01:15:05,230 --> 01:15:07,660
>> ולאחר מכן בתחתית,
אנו ליישם קובייה.

1501
01:15:07,660 --> 01:15:11,180
ואז ראשי יהיה פשוט לומר,
טוב, זה יהיה למיין של קישור

1502
01:15:11,180 --> 01:15:12,250
שני הסמלים האלה ביחד.

1503
01:15:12,250 --> 01:15:14,320
ואנו לכסות את מה ש
משמעות בהמשך.

1504
01:15:14,320 --> 01:15:17,090
וכך תדע שזה הוא
פונקצית קובייה שהוא צריך להשתמש.

1505
01:15:17,090 --> 01:15:19,630

1506
01:15:19,630 --> 01:15:23,383
>> ROB: [לא ברור] על רצון
עיקרי בתחתית או

1507
01:15:23,383 --> 01:15:24,880
עליון, ראיתי את שניהם.

1508
01:15:24,880 --> 01:15:28,630
יש דברים שפשוט אוהבים
לשים ראשי בתחתית.

1509
01:15:28,630 --> 01:15:32,520
אבל ברגע שפרויקט מקבל במיוחד
גדול, בדרך כלל עיקרי הוא ב

1510
01:15:32,520 --> 01:15:34,290
קובץ כולו שלו.

1511
01:15:34,290 --> 01:15:38,170
ובנקודה זו, כמו
שורת קוביית int היית -

1512
01:15:38,170 --> 01:15:42,460
בתוך stdio.h הן חבורה
קווים בדיוק כמו int כי

1513
01:15:42,460 --> 01:15:44,010
שורת קלט int הקובייה.

1514
01:15:44,010 --> 01:15:50,170
>> וכך אב טיפוס אלה הם דברים שאתה
נוטה לשים לקבצי כותרת, ב

1515
01:15:50,170 --> 01:15:52,140
ונקודה, זה לא משנה.

1516
01:15:52,140 --> 01:15:54,700
ובכן, זה לא משנה.

1517
01:15:54,700 --> 01:15:56,070
אלה תמיד הולכים בראש.

1518
01:15:56,070 --> 01:15:59,490
ואם עיקרי הוא לא קובץ כולו שלו,
אתה לא צריך לדאוג לשים

1519
01:15:59,490 --> 01:16:02,360
אבות טיפוס לפונקציות בודדים
בקובץ.

1520
01:16:02,360 --> 01:16:05,370
>> יוסף: ואנחנו נגיע לזה קצת
קצת מאוחר יותר, כאשר רוב מתחיל לדבר

1521
01:16:05,370 --> 01:16:06,380
על העריכה.

1522
01:16:06,380 --> 01:16:09,480
וכך יש גם הבדל
בין פרמטר וויכוח.

1523
01:16:09,480 --> 01:16:12,500
ופרמטר הוא בדיוק מה
אנחנו קוראים לתשומות אלה כאשר

1524
01:16:12,500 --> 01:16:13,820
אנו מגדירים את הפונקציה.

1525
01:16:13,820 --> 01:16:16,950
ואנחנו קוראים לזה טיעון כאשר אנו
למעשה להעביר אותו לפונקציה.

1526
01:16:16,950 --> 01:16:19,600
>> אז במקרה הזה, מדובר בפרמטר,
כפי שאמרנו קודם.

1527
01:16:19,600 --> 01:16:24,130
וכאשר אנו למעשה להשתמש בו לשם,
קובייה של x, אז x עצמו הוא

1528
01:16:24,130 --> 01:16:25,910
מה שאנו מכנים טיעון
לקוביית הפונקציה.

1529
01:16:25,910 --> 01:16:28,150
>> ROB: אז את טענותיו של הפרמטר הן -

1530
01:16:28,150 --> 01:16:33,270
יש הבחנה זו, מאוד
מבולבל לסירוגין.

1531
01:16:33,270 --> 01:16:37,090
בשלב זה, לי, זה כמו אחד
המילים האלה, שכשאני רואה את זה ב

1532
01:16:37,090 --> 01:16:41,190
פרא, אני לא יכול לעזור, אבל באופן מיידי
שאלה אם הם משתמשים בו ב

1533
01:16:41,190 --> 01:16:44,120
ההקשר הנכון, כי
ההבדל הוא דק מספיק, כי רק

1534
01:16:44,120 --> 01:16:45,500
כולם נוטה -

1535
01:16:45,500 --> 01:16:48,530
כמעט תמיד אני אומר טיעון
בלי קשר למה אני מתכוון.

1536
01:16:48,530 --> 01:16:51,230

1537
01:16:51,230 --> 01:16:54,630
>> יוסף: ופונקציות שימושיות גם
למה שאנו מכנים תופעות לוואי.

1538
01:16:54,630 --> 01:16:59,230
אז פונקציה יכולה לקחת לא תשומות, ו
זה גם יכול לייצר שום פלטים.

1539
01:16:59,230 --> 01:17:03,280
אז במקרה הספציפי הזה, אני
הגדרת שגרה שאין לי

1540
01:17:03,280 --> 01:17:03,970
להחזיר ערך.

1541
01:17:03,970 --> 01:17:07,730
וכדי לציין את זה, אנו משתמשים
מה שאנו מכנים חלל לכאן.

1542
01:17:07,730 --> 01:17:10,890
וכך תופעת הלוואי של פונקציה זו
הוא שזה פשוט מדפיס דברים

1543
01:17:10,890 --> 01:17:11,920
לדף.

1544
01:17:11,920 --> 01:17:13,840
זה לא ממש לקחת כל
תשומות, וזה לא

1545
01:17:13,840 --> 01:17:15,360
למעשה לייצר כל תפוקות.

1546
01:17:15,360 --> 01:17:18,230
>> אבל זה יכול להיות שימושי במובן
אם אתה רוצה, למשל, ניפוי שגיאות

1547
01:17:18,230 --> 01:17:21,530
משהו בתכנית שלך, אם אתה רוצה
לכתוב קצת שגרה כי

1548
01:17:21,530 --> 01:17:25,160
מדפיס את, נניח, את התוכן
של זיכרון או משהו.

1549
01:17:25,160 --> 01:17:29,800
וכן תופעות לוואי אלה הן לפעמים
שימושי מחוץ להקשר

1550
01:17:29,800 --> 01:17:33,010
רק רוצה כניסות ויציאות.

1551
01:17:33,010 --> 01:17:34,260
כל שאלה?

1552
01:17:34,260 --> 01:17:37,270

1553
01:17:37,270 --> 01:17:44,240
>> ולסיום קטע המסוים הזה,
מה התכנית הזו עושה?

1554
01:17:44,240 --> 01:17:47,420
אני אתן לך חבר 'ה כמה
שניות לקרוא את זה.

1555
01:17:47,420 --> 01:17:52,720

1556
01:17:52,720 --> 01:17:56,880
ברמה בסיסית מאוד, מה שאנחנו רוצים
לומר הוא שזה מחליף x ו-y, נכון?

1557
01:17:56,880 --> 01:18:00,090
>> אז כמה מכם באמת חושב
זה יהיה להחליף x ו-y?

1558
01:18:00,090 --> 01:18:02,160
הרם את ידך.

1559
01:18:02,160 --> 01:18:02,760
אף אחד.

1560
01:18:02,760 --> 01:18:03,070
על אישור.

1561
01:18:03,070 --> 01:18:06,720
מי שחושב שזה יהיה
לא להחליף x ו-y?

1562
01:18:06,720 --> 01:18:09,120
וסכום שהיה
לא את כל החדר.

1563
01:18:09,120 --> 01:18:10,440
אז יש אנשים שהם לא בטוחים.

1564
01:18:10,440 --> 01:18:10,920
על אישור.

1565
01:18:10,920 --> 01:18:11,630
זה סביר.

1566
01:18:11,630 --> 01:18:16,450
>> אז בואו לעבור את מה שקורה כאשר
אתה בעצם קורא לפונקציות הראשונות ב

1567
01:18:16,450 --> 01:18:18,320
כדי לענות על שאלה זו.

1568
01:18:18,320 --> 01:18:21,430
אז זה מה שזיכרון
סוג של נראה.

1569
01:18:21,430 --> 01:18:23,860
זה כמו סוג של מודל פשוט
של מה שנראה כמו זיכרון כאשר

1570
01:18:23,860 --> 01:18:24,800
אתה מפעיל את תכנית.

1571
01:18:24,800 --> 01:18:27,270
אז יש משהו שנקרא
הערימה כאן למטה ו

1572
01:18:27,270 --> 01:18:28,330
משהו שנקרא הערימה.

1573
01:18:28,330 --> 01:18:30,950
ולגדול אלה כלפי
האמצע של זיכרון.

1574
01:18:30,950 --> 01:18:33,860
>> אז במקרה הספציפי הזה, כש
אתה קורא לפונקציה, היא

1575
01:18:33,860 --> 01:18:35,680
מקבל לשים על הערימה.

1576
01:18:35,680 --> 01:18:38,900
ואז כל מה שכלול בזה
פונקציה נשארת במה שאנחנו קוראים לזה

1577
01:18:38,900 --> 01:18:40,550
מסגרת המחסנית של הפונקציה.

1578
01:18:40,550 --> 01:18:44,500
ולכן כדי לקבל הדמיה יפה של
זה, בואי - למשל, היה לנו

1579
01:18:44,500 --> 01:18:45,960
עיקרי תכנית קודם לכן.

1580
01:18:45,960 --> 01:18:47,820
ובתוך ראשיים, שקראנו קובייה.

1581
01:18:47,820 --> 01:18:50,650
אז עיקרי היינו הולך ראשון במחסנית
מסגרת, כי זה הפונקציה הראשונה

1582
01:18:50,650 --> 01:18:51,640
זה נקרא.

1583
01:18:51,640 --> 01:18:55,740
>> ולאחר מכן, כאשר הקובייה נקראת פנימית של
עיקרי, הוא מקבל לשים על גבי עיקרי

1584
01:18:55,740 --> 01:18:57,790
בתוך הזיכרון.

1585
01:18:57,790 --> 01:19:02,090
אז מה תוכל להבחין כאן הוא קובייה ש
יש פרמטרים משלו ושלה

1586
01:19:02,090 --> 01:19:02,950
המקומיים עצמו.

1587
01:19:02,950 --> 01:19:06,720
לכן, כאשר אתה באמת עובר משהו
פונקציה, הפרמטרים שהיא

1588
01:19:06,720 --> 01:19:09,910
מקבל הם עותקים של מה שהיה
עבר מראשי.

1589
01:19:09,910 --> 01:19:14,140
>> וכדי להסביר סוג של זה, בוא
ללכת דרך תכנית.

1590
01:19:14,140 --> 01:19:16,960
אז יש לנו את הערימה, זה
רק את חלק המחסנית.

1591
01:19:16,960 --> 01:19:21,240
ומה שאנו עושים זה לאתחל ראשון
x ו-y לאחד ושתיים.

1592
01:19:21,240 --> 01:19:22,400
אז יש לנו קופסות קטנות האלה.

1593
01:19:22,400 --> 01:19:25,310
הם יושבים בערימה של עיקרי
למסגר בערימה.

1594
01:19:25,310 --> 01:19:26,580
הם מכילים אחד ושניים.

1595
01:19:26,580 --> 01:19:28,820
>> עכשיו אנחנו קוראים להחלפה.

1596
01:19:28,820 --> 01:19:33,940
מה שקורה הוא שאנחנו עוברים x ו-y ל
החלפה, והחלפה יוצרים עותקים שלו

1597
01:19:33,940 --> 01:19:36,520
של משתנים אלו לשימוש בתוך
של מסגרת הערימה שלה.

1598
01:19:36,520 --> 01:19:39,920
אז עכשיו לשם, יש לנו, אשר
מכיל את הערך שהיה לי x; ו-B,

1599
01:19:39,920 --> 01:19:41,620
שמכיל את הערך שהיה לי y.

1600
01:19:41,620 --> 01:19:42,670
אז אחד, שתיים.

1601
01:19:42,670 --> 01:19:47,130
>> ותשים לב שזה הוא נפרד
מx ו-y בתוך ראשי.

1602
01:19:47,130 --> 01:19:51,390
אז עכשיו אנחנו יוצרים זמניים
משתנה להכיל.

1603
01:19:51,390 --> 01:19:56,100
אנו קובעים שווים ל-B, ולכן
שינויים מאחת לשתיים.

1604
01:19:56,100 --> 01:19:59,340
ולאחר מכן הקמנו B שווה
לטמפ ', שהוא אחד.

1605
01:19:59,340 --> 01:20:01,640
>> ואז עכשיו אנחנו יוצאים החוצה
של פונקציה זו.

1606
01:20:01,640 --> 01:20:04,310

1607
01:20:04,310 --> 01:20:07,410
כשאתה יוצא מחוץ לפונקציה,
מסגרת מחסנית מקבלת התפגרה הערימה.

1608
01:20:07,410 --> 01:20:08,270
אנחנו קוראים לזה לדחוף.

1609
01:20:08,270 --> 01:20:12,750
אתה דוחף את מסגרת מחסנית על המחסנית
ואתה קופץ אם את המחסנית.

1610
01:20:12,750 --> 01:20:16,080
ואז מה שקורה הוא שכל מה ש
היה שבסוג מסגרת ערימת רק

1611
01:20:16,080 --> 01:20:17,280
עולה בלהבות.

1612
01:20:17,280 --> 01:20:19,180
וכדי שכבר לא קיים.

1613
01:20:19,180 --> 01:20:20,470
>> אבל מה שאנחנו שמים לב?

1614
01:20:20,470 --> 01:20:23,690
אנחנו אף פעם לא באמת השתנו
ערכים של x ו-y, נכון?

1615
01:20:23,690 --> 01:20:26,530
אז מי נשאר מקומי לראשי.

1616
01:20:26,530 --> 01:20:29,900
ועל ידי העברת דברים להחלפה, אנחנו
למעשה מעולם לא שינה את הערכים האלה.

1617
01:20:29,900 --> 01:20:31,260
ומה שאנחנו קוראים לזה?

1618
01:20:31,260 --> 01:20:33,040
אנחנו קוראים לפטירתו זאת על ידי ערך.

1619
01:20:33,040 --> 01:20:36,860
>> אז ב-C, כאשר אתה עובר דברים לתוך
פונקציות, הוא עובר אותם לפי ערך ו

1620
01:20:36,860 --> 01:20:40,160
יוצר עותק של אותם עבור
הפונקציה לשימוש.

1621
01:20:40,160 --> 01:20:43,980
ואנחנו תלמדו על משהו שנקרא
עובר על ידי עיון מאוחר יותר, אבל זה

1622
01:20:43,980 --> 01:20:45,390
דרך בה אתה יכול לפתור את הבעיה הזו.

1623
01:20:45,390 --> 01:20:47,080
אבל אנחנו לא לדאוג
כי רק מאוחר יותר.

1624
01:20:47,080 --> 01:20:52,200
>> רוב: ולמעשה, מונח זה, דרך אגב
על ידי התייחסות, אפילו לא צריך כל כך C

1625
01:20:52,200 --> 01:20:54,270
עובר על ידי התייחסות.

1626
01:20:54,270 --> 01:20:56,760
C באופן בלעדי כבר עובר ליד ערך.

1627
01:20:56,760 --> 01:20:59,630
לא משנה מה אתה עושה, אתה תמיד
עובר העתק של משהו.

1628
01:20:59,630 --> 01:21:03,395
זה בדיוק את זה, כמו שאני סוג של הזכיר
כי לפני שעם מצביעים

1629
01:21:03,395 --> 01:21:07,690
ושמחרוזת היא באמת רק ארבעה
ביטים והצביעו על מקום בזיכרון.

1630
01:21:07,690 --> 01:21:11,890
>> ובכן, אם יש לי מחרוזת זו וזה
אומר לי שהמקום שבו המחרוזת -

1631
01:21:11,890 --> 01:21:15,470
טוב, אם יש לי מצביע זה לזה
מקום בזיכרון, ואז אני יכול לעבור

1632
01:21:15,470 --> 01:21:19,160
עותק של מצביע שלפונקציה, ו
פונקציה שעדיין לא יודעת איפה ב

1633
01:21:19,160 --> 01:21:19,780
זיכרון זה.

1634
01:21:19,780 --> 01:21:22,950
אז שניהם של מצביעים אלה מצביעים
לאותו המקום בזיכרון, ו

1635
01:21:22,950 --> 01:21:26,460
ככה אנחנו הולכים להיות מסוגלים
כדי לשנות את הדברים שמעבר

1636
01:21:26,460 --> 01:21:29,852
מסגרת מחסנית נוכחית.

1637
01:21:29,852 --> 01:21:31,040
>> יוסף: האם אתה רוצה לעשות קומפילציה?

1638
01:21:31,040 --> 01:21:31,820
>> רוב: לא, זה 5:30.

1639
01:21:31,820 --> 01:21:32,910
>> יוסף: על אישור.

1640
01:21:32,910 --> 01:21:35,040
זה 5:30.

1641
01:21:35,040 --> 01:21:35,360
על אישור.

1642
01:21:35,360 --> 01:21:39,280
אז אנחנו יכסו קומפילציה אני מניח ב
בסעיף הבא, או בסעיף שלך

1643
01:21:39,280 --> 01:21:42,795
מנהיג יהיה בשלב זה.

1644
01:21:42,795 --> 01:21:43,272
ו--

1645
01:21:43,272 --> 01:21:44,630
>> רוב: יש שאלות?

1646
01:21:44,630 --> 01:21:46,760
>> יוסף: יש שאלות?

1647
01:21:46,760 --> 01:21:47,150
כן?

1648
01:21:47,150 --> 01:21:52,469
>> SPEAKER 5: שימוש במחרוזות מCS50, כל
פונקציות שאנחנו רוצים להשתמש עבור

1649
01:21:52,469 --> 01:21:53,880
אלה, שנהיה כמו פונקציות C.

1650
01:21:53,880 --> 01:21:59,050
CS50 לא נעלם וב
עשה כל נוסף.

1651
01:21:59,050 --> 01:22:01,850
>> ROB: נכון.

1652
01:22:01,850 --> 01:22:08,155
כל אחד מC כמו [לא ברור], אתה
ישתמש באלה על המיתרים שלנו.

1653
01:22:08,155 --> 01:22:12,400
>> יוסף: ועוד דבר אחד אחרון שאני רוצה
להזכיר הוא שיש לנו מדריך סגנון

1654
01:22:12,400 --> 01:22:13,130
למעמד הזה.

1655
01:22:13,130 --> 01:22:13,360
>> ROB: הו, כן.

1656
01:22:13,360 --> 01:22:15,270
>> יוסף: אז אם אתה כבר בא
תכנות רקע לפני, אתה

1657
01:22:15,270 --> 01:22:17,750
אולי יש מוסכמות מסוימות כאשר
אתה כותב קוד כמו לשים

1658
01:22:17,750 --> 01:22:20,950
פלטה באותה השורה או מסוימת
דרכים של זחה

1659
01:22:20,950 --> 01:22:22,240
או שמות המשתנים שלך.

1660
01:22:22,240 --> 01:22:26,870
במעמד הזה, אנחנו רוצים לעקוב
מדריך לסגנון מסוים רק בגלל,

1661
01:22:26,870 --> 01:22:31,100
ובכן, אם אתה יוצא לעבוד ב
בתעשייה, אתה הולך להיות צפוי

1662
01:22:31,100 --> 01:22:34,780
כדי לבצע את מדריך הסגנון של
חברה שבה אתה הולך.

1663
01:22:34,780 --> 01:22:38,040
>> כמו למשל, אני חושב שפייסבוק
יש סוג מסוים של שמות

1664
01:22:38,040 --> 01:22:38,760
אמנה.

1665
01:22:38,760 --> 01:22:42,570
ויש הבדלים בין הגמלים
משתני מעטפת ובדיוק כמו

1666
01:22:42,570 --> 01:22:44,610
מפריד אותם עם קו תחתון.

1667
01:22:44,610 --> 01:22:52,170
וגם, אני חושב שהכי חשוב, כמו
לדוגמא, כניסה, נכון?

1668
01:22:52,170 --> 01:22:56,440
>> אנו סוגריים מסולסלים מתחילים בי
התנאי הוא, והם

1669
01:22:56,440 --> 01:22:57,730
הם בשורה הבאה.

1670
01:22:57,730 --> 01:23:01,230
ואנחנו גם לשים סוגריים מסולסלים ב
אפילו אם זה רק שורה אחת.

1671
01:23:01,230 --> 01:23:06,100
והרבה פעמים, יש דרכים לעשות
זה שבו אתה יכול להשאיר את הפלטה אלה

1672
01:23:06,100 --> 01:23:08,380
את אם זה רק שורה אחת
תחת ההצהרה אם.

1673
01:23:08,380 --> 01:23:12,070
אבל במעמד הזה, אנחנו רוצים לעקוב
מדריך לסגנון מסוים רק כדי שתקבל

1674
01:23:12,070 --> 01:23:13,550
משמש לדברים מהסוג הזה.

1675
01:23:13,550 --> 01:23:16,410
>> ROB: כן, ו50 סגנון הולך
לאכוף מדריך הסגנון הזה, ואנחנו

1676
01:23:16,410 --> 01:23:18,080
הולך להשתמש בסגנון 50
לקוד שלך בכיתה.

1677
01:23:18,080 --> 01:23:25,150
אז זה עושה את הדברים קלים יותר עבורנו ו
אני מקווה שלא צריך לעשות דברים ש

1678
01:23:25,150 --> 01:23:30,120
הרבה יותר גרוע בשבילך נתת
סגנון סטנדרטי לא צריך להיות כי

1679
01:23:30,120 --> 01:23:31,460
לא מציאותי.

1680
01:23:31,460 --> 01:23:36,000
>> יוסף: ולבסוף, כדי למצוא את הסגנון
מדריך, ללכת לmanual.cs50.net/style.

1681
01:23:36,000 --> 01:23:37,725
וכן.

1682
01:23:37,725 --> 01:23:40,575
>> 4 SPEAKER: האם אתה הולך לאכיפה
כל תווים בכל שורה?

1683
01:23:40,575 --> 01:23:42,480
>> ROB: כן.

1684
01:23:42,480 --> 01:23:45,405
>> יוסף: מצטער, חבר 'ה.

1685
01:23:45,405 --> 01:23:47,680
>> רוב: זה כמו אחד מהיחידים.

1686
01:23:47,680 --> 01:23:50,420
בשלב זה, אני בסדר עם 120.

1687
01:23:50,420 --> 01:23:52,460
אני בסדר עם אומר 120
תווים בכל שורה.

1688
01:23:52,460 --> 01:23:53,830
אני מבין שיש להיות גבול מסוים.

1689
01:23:53,830 --> 01:23:57,130
אני חושב 80 הוא כל כך קטן, אבל
אנחנו אוכפים את זה.

1690
01:23:57,130 --> 01:24:00,260
>> יוסף: באופן אישי, אני חושב שעם
C, 80 תווים הוא בסדר יותר.

1691
01:24:00,260 --> 01:24:04,160
ברגע שאתה מתחיל לקבל לאחר
שפות כמו JavaScript ו-PHP, לא

1692
01:24:04,160 --> 01:24:08,860
כך סביר רק כדי להגביל את
זה 80 תווים.

1693
01:24:08,860 --> 01:24:09,260
על אישור.

1694
01:24:09,260 --> 01:24:12,780
ובכן, זה היה הקטע סופר.

1695
01:24:12,780 --> 01:24:14,750
האם מישהו רוצה ממתק?

1696
01:24:14,750 --> 01:24:16,000
>> 4 SPEAKER: כן.

1697
01:24:16,000 --> 01:24:18,667