1
00:00:00,000 --> 00:00:05,140

2
00:00:05,140 --> 00:00:05,640
בסדר.

3
00:00:05,640 --> 00:00:08,330
אז עכשיו בואו נדבר על משהו
באמת שימושי בprogramming--

4
00:00:08,330 --> 00:00:09,914
הצהרות מותנות.

5
00:00:09,914 --> 00:00:11,830
ביטויים אז מותנים
מאפשר לתוכניות שלך

6
00:00:11,830 --> 00:00:14,538
לקבל החלטות ולקחת שונה
מזלגות בכביש, משהו

7
00:00:14,538 --> 00:00:17,670
רמזתי לקצת יותר מוקדם,
בהתאם לערכים של משתנים,

8
00:00:17,670 --> 00:00:20,990
או על סמך מה תשומות המשתמש ב
מתכנת, בשורת הפקודה,

9
00:00:20,990 --> 00:00:23,130
או אם יש לך הפקודה
או משהו כזה.

10
00:00:23,130 --> 00:00:26,690
יש C כמה דרכים שונות ל
להביע את ביטויי תנאי, ש

11
00:00:26,690 --> 00:00:29,911
גם אנחנו לפעמים קוראים
סניף מותנה בתוכניות שלך.

12
00:00:29,911 --> 00:00:32,910
וחלק מאלה הולכים להסתכל
די מוכר לך מהתחלה,

13
00:00:32,910 --> 00:00:35,190
כדי שאפילו למשוך אותם
עד לצד זה, רק

14
00:00:35,190 --> 00:00:38,170
אתה יכול לעשות את האנלוגיה שבראש שלך.

15
00:00:38,170 --> 00:00:41,250
>> אז, אם if-- הוא די
פשוט מותנה.

16
00:00:41,250 --> 00:00:43,560
אם אתה זוכר מ
שריטה על הזכות כאן

17
00:00:43,560 --> 00:00:50,000
אתה יכול למלא שבהיא משושה
עם ביטוי כחול אם עכבר למטה

18
00:00:50,000 --> 00:00:53,010
או אם x הוא פחות מ -10,
או משהו כזה.

19
00:00:53,010 --> 00:00:57,390
ולאחר מכן, אם x היה פחות מ -10,
או אם העכבר היה בעובדה, במורד,

20
00:00:57,390 --> 00:01:01,140
כל הקוד הפנימי של
פיסת הפאזל הייתה לבצע.

21
00:01:01,140 --> 00:01:03,720
כל הדברים שמתאימים
בתוך שצורת C.

22
00:01:03,720 --> 00:01:07,200
>> כמו כן, יש לנו
אם בצד השמאל יש.

23
00:01:07,200 --> 00:01:09,210
אם ביטוי בוליאני,
שאני רק משתמש

24
00:01:09,210 --> 00:01:13,010
כתחליף לאחד בוליאנית
ביטויים שהוסברנו קודם לכן,

25
00:01:13,010 --> 00:01:15,240
סד פתוח מתולתל, מסולסל סד קרוב.

26
00:01:15,240 --> 00:01:17,720
אז לחשוב על מתולתל פתוחים
סד וסד מתולתל סגור

27
00:01:17,720 --> 00:01:22,720
כסוג של אנלוגי לכריך
השפעה של אם הבלוק בצד הימין

28
00:01:22,720 --> 00:01:24,070
מאפס.

29
00:01:24,070 --> 00:01:28,680
>> אם ביטוי בוליאני
באם הטענה נכונה,

30
00:01:28,680 --> 00:01:30,900
אז כל השורות של קוד
בין הסוגריים המסולסלים

31
00:01:30,900 --> 00:01:33,870
יבצע על מנת
מלמעלה למטה.

32
00:01:33,870 --> 00:01:35,700
אם ביטוי בוליאני
הוא שקר, אנחנו

33
00:01:35,700 --> 00:01:38,610
לדלג על מה שביניהם
הסוגריים המסולסלים, כי אנחנו היחידים

34
00:01:38,610 --> 00:01:44,570
רוצה ללכת את מזלג שבכביש
אם ביטוי בוליאני הוא אמיתי.

35
00:01:44,570 --> 00:01:48,540
>> אנחנו יכולים לקחת את זה צעד אחד
נוסף עם אם אחר.

36
00:01:48,540 --> 00:01:50,820
אז בלוק Scratch זה
די דומה לזה

37
00:01:50,820 --> 00:01:55,884
ראינו רק לפני שנייה, למעט
זה לוקח שני נתיבים שונים המבוססים

38
00:01:55,884 --> 00:01:56,550
על מה שקורה.

39
00:01:56,550 --> 00:02:00,420
אז אם העכבר היה למטה,
או אם x היה פחות מ -10,

40
00:02:00,420 --> 00:02:04,780
אנחנו נעשה כל מה שביניהם
שהמזלג הראשון, שג הראשון,

41
00:02:04,780 --> 00:02:08,430
>> אחרת, אם העכבר הוא
עד, או x הוא לא פחות מ -10,

42
00:02:08,430 --> 00:02:10,460
נעשינו הכל במערכה השנייה.

43
00:02:10,460 --> 00:02:15,010
וזה דומה למה שאתה רואה
כאן לביטוי ג אם בוליאנית,

44
00:02:15,010 --> 00:02:17,910
לעשות את הדברים בין
הסט הראשון של סוגריים מסולסלים.

45
00:02:17,910 --> 00:02:20,550
אחר, לעשות את הדברים בין
שני קבוצה של סוגריים מסולסלים.

46
00:02:20,550 --> 00:02:22,080
אז אם בוליאנית
הביטוי נכון, אנחנו

47
00:02:22,080 --> 00:02:23,580
תעשה כל מה שבין הסט הראשון.

48
00:02:23,580 --> 00:02:27,480
אם ביטוי בוליאני הוא
שווא, שיפעיל אחר,

49
00:02:27,480 --> 00:02:30,100
ואנחנו אעשה כל מה של ב
הסט השני של סוגריים מסולסלים.

50
00:02:30,100 --> 00:02:34,190
שוב, מלמעלה למטה, כל
קווים בין הפלטה.

51
00:02:34,190 --> 00:02:38,130
>> ב C, זה אפשרי ליצור
אם-אחר שרשרת אם-אחר.

52
00:02:38,130 --> 00:02:42,000
למעשה אתה יכול לקבל-אחר אם אם-אחר
אם-אחר, אם, וכן הלאה וכן הלאה וכן

53
00:02:42,000 --> 00:02:42,720
על.

54
00:02:42,720 --> 00:02:44,660
בסריטות, זה נדרש
קינון בלוקים.

55
00:02:44,660 --> 00:02:48,280
אתה מוסיף עוד אם-, והיה לך ל
לשים עוד אחד בתוך אחר,

56
00:02:48,280 --> 00:02:51,110
וכן הלאה, וזה קיבל סוג
של מקונן ומסובך.

57
00:02:51,110 --> 00:02:52,450
אבל C, אנחנו לא צריכים לעשות את זה.

58
00:02:52,450 --> 00:02:55,300
יכול למעשה רק לנו
זה יהיה שרשרת כמו זה.

59
00:02:55,300 --> 00:02:58,350
שוב, כמו שהיית מצפה, כל
סניפים אלה הם סותרים.

60
00:02:58,350 --> 00:03:00,750
אתה היחיד שיכול ללכת
את אחד מהסניף.

61
00:03:00,750 --> 00:03:02,270
אם זה נכון.

62
00:03:02,270 --> 00:03:03,930
אחרת, אם זה נכון.

63
00:03:03,930 --> 00:03:05,700
אחרת, אם זה נכון.

64
00:03:05,700 --> 00:03:07,120
אחרת, לעשות את זה.

65
00:03:07,120 --> 00:03:11,010
אז כל ארבעת הסניפים בזה
דוגמא היא סותרות.

66
00:03:11,010 --> 00:03:14,900
זה שרשרת אם-אחר אם-אחרת.

67
00:03:14,900 --> 00:03:17,580
>> למרות שזה אפשרי,
ולפעמים מאוד שימושי,

68
00:03:17,580 --> 00:03:20,950
ליצור שרשרת של לא
סניפים סותרים.

69
00:03:20,950 --> 00:03:24,600
בדוגמא זו, ושלישית רק
הסניפים רביעי הם סותרים.

70
00:03:24,600 --> 00:03:27,450
יכול להיות שאתה יכול
לספק את התנאי הראשון,

71
00:03:27,450 --> 00:03:29,396
ואתה יכול לספק
התנאי השני,

72
00:03:29,396 --> 00:03:31,770
ואתה יכול לספק את
condition-- השלישי ובמקרה

73
00:03:31,770 --> 00:03:35,270
היית יורד הסניף הראשון,
אז אתה יורד סניף שני,

74
00:03:35,270 --> 00:03:37,000
אז היית יורד סניף השלישי.

75
00:03:37,000 --> 00:03:40,450
או אולי אתה לספק ראשון
מצב, והתנאי השני,

76
00:03:40,450 --> 00:03:42,770
אבל אתה לא לספק
התנאי השלישי.

77
00:03:42,770 --> 00:03:46,230
במקרה זה אתה יורד הראשון
סניף והסניף השני,

78
00:03:46,230 --> 00:03:48,040
ולאחר מכן את הסניף הרביעי,

79
00:03:48,040 --> 00:03:51,392
>> הסיבה לכך היא שאחר
רק להיקשר הקרוב אם.

80
00:03:51,392 --> 00:03:53,100
אז למרות שיש
אחר כאן, ש

81
00:03:53,100 --> 00:03:56,490
לא בהכרח ליצור הדדי
שרשרת בלעדית של כל דבר.

82
00:03:56,490 --> 00:04:00,890
זה רק הביטוי
יש עם וליאנית

83
00:04:00,890 --> 00:04:05,040
ביטוי 3-- זה
סותרים עם אחר.

84
00:04:05,040 --> 00:04:07,580
אז זה אפשרי, ו
לפעמים די שימושי,

85
00:04:07,580 --> 00:04:11,772
כפי שאמרתי, כדי ליצור שרשרת של
סניפים אינם סותרים.

86
00:04:11,772 --> 00:04:14,230
בואו נסתכל שונה
סוג של מותנה, ש

87
00:04:14,230 --> 00:04:17,392
שלא ראה לפני בגרד.

88
00:04:17,392 --> 00:04:19,369
יש משהו שנקרא
ההצהרה הבורר.

89
00:04:19,369 --> 00:04:21,410
ההצהרה הבורר היא
סוג של מסודר כי זה

90
00:04:21,410 --> 00:04:25,930
משפט תנאי המאפשר
לך לציין מקרים שונים,

91
00:04:25,930 --> 00:04:28,926
במקום להסתמך על וליאנית
ביטויים לקבל החלטות בשבילך.

92
00:04:28,926 --> 00:04:31,050
כך למשל, נניח ש
שיש לי בתכנית זו,

93
00:04:31,050 --> 00:04:34,110
ואני שואל את המשתמש
לספק קלט לי.

94
00:04:34,110 --> 00:04:37,170
אז אני אומר, int x = קבל Int (),
ואם אתה לא מכיר עדיין,

95
00:04:37,170 --> 00:04:40,190
לקבל int הוא פונקציה שהיא
גם כלול בספריית CS50,

96
00:04:40,190 --> 00:04:44,610
כך שאם אתה #include CS50.H יהיה לך
גישה למקבלת Int () וכולה

97
00:04:44,610 --> 00:04:46,840
cousins-- GetFloat,
GetString, וכן הלאה.

98
00:04:46,840 --> 00:04:52,590
בעיקרון אחד קבל פונקציה לכל
סוג הנתונים שיש לנו כבר דן.

99
00:04:52,590 --> 00:04:53,970
>> אז x Int שווה GetInt.

100
00:04:53,970 --> 00:04:56,390
בעיקרון מה שקורה
הוא אני במסוף.

101
00:04:56,390 --> 00:04:58,790
אני מבקש מהמשתמש להקליד מספר.

102
00:04:58,790 --> 00:05:02,300
>> וכאן אני עובר
מה שאני עושה, בהתאם

103
00:05:02,300 --> 00:05:05,060
על מה שהמשתמש הקליד בשורת.

104
00:05:05,060 --> 00:05:09,147
אז אם הם הקלידו אחד, אני להדפיס את אחד.

105
00:05:09,147 --> 00:05:09,855
ואז אני שובר.

106
00:05:09,855 --> 00:05:12,590

107
00:05:12,590 --> 00:05:15,510
אם הם להקליד שני, אני להדפיס את שתי.

108
00:05:15,510 --> 00:05:16,690
ואז אני שובר.

109
00:05:16,690 --> 00:05:19,060
זה חשוב ל
לשבור בין כל מקרה ומקרה

110
00:05:19,060 --> 00:05:20,890
כי אחרת אתה תיפול דרך.

111
00:05:20,890 --> 00:05:23,380
אז אם לא היה לי כל
הפסקות לשם, והמשתמש

112
00:05:23,380 --> 00:05:31,380
מוקלד אחד, מה היה קורה זה
היה להדפיס אחד, שתיים, שלוש, מצטער.

113
00:05:31,380 --> 00:05:33,099
זה סוג של התנהגות מוזרה, נכון?

114
00:05:33,099 --> 00:05:33,890
אתה עשוי לחשוב כך.

115
00:05:33,890 --> 00:05:36,480
אבל למעשה יש מקרים מסוימים שבי
זה יכול להיות דבר די שימושי.

116
00:05:36,480 --> 00:05:39,730
אז הנה דוגמא נוספת של מתג
הצהרה שבו אני להשמיט את ההפסקות.

117
00:05:39,730 --> 00:05:42,030
אבל אני עושה את זה בכוונה.

118
00:05:42,030 --> 00:05:43,030
>> אז מה קורה כאן?

119
00:05:43,030 --> 00:05:43,821
תחשוב לרגע.

120
00:05:43,821 --> 00:05:45,960
ייתכן גם רוצה להשהות את הווידאו.

121
00:05:45,960 --> 00:05:48,230
>> מה קורה כאן אם
סוגי המשתמשים ארבעה?

122
00:05:48,230 --> 00:05:51,190

123
00:05:51,190 --> 00:05:53,860
אז אני שאלתי את המשתמש לקלט.

124
00:05:53,860 --> 00:05:56,560
והם מספקים את הערך 4.

125
00:05:56,560 --> 00:05:59,545
מה יודפס כאשר אני עושה את זה?

126
00:05:59,545 --> 00:06:02,170
בשקופית הקודמת, היו
הפסקות בין כל המקרים.

127
00:06:02,170 --> 00:06:04,750
ואז זה פשוט היית
להדפיס ארבעה ואז להפסיק.

128
00:06:04,750 --> 00:06:06,610
אבל במקרה הזה, זה לא יהיה.

129
00:06:06,610 --> 00:06:10,700
מה שיקרה הוא ש
ייפול דרך כל מקרה.

130
00:06:10,700 --> 00:06:14,890
>> אז במקרה הזה אני כבר מאורגן מקרים שלי
באופן כזה שאם המשתמש מקליד 4,

131
00:06:14,890 --> 00:06:20,070
אני אדפיס ארבעה, שלוש,
שתיים, אחת, פיצוץ ב.

132
00:06:20,070 --> 00:06:22,780
ואם הם הקלידו 5, הייתי מתחיל
בחמש ולעשות את אותו דבר.

133
00:06:22,780 --> 00:06:26,410
אם הם הקלידו 1, הייתי
פשוט לעשות אחד, זינוק.

134
00:06:26,410 --> 00:06:28,715
>> אז במקרה הזה, אני משתמש ב
מתג סוג של חוכמה כל כך

135
00:06:28,715 --> 00:06:30,804
שאני מתכוון ליפול
בכל המקרים.

136
00:06:30,804 --> 00:06:33,720
אבל בדרך כלל אתה כנראה הולך
רוצה לשבור בין כולם,

137
00:06:33,720 --> 00:06:36,090
אלא אם כן יש לך מצב
כמו זה שבו אתה נמצא

138
00:06:36,090 --> 00:06:40,081
סוג של מינוף העובדה כי אתה
נופל דרך מקרים ללא הפסקה.

139
00:06:40,081 --> 00:06:42,830
אז זה השני של גדול
סוגי דוחות מותנים.

140
00:06:42,830 --> 00:06:47,139
האחרון שבן הוא:? אז
יש שני קטעי קוד C כאן.

141
00:06:47,139 --> 00:06:48,680
אחד בצד שמאל ואחד בצד הימין.

142
00:06:48,680 --> 00:06:52,330
אחד בצד השמאל צריך
כנראה יהיה די מוכר לך.

143
00:06:52,330 --> 00:06:55,110
>> יש לי x Int.

144
00:06:55,110 --> 00:06:57,167
ואני כנראה צריך
ביקש המשתמש

145
00:06:57,167 --> 00:07:00,250
for-- זה כנראה צריך להיות x Int
שווה GetInt, או משהו כזה.

146
00:07:00,250 --> 00:07:03,030

147
00:07:03,030 --> 00:07:05,240
ואז אני עושה את החלטה.

148
00:07:05,240 --> 00:07:11,700
אם חלק ביטוי בוליאני הוא
נכון, להקצות x הערך 5.

149
00:07:11,700 --> 00:07:13,590
אחרת, להקצות x הערך 6.

150
00:07:13,590 --> 00:07:16,548
>> כי בצד השמאל כנראה צריך להיות
מוכר למדי מהדיון שלנו

151
00:07:16,548 --> 00:07:18,160
של אם אחרת רק לפני רגע.

152
00:07:18,160 --> 00:07:20,535
האם אתה יכול להיות מופתע לדעת
כי הקו בצד הימין

153
00:07:20,535 --> 00:07:22,310
עושה בדיוק את אותו הדבר?

154
00:07:22,310 --> 00:07:26,140
>> אז זה נקרא:? או לפעמים
התקשר למרכזייה משולשת.

155
00:07:26,140 --> 00:07:27,450
וזה די מגניב.

156
00:07:27,450 --> 00:07:29,110
זה משמש בדרך כלל כטריק חמוד.

157
00:07:29,110 --> 00:07:35,777
>> אבל מה זה מאפשר לך לעשות הוא
לדמות אם אחר עם ממש קטן,

158
00:07:35,777 --> 00:07:37,610
באמת קצר trivially
סניפים מותנים.

159
00:07:37,610 --> 00:07:41,470
אתה בדרך כלל לא משתמש ב:? אם אתה
היו שש שורות של קוד בין כל סט

160
00:07:41,470 --> 00:07:42,569
פלטה של ​​מתולתלת.

161
00:07:42,569 --> 00:07:44,360
אבל אם אתה רק
קבלת החלטה מהירה,

162
00:07:44,360 --> 00:07:47,520
אם אתה הולך לעשות דבר אחד
או אחרים וזה מאוד פשוט,

163
00:07:47,520 --> 00:07:52,240
זה יכול להיות דוגמא לאופן ל
לעשות את זה עם:? מפעיל המשולש.

164
00:07:52,240 --> 00:07:56,940
אז x Int שווה ביטוי?

165
00:07:56,940 --> 00:07:59,470
הדבר לאחר השאלה
סימן ערך של מה x

166
00:07:59,470 --> 00:08:02,690
יהיה אם הביטוי נכון.

167
00:08:02,690 --> 00:08:05,330
>> הדבר לאחר
מעי גס הוא מה הערך של x

168
00:08:05,330 --> 00:08:07,990
יהיה אם הביטוי היה כוזב.

169
00:08:07,990 --> 00:08:11,510
אז אני שואל את עצמי,
הוא הביטוי אמיתי?

170
00:08:11,510 --> 00:08:13,870
אם זה הוא, להקצות x הערך 5.

171
00:08:13,870 --> 00:08:16,619
אם זה לא, להקצות x הערך 6.

172
00:08:16,619 --> 00:08:17,410
שוב, כמו שאמרתי.

173
00:08:17,410 --> 00:08:18,670
זה בדרך כלל רק טריק חמוד.

174
00:08:18,670 --> 00:08:20,430
ולפעמים, אם אתה הופך
באמת נוח עם זה,

175
00:08:20,430 --> 00:08:22,820
אתה עושה את זה כי זה נראה
סוג של מגניב בתוכניות שלך.

176
00:08:22,820 --> 00:08:25,710
בדרך כלל אני מציג אותו ל
עכשיו אתה כל כך אתה מכיר אותו

177
00:08:25,710 --> 00:08:26,990
אם אתה רואה את זה.

178
00:08:26,990 --> 00:08:30,080
אבל בהחלט יודע שאין לך
לכתוב את זה בכל הקוד שלך.

179
00:08:30,080 --> 00:08:33,246
אבל זה משהו שיכיר,
כי אתה בהחלט תיתקל

180
00:08:33,246 --> 00:08:36,130
קטעי קוד כאן ו
יש בו זה:? תחביר,

181
00:08:36,130 --> 00:08:39,120
AKA המפעיל המשולש, משמש.

182
00:08:39,120 --> 00:08:40,960
>> סיכום כל כך מהר על
מה התניות הם,

183
00:08:40,960 --> 00:08:44,210
ומה זמינות האפשרויות
לך בג לך אם ואם-אחר,

184
00:08:44,210 --> 00:08:46,860
ואם אם אחר, וכולי.

185
00:08:46,860 --> 00:08:50,880
אתה יכול להשתמש בביטויים בוליאנית
עבור אלה לקבל החלטות.

186
00:08:50,880 --> 00:08:53,720
>> עם הצהרות מתג אתה משתמש
מקרים בדידים לקבל החלטות.

187
00:08:53,720 --> 00:08:57,540
אתה במיוחד הייתי אומר, אם זה
אחד, או אם זה שניים, או אם זה שלושה,

188
00:08:57,540 --> 00:09:00,870
אני אעשה את הדבר הזה, או
הדבר הזה, או את הדבר הזה.

189
00:09:00,870 --> 00:09:04,660
ו:? יכול לשמש כדי להחליף
סניפים אם-אחר פשוט מאוד,

190
00:09:04,660 --> 00:09:08,490
או רשתות לאיפור אחרת אם
הקוד שלך נראה קצת מפואר.

191
00:09:08,490 --> 00:09:09,250
>> אני דאג לויד.

192
00:09:09,250 --> 00:09:11,410
וזה CS50.

193
00:09:11,410 --> 00:09:12,959