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

2
00:00:05,140 --> 00:00:05,640
Okej.

3
00:00:05,640 --> 00:00:08,330
Så nu ska vi prata om någonting
verkligen användbart i programming--

4
00:00:08,330 --> 00:00:09,914
villkorssatser.

5
00:00:09,914 --> 00:00:11,830
Så villkorsuttryck
låta dina program

6
00:00:11,830 --> 00:00:14,538
att fatta beslut och ta olika
gafflar i vägen, något

7
00:00:14,538 --> 00:00:17,670
Jag hänvisade till lite tidigare,
beroende på värdena på variabler,

8
00:00:17,670 --> 00:00:20,990
eller baserat på vad användaren matar på
programmeraren, på kommandoraden,

9
00:00:20,990 --> 00:00:23,130
eller om du har en fråga
eller något sådant.

10
00:00:23,130 --> 00:00:26,690
C har ett par olika sätt att
uttrycka villkorsuttryck, som

11
00:00:26,690 --> 00:00:29,911
vi också ibland kallar en
villkor filial i dina program.

12
00:00:29,911 --> 00:00:32,910
Och några av dessa kommer att se ut
ganska bekant för dig från scratch,

13
00:00:32,910 --> 00:00:35,190
så vi kommer även dra dem
upp sida vid sida, precis

14
00:00:35,190 --> 00:00:38,170
du kan göra det analogi i huvudet.

15
00:00:38,170 --> 00:00:41,250
>> Så, om är if-- en ganska
enkel villkorligt.

16
00:00:41,250 --> 00:00:43,560
Om ni minns från
repa på höger här

17
00:00:43,560 --> 00:00:50,000
du kan fylla i det är hexagon
med en blå uttryck om musen ner

18
00:00:50,000 --> 00:00:53,010
eller om X är mindre än 10,
eller något sådant.

19
00:00:53,010 --> 00:00:57,390
Och sedan, om x var mindre än 10,
eller om musen var i själva verket, nedåt,

20
00:00:57,390 --> 00:01:01,140
all kod insidan av
pusselbiten skulle utföra.

21
00:01:01,140 --> 00:01:03,720
Alla de saker som passar
insidan som C-form.

22
00:01:03,720 --> 00:01:07,200
>> På samma sätt har vi
om till vänster där.

23
00:01:07,200 --> 00:01:09,210
Om booleskt uttryck,
som jag bara använda

24
00:01:09,210 --> 00:01:13,010
som ett substitut för en av Boolean
uttryck vi tidigare diskuterat,

25
00:01:13,010 --> 00:01:15,240
öppna klammerparentes, nära klammerparentes.

26
00:01:15,240 --> 00:01:17,720
Så tänk på öppen lockigt
stag och sluten klammerparentes

27
00:01:17,720 --> 00:01:22,720
som en slags analogt med sandwich
effekten av om blocket på höger

28
00:01:22,720 --> 00:01:24,070
från början.

29
00:01:24,070 --> 00:01:28,680
>> Om det booleska uttryck
i om påståendet är sant,

30
00:01:28,680 --> 00:01:30,900
då alla kodrader
mellan klammerparenteserna

31
00:01:30,900 --> 00:01:33,870
kommer att utföra i syfte
från topp till tå.

32
00:01:33,870 --> 00:01:35,700
Om det booleska uttryck
är falska, vi ska

33
00:01:35,700 --> 00:01:38,610
hoppa över allt däremellan
klammerparenteserna, eftersom vi bara

34
00:01:38,610 --> 00:01:44,570
vill gå den vägskäl
Om det booleska uttrycket är sant.

35
00:01:44,570 --> 00:01:48,540
>> Vi kan ta detta ett steg
ytterligare med om annat.

36
00:01:48,540 --> 00:01:50,820
Så här Scratch block är
ganska lik den

37
00:01:50,820 --> 00:01:55,884
vi såg bara en sekund sedan, med undantag
det tar två olika vägar baserade

38
00:01:55,884 --> 00:01:56,550
om vad som händer.

39
00:01:56,550 --> 00:02:00,420
Så om musen var nere,
eller om x var mindre än 10,

40
00:02:00,420 --> 00:02:04,780
Vi kommer att göra allt som är i mellan
det första gaffeln, det första C,

41
00:02:04,780 --> 00:02:08,430
>> Annars, om musen är
upp, eller x är minst 10,

42
00:02:08,430 --> 00:02:10,460
Vi kommer att göra allt i andra set.

43
00:02:10,460 --> 00:02:15,010
Och det är analogt med vad du ser
här för C. Om booleskt uttryck,

44
00:02:15,010 --> 00:02:17,910
göra saker mellan
första uppsättning klammerparenteser.

45
00:02:17,910 --> 00:02:20,550
Annars gör grejer mellan
andra uppsättning av klammerparenteser.

46
00:02:20,550 --> 00:02:22,080
Så om Boolean
uttrycket är sant, vi ska

47
00:02:22,080 --> 00:02:23,580
göra vad är mellan den första uppsättningen.

48
00:02:23,580 --> 00:02:27,480
Om det booleska uttrycket är
falsk, skulle det utlösa annat,

49
00:02:27,480 --> 00:02:30,100
och vi skulle göra vad är i
den andra uppsättningen av klammerparenteser.

50
00:02:30,100 --> 00:02:34,190
Återigen, topp till botten, alla
linjer i mellan hängslen.

51
00:02:34,190 --> 00:02:38,130
>> I C, är det möjligt att skapa
en if-else if-else kedjan.

52
00:02:38,130 --> 00:02:42,000
I själva verket kan du ha if-else if-else
if-else, om och så vidare och så vidare och så

53
00:02:42,000 --> 00:02:42,720
vidare.

54
00:02:42,720 --> 00:02:44,660
I Scratch, detta krävs
kapsla blocken.

55
00:02:44,660 --> 00:02:48,280
Du lägger en if-else, och var du tvungen att
sätta en annan insidan av annat,

56
00:02:48,280 --> 00:02:51,110
och så vidare, och det fick typ
av kapslade och komplicerat.

57
00:02:51,110 --> 00:02:52,450
Men C, behöver vi inte göra det.

58
00:02:52,450 --> 00:02:55,300
Vi kan faktiskt bara ha
det är en kedja som denna.

59
00:02:55,300 --> 00:02:58,350
Återigen, som du kanske tror, ​​alla
dessa grenar är ömsesidigt uteslutande.

60
00:02:58,350 --> 00:03:00,750
Du kan alltid bara gå
ner en av grenen.

61
00:03:00,750 --> 00:03:02,270
Om detta är sant.

62
00:03:02,270 --> 00:03:03,930
Annars, om detta är sant.

63
00:03:03,930 --> 00:03:05,700
Annars, om detta är sant.

64
00:03:05,700 --> 00:03:07,120
Annars gör detta.

65
00:03:07,120 --> 00:03:11,010
Så alla fyra grenarna i detta
exempel är ömsesidigt uteslutande.

66
00:03:11,010 --> 00:03:14,900
Det är en if-else if-else kedjan.

67
00:03:14,900 --> 00:03:17,580
>> Det är möjligt men,
och ibland mycket användbar,

68
00:03:17,580 --> 00:03:20,950
att skapa en kedja av inte
ömsesidigt uteslutande grenar.

69
00:03:20,950 --> 00:03:24,600
I detta exempel, bara den tredje och
fjärde grenar är ömsesidigt uteslutande.

70
00:03:24,600 --> 00:03:27,450
Det kan vara så att du kan
uppfyller det första villkoret,

71
00:03:27,450 --> 00:03:29,396
och du kan tillfredsställa
det andra villkoret,

72
00:03:29,396 --> 00:03:31,770
och du kan tillfredsställa
tredje Skick- i vilket fall

73
00:03:31,770 --> 00:03:35,270
du skulle gå ner den första grenen,
sedan går du ner en andra gren,

74
00:03:35,270 --> 00:03:37,000
då du skulle gå ner den tredje grenen.

75
00:03:37,000 --> 00:03:40,450
Eller kanske du uppfyller det första
skick, och det andra villkoret,

76
00:03:40,450 --> 00:03:42,770
men du inte uppfyller
det tredje villkoret.

77
00:03:42,770 --> 00:03:46,230
I det här fallet du går ner den första
gren och den andra grenen,

78
00:03:46,230 --> 00:03:48,040
och sedan den fjärde grenen,

79
00:03:48,040 --> 00:03:51,392
>> Anledningen till detta är att den annars
kommer endast att binda till närmaste om.

80
00:03:51,392 --> 00:03:53,100
Så även om det finns
en annan här, att

81
00:03:53,100 --> 00:03:56,490
inte nödvändigtvis skapar en ömsesidigt
exklusiva kedja av allt.

82
00:03:56,490 --> 00:04:00,890
Det är bara ett uttryck
där med Boolean

83
00:04:00,890 --> 00:04:05,040
uttryck 3-- det är
ömsesidigt uteslutande med annat.

84
00:04:05,040 --> 00:04:07,580
Så det är möjligt, och
ibland ganska användbara,

85
00:04:07,580 --> 00:04:11,772
som jag sa, att skapa en kedja av
inte utesluter varandra grenar.

86
00:04:11,772 --> 00:04:14,230
Låt oss ta en titt på en annan
typ av villkorad, som

87
00:04:14,230 --> 00:04:17,392
du inte har sett förut i Scratch.

88
00:04:17,392 --> 00:04:19,369
Det finns något som kallas
satsen switch.

89
00:04:19,369 --> 00:04:21,410
Satsen switch är
typ av snyggt eftersom det är

90
00:04:21,410 --> 00:04:25,930
en villkorlig programsats som tillåter
du ange tydliga mål,

91
00:04:25,930 --> 00:04:28,926
i stället för att förlita sig på Boolean
uttryck för att fatta beslut för dig.

92
00:04:28,926 --> 00:04:31,050
Så till exempel, låt oss säga
att jag har det här programmet,

93
00:04:31,050 --> 00:04:34,110
och jag ber användaren
att bidra till mig.

94
00:04:34,110 --> 00:04:37,170
Så jag säger, int x = Få Int (),
och om du inte är bekant ännu,

95
00:04:37,170 --> 00:04:40,190
få int är en funktion som är
även i CS50 biblioteket

96
00:04:40,190 --> 00:04:44,610
så om du #include CS50.H har du
tillgång att få Int () och alla dess

97
00:04:44,610 --> 00:04:46,840
cousins-- getFloat,
GetString, och så vidare.

98
00:04:46,840 --> 00:04:52,590
I grund och botten en Få funktion för varje
datatyp som vi redan har diskuterat.

99
00:04:52,590 --> 00:04:53,970
>> Så Int x är lika getInt.

100
00:04:53,970 --> 00:04:56,390
I grund och botten vad som händer
är jag på terminalen.

101
00:04:56,390 --> 00:04:58,790
Jag ber användaren att skriva in ett nummer.

102
00:04:58,790 --> 00:05:02,300
>> Och här jag byta
vad jag gör, beroende

103
00:05:02,300 --> 00:05:05,060
på vad användaren skrivit vid prompten.

104
00:05:05,060 --> 00:05:09,147
Så om de skrev en, jag skriva ut en.

105
00:05:09,147 --> 00:05:09,855
Och sedan jag bryta.

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

107
00:05:12,590 --> 00:05:15,510
Om de skriver två, jag skriva ut två.

108
00:05:15,510 --> 00:05:16,690
Och sedan jag bryta.

109
00:05:16,690 --> 00:05:19,060
Det är viktigt att
bryta mellan varje fall

110
00:05:19,060 --> 00:05:20,890
annars kommer du att falla igenom.

111
00:05:20,890 --> 00:05:23,380
Så om jag inte hade någon
raster där, och användaren

112
00:05:23,380 --> 00:05:31,380
maskinskriven en, vad som skulle hända är det
skulle skriva ut en, två, tre, sorry.

113
00:05:31,380 --> 00:05:33,099
Det är typ av märkliga beteende, eller hur?

114
00:05:33,099 --> 00:05:33,890
Du kanske tror det.

115
00:05:33,890 --> 00:05:36,480
Men det finns faktiskt vissa fall där
Detta kan vara en ganska bra sak.

116
00:05:36,480 --> 00:05:39,730
Så här är ett annat exempel på en switch
uttalande där jag utelämna raster.

117
00:05:39,730 --> 00:05:42,030
Men jag gör det med flit.

118
00:05:42,030 --> 00:05:43,030
>> Så vad händer här?

119
00:05:43,030 --> 00:05:43,821
Tänk för en sekund.

120
00:05:43,821 --> 00:05:45,960
Du kanske även vill pausa videon.

121
00:05:45,960 --> 00:05:48,230
>> Vad händer här om
användaren skriver fyra?

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

123
00:05:51,190 --> 00:05:53,860
Så jag har bett användaren för inmatning.

124
00:05:53,860 --> 00:05:56,560
Och de ger värdet 4.

125
00:05:56,560 --> 00:05:59,545
Vad får ut när jag gör det?

126
00:05:59,545 --> 00:06:02,170
På föregående bild, fanns
pauser mellan samtliga fall.

127
00:06:02,170 --> 00:06:04,750
Och så skulle det bara
ut fyra och sedan stanna.

128
00:06:04,750 --> 00:06:06,610
Men i detta fall, kommer det inte.

129
00:06:06,610 --> 00:06:10,700
Vad kommer att hända är att du
kommer att falla genom varje fall.

130
00:06:10,700 --> 00:06:14,890
>> Så i det här fallet jag har organiserat mitt fall
på ett sådant sätt att, om användaren skriver 4,

131
00:06:14,890 --> 00:06:20,070
Jag kommer att skriva ut fyra, tre,
två, ett, spränga bort.

132
00:06:20,070 --> 00:06:22,780
Och om de skrivit fem, skulle jag börja
på fem och göra samma sak.

133
00:06:22,780 --> 00:06:26,410
Om de skrev en, skulle jag
bara göra en, blast off.

134
00:06:26,410 --> 00:06:28,715
>> Så i detta fall, jag använder
en omkopplare slags skickligt så

135
00:06:28,715 --> 00:06:30,804
att jag tänker att falla
genom alla fallen.

136
00:06:30,804 --> 00:06:33,720
Men generellt är du förmodligen gonna
vill bryta mellan dem alla,

137
00:06:33,720 --> 00:06:36,090
om du inte har en situation
som den här där du

138
00:06:36,090 --> 00:06:40,081
typ av utnyttja det faktum att du kommer
falla igenom fallen utan avbrott.

139
00:06:40,081 --> 00:06:42,830
Så det är den andra av de stora
typer av villkorssatser.

140
00:06:42,830 --> 00:06:47,139
Varav den sista är:? Så jag
har två fragment av C-kod här.

141
00:06:47,139 --> 00:06:48,680
En på vänster och en på höger sida.

142
00:06:48,680 --> 00:06:52,330
Den till vänster bör
förmodligen vara ganska bekant för dig.

143
00:06:52,330 --> 00:06:55,110
>> Jag har Int x.

144
00:06:55,110 --> 00:06:57,167
Och jag förmodligen borde
har bett användaren

145
00:06:57,167 --> 00:07:00,250
for-- detta bör nog vara Int x
lika getInt, eller nåt sånt.

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

147
00:07:03,030 --> 00:07:05,240
Och då jag fattar ett beslut.

148
00:07:05,240 --> 00:07:11,700
Om några booleskt uttryck är
sant, tilldela x värdet 5.

149
00:07:11,700 --> 00:07:13,590
Annars tilldela x värdet 6.

150
00:07:13,590 --> 00:07:16,548
>> Det till vänster bör nog vara
ganska bekant från vår diskussion

151
00:07:16,548 --> 00:07:18,160
If Else bara en stund sedan.

152
00:07:18,160 --> 00:07:20,535
Skulle du bli förvånad över att veta
att linjen på höger

153
00:07:20,535 --> 00:07:22,310
gör exakt samma sak?

154
00:07:22,310 --> 00:07:26,140
>> Så det här kallas:? Eller ibland
kallas ternära operatören.

155
00:07:26,140 --> 00:07:27,450
Och det är ganska coolt.

156
00:07:27,450 --> 00:07:29,110
Det är oftast används som en söt trick.

157
00:07:29,110 --> 00:07:35,777
>> Men vad det gör att du kan göra är att
simulera en Om Else med riktigt små,

158
00:07:35,777 --> 00:07:37,610
verkligen trivialt kort
villkorliga grenar.

159
00:07:37,610 --> 00:07:41,470
Du vanligtvis inte skulle använda:? Om du
hade sex rader kod mellan varje uppsättning

160
00:07:41,470 --> 00:07:42,569
av klammerparenteserna.

161
00:07:42,569 --> 00:07:44,360
Men om du bara
gör ett snabbt beslut,

162
00:07:44,360 --> 00:07:47,520
Om du ska göra en sak
eller andra och det är mycket enkelt,

163
00:07:47,520 --> 00:07:52,240
detta kan vara ett exempel på hur man
göra det med? ternära operatören.

164
00:07:52,240 --> 00:07:56,940
Så Int x är lika med uttrycket?

165
00:07:56,940 --> 00:07:59,470
Saken efter frågan
märket är vad x värde

166
00:07:59,470 --> 00:08:02,690
kommer att vara om uttrycket är sant.

167
00:08:02,690 --> 00:08:05,330
>> Saken efter
kolon är vad xs värde

168
00:08:05,330 --> 00:08:07,990
skulle vara om expressionen var falsk.

169
00:08:07,990 --> 00:08:11,510
Så jag frågar mig själv,
är ett uttryck sant?

170
00:08:11,510 --> 00:08:13,870
Om det är, tilldela x värdet 5.

171
00:08:13,870 --> 00:08:16,619
Om det inte tilldela x värdet 6.

172
00:08:16,619 --> 00:08:17,410
Återigen, som jag sa.

173
00:08:17,410 --> 00:08:18,670
Detta är oftast bara en söt trick.

174
00:08:18,670 --> 00:08:20,430
Och ibland om du blir
riktigt bekväm med det,

175
00:08:20,430 --> 00:08:22,820
Du ska göra detta eftersom det ser ut
typ av cool i dina program.

176
00:08:22,820 --> 00:08:25,710
Generellt jag presenterar det till
du nu så du är bekant med det

177
00:08:25,710 --> 00:08:26,990
om du ser det.

178
00:08:26,990 --> 00:08:30,080
Men säkert vet att du inte har
att skriva det i någon av din kod.

179
00:08:30,080 --> 00:08:33,246
Men det är något att vara bekant med,
eftersom du kommer definitivt att stöta

180
00:08:33,246 --> 00:08:36,130
kodavsnitt här och
Det var så här:? syntax,

181
00:08:36,130 --> 00:08:39,120
AKA ternära operatören används.

182
00:08:39,120 --> 00:08:40,960
>> Så snabb sammanfattning på
vilka villkors är

183
00:08:40,960 --> 00:08:44,210
och vilka alternativ är tillgängliga
till dig i C. Du har If och if-else,

184
00:08:44,210 --> 00:08:46,860
och om annat om et cetera.

185
00:08:46,860 --> 00:08:50,880
Du kan använda booleska uttryck
för dem att fatta beslut.

186
00:08:50,880 --> 00:08:53,720
>> Med switch uttalanden du använder
diskreta fall att fatta beslut.

187
00:08:53,720 --> 00:08:57,540
Du skulle specifikt säga, om det är
en, eller om det är två, eller om det är tre,

188
00:08:57,540 --> 00:09:00,870
Jag ska göra det här, eller
denna sak, eller det här.

189
00:09:00,870 --> 00:09:04,660
Och: kan användas för att ersätta
mycket enkla if-else grenar,

190
00:09:04,660 --> 00:09:08,490
eller om-else kedjor att göra
koden ser lite fantasi.

191
00:09:08,490 --> 00:09:09,250
>> Jag är Doug Lloyd.

192
00:09:09,250 --> 00:09:11,410
Och detta är CS50.

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