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

2
00:00:05,410 --> 00:00:07,640
>> DOUG LLOYD: Okej, så
låt oss tala om loopar.

3
00:00:07,640 --> 00:00:10,015
Så slingor är ganska coolt
eftersom de tillåter ditt program

4
00:00:10,015 --> 00:00:12,050
att exekvera kodrader
om och om och om igen.

5
00:00:12,050 --> 00:00:15,600
Upprepade gånger, utan att behöva kopiera
och klistra eller på annat sätt upprepa dem.

6
00:00:15,600 --> 00:00:17,630
Det finns tre stora
typer av loopar får du se.

7
00:00:17,630 --> 00:00:21,010
Du kommer förmodligen få tillfälle att använda
var och en som du framsteg genom CS50.

8
00:00:21,010 --> 00:00:22,940
Vissa av dessa slingor är ganska
bekant för dig från Scratch,

9
00:00:22,940 --> 00:00:25,814
så igen, som vi gjorde med villkors,
Vi kommer att sätta upp dem sida vid sida

10
00:00:25,814 --> 00:00:28,930
om det finns en analogi kan vi dra.

11
00:00:28,930 --> 00:00:33,600
>> Först är alltid från Scratch,
vilket kan jämföras med while (true).

12
00:00:33,600 --> 00:00:35,390
Detta är vad vi kallar en oändlig loop.

13
00:00:35,390 --> 00:00:38,560
De kodrader mellan lockigt
hängslen, ungefär som pusselbitar

14
00:00:38,560 --> 00:00:41,190
som får plats i det C
av evigt blockera

15
00:00:41,190 --> 00:00:45,290
kommer upprepade gånger köra uppifrån
till botten, om och om och om igen,

16
00:00:45,290 --> 00:00:46,085
evigt.

17
00:00:46,085 --> 00:00:48,710
Trots allt, om ni minns vår
diskussion om booleska uttryck,

18
00:00:48,710 --> 00:00:51,060
sant är alltid sant.

19
00:00:51,060 --> 00:00:53,250
Så om vi gör
något så länge som sann

20
00:00:53,250 --> 00:00:58,227
är true-- det verkar lite Silly-- sann
är alltid sant, så det kommer alltid köra.

21
00:00:58,227 --> 00:01:00,060
Det kommer att köra för evigt och
evigheternas evigheter tills vi

22
00:01:00,060 --> 00:01:02,900
hitta ett sätt att bryta sig ur det med
ett break, som återigen,

23
00:01:02,900 --> 00:01:06,350
Vi såg en liten stund sedan vi
talade om switch.

24
00:01:06,350 --> 00:01:08,725
>> Eller annars bara döda vår
programmet, som för övrigt,

25
00:01:08,725 --> 00:01:11,110
om du någonsin befinner dig i en
Situationen med en oändlig loop

26
00:01:11,110 --> 00:01:13,484
och du inte vet hur man stoppar
ditt program från att köras.

27
00:01:13,484 --> 00:01:16,527
Slå precis kontroll och C och
som dödar ditt program för dig.

28
00:01:16,527 --> 00:01:18,360
Men detta, återigen, är
kallas en oändlig slinga.

29
00:01:18,360 --> 00:01:19,818
Det är en loop som körs alltid.

30
00:01:19,818 --> 00:01:22,570

31
00:01:22,570 --> 00:01:25,610
Nu, medan slingor är inte
alltid oändligt, eftersom också

32
00:01:25,610 --> 00:01:27,880
Vi kan ersätta Boolean
uttryck med något

33
00:01:27,880 --> 00:01:29,867
lite mer användbar än bara sant.

34
00:01:29,867 --> 00:01:30,950
Så här är ett annat exempel.

35
00:01:30,950 --> 00:01:34,600
Medan och några booleska
uttryck och sedan klammerparenteserna.

36
00:01:34,600 --> 00:01:38,310
Det är ganska mycket analogt
upprepa tills från scratch.

37
00:01:38,310 --> 00:01:40,700
Även i en andra, jag
förklara skillnaden.

38
00:01:40,700 --> 00:01:44,310
>> Så i C, om det booleska uttryck
insidan av while-slingan

39
00:01:44,310 --> 00:01:47,980
utvärderas till true, i linje med
kod mellan klammerparenteserna

40
00:01:47,980 --> 00:01:51,900
kommer att utföra flera gånger om och om igen
och om igen tills Booleskt uttryck

41
00:01:51,900 --> 00:01:55,174
utvärderas till false.

42
00:01:55,174 --> 00:01:57,340
Så till exempel, kanske du
har någon form av disk.

43
00:01:57,340 --> 00:02:01,440
Så säger du i början av
denna slinga säga int x är lika med noll.

44
00:02:01,440 --> 00:02:06,370
Medan x är mindre än 100, gör ett par
saker inuti att klammerparenteser,

45
00:02:06,370 --> 00:02:10,570
sedan i slutet av din loop, säger du
x plus plus, du uppräkning x.

46
00:02:10,570 --> 00:02:13,360
Så småningom x kommer att få
till 100 och du kommer

47
00:02:13,360 --> 00:02:15,760
sluta eftersom villkoret
x är mindre än 100

48
00:02:15,760 --> 00:02:19,416
kommer inte längre att vara sant som
snart x är lika med 100.

49
00:02:19,416 --> 00:02:21,820
100 är inte mindre än 100.

50
00:02:21,820 --> 00:02:25,870
>> Nu något förvirrande, beteendet
av scratch blocket reverseras.

51
00:02:25,870 --> 00:02:29,110
Så var riktigt försiktig om detta är
din första razzia i att använda loopar.

52
00:02:29,110 --> 00:02:33,630
I grund och botten, det upprepade
tills blocket i Scratch

53
00:02:33,630 --> 00:02:35,970
kommer att upprepa något
om och om och om igen,

54
00:02:35,970 --> 00:02:40,460
tills uttrycket, Boolean
uttryck i Hexagon är sant.

55
00:02:40,460 --> 00:02:43,860
Så det kommer att fortsätta göra
tills det är sant.

56
00:02:43,860 --> 00:02:48,881
Samtidigt kommer while-slingan
fortsätta att göra det tills den är falsk.

57
00:02:48,881 --> 00:02:51,630
Så de är ganska lika, men
det är det liten skillnad bara

58
00:02:51,630 --> 00:02:55,140
att vara försiktig med, särskilt när du gör
din första razzia från övergången

59
00:02:55,140 --> 00:02:58,149
att Scratch i c.

60
00:02:58,149 --> 00:03:00,190
Nästa typ av slinga är
faktiskt ganska likartade.

61
00:03:00,190 --> 00:03:02,860
Det heter do while.

62
00:03:02,860 --> 00:03:07,060
Denna slinga kommer att utföra alla linjer
kod mellan klammerparenteserna en gång,

63
00:03:07,060 --> 00:03:09,530
och så kommer det att kontrollera
Boolean uttryck.

64
00:03:09,530 --> 00:03:11,700
Om det booleska uttryck
utvärderas till true

65
00:03:11,700 --> 00:03:14,340
Det ska gå tillbaka och repetera
denna process om och om igen

66
00:03:14,340 --> 00:03:17,690
och om igen tills Boolean
uttryck utvärderas till false.

67
00:03:17,690 --> 00:03:23,370
Så denna slinga, till skillnad från en while-slinga, är
garanterat att köra åtminstone en gång.

68
00:03:23,370 --> 00:03:26,080
Detta kan vara ganska användbart.

69
00:03:26,080 --> 00:03:28,011
>> Slutligen har vi en for-loop.

70
00:03:28,011 --> 00:03:30,010
För loopar är typ av
syntaktiskt oattraktiv

71
00:03:30,010 --> 00:03:32,330
och det finns en hel del att gå
här, så bär med mig

72
00:03:32,330 --> 00:03:34,640
som vi försöker bryta dessa bitar isär.

73
00:03:34,640 --> 00:03:36,810
Generellt användningsfallet
av en for-loop är dig

74
00:03:36,810 --> 00:03:40,136
vill upprepa något
visst antal gånger.

75
00:03:40,136 --> 00:03:42,010
I detta exempel här,
Jag har upprepningsblocket

76
00:03:42,010 --> 00:03:44,010
från Scratch, som är
analogt med for-slingan

77
00:03:44,010 --> 00:03:47,340
i C, upprepa något 10 gånger.

78
00:03:47,340 --> 00:03:49,250
Och för slingan på
vänster där, vilket

79
00:03:49,250 --> 00:03:51,410
är en fyra loop som
skulle göra samma sak.

80
00:03:51,410 --> 00:03:52,570
Detta skulle gå 10 gånger.

81
00:03:52,570 --> 00:03:56,720
Räknat från noll, vi
inkrementera varje passage i slingan.

82
00:03:56,720 --> 00:03:59,220
Och vi fortsätta att göra det
tills jag är mindre än 10.

83
00:03:59,220 --> 00:04:00,134
>> Så vad händer?

84
00:04:00,134 --> 00:04:01,550
Det finns en hel del kod där.

85
00:04:01,550 --> 00:04:03,424
Låt oss bryta ner det till
vad som händer steg

86
00:04:03,424 --> 00:04:05,684
steg när vi gräver genom en for-loop.

87
00:04:05,684 --> 00:04:08,350
Det första som hände är
räknarvariabeln är centrum.

88
00:04:08,350 --> 00:04:11,970
Allt till vänster om det första
semikolon inom parentes

89
00:04:11,970 --> 00:04:12,970
exekveras.

90
00:04:12,970 --> 00:04:15,180
I det här fallet är vi
säger int i lika med 0.

91
00:04:15,180 --> 00:04:18,709
Deklarera en ny variabel som kallas i,
att variabler är en typ heltal

92
00:04:18,709 --> 00:04:22,570
och vi säger värdet inuti
den variabeln kommer att vara noll.

93
00:04:22,570 --> 00:04:25,480
>> Den andra saken som vi gör är
vi sedan omedelbart utvärdera

94
00:04:25,480 --> 00:04:26,750
Boolean uttryck.

95
00:04:26,750 --> 00:04:30,100
Booleskt uttryck är i
mitten av de två semikolon.

96
00:04:30,100 --> 00:04:31,360
I är mindre än 10.

97
00:04:31,360 --> 00:04:32,410
Det är sant här, eller hur?

98
00:04:32,410 --> 00:04:36,030
Vi sade bara att jag är lika med
noll, och så 0 är mindre än 10,

99
00:04:36,030 --> 00:04:38,040
och så detta villkor
är sant och vi kommer nu

100
00:04:38,040 --> 00:04:40,640
fortsätta att utföra kroppen av slingan.

101
00:04:40,640 --> 00:04:41,480
Om det var falskt.

102
00:04:41,480 --> 00:04:46,380
Om till exempel, sa jag i stället för
Jag är lika med 0 där jag sade att jag är lika 15,

103
00:04:46,380 --> 00:04:47,820
int i lika 15.

104
00:04:47,820 --> 00:04:51,450
Väl 15 inte är mindre än 10, så vi
skulle aldrig kommer in i kroppen av slingan

105
00:04:51,450 --> 00:04:55,450
eftersom Boolean uttryck
skulle bedöma att vara falsk.

106
00:04:55,450 --> 00:04:59,060
>> När vi går igenom från topp till botten,
vi möter att stänga klammerparentes,

107
00:04:59,060 --> 00:05:00,830
en tredje sak händer.

108
00:05:00,830 --> 00:05:03,840
Räknarvariabeln är
ökas, eller rättare sagt, linjerna

109
00:05:03,840 --> 00:05:07,790
kod i ett uttalande efter
andra semikolon insidan av

110
00:05:07,790 --> 00:05:10,500
för slingor parenteser utförs.

111
00:05:10,500 --> 00:05:13,250
Så vi börjar med
säger int i lika med 0.

112
00:05:13,250 --> 00:05:15,770
Sedan kollar vi om eller inte
det booleska uttrycket är sant.

113
00:05:15,770 --> 00:05:17,469
0 är mindre än 10, så det är sant.

114
00:05:17,469 --> 00:05:19,510
Så vi kommer att gå vidare
in i kroppen slingan.

115
00:05:19,510 --> 00:05:22,676
Saker kommer att hända innanför slingan, och
när vi möter att stänga lockigt

116
00:05:22,676 --> 00:05:25,660
stag, nästa sak vi
göra är att vi säger i plus, plus.

117
00:05:25,660 --> 00:05:28,860
Jag var noll nu jag är en.

118
00:05:28,860 --> 00:05:33,100
Sedan återigen kontrollerar vi värdet av
Boolean uttryck i mitten.

119
00:05:33,100 --> 00:05:34,900
En är mindre än 10.

120
00:05:34,900 --> 00:05:38,325
Så vi ska gå igenom denna
bearbeta och om igen.

121
00:05:38,325 --> 00:05:40,590
Vi kommer till stängning
klammerparentes igen.

122
00:05:40,590 --> 00:05:44,090
Vi kommer att öka i från
Ett till två och från två till tre.

123
00:05:44,090 --> 00:05:48,290
Och så vidare och så vidare och så vidare, tills
småningom i värde blir 10.

124
00:05:48,290 --> 00:05:49,950
Är 10 mindre än 10?

125
00:05:49,950 --> 00:05:51,200
Nej.

126
00:05:51,200 --> 00:05:53,800
Räknat från 0, har vi gått
genom 10 iterationer av slingan.

127
00:05:53,800 --> 00:05:57,204
Vi har upprepades 10 gånger, bara
som vi gjorde i Scratch blocket.

128
00:05:57,204 --> 00:05:59,370
Och så det är i princip
förfarande för en fyra slinga.

129
00:05:59,370 --> 00:06:01,630
>> Nu tar bort
faktiska koden och sätta det

130
00:06:01,630 --> 00:06:05,120
på bara några grundläggande allmänna uttalanden.

131
00:06:05,120 --> 00:06:06,550
Här är vad som händer.

132
00:06:06,550 --> 00:06:09,290
Alla uttalanden i
börja utförs först.

133
00:06:09,290 --> 00:06:11,260
Du kanske har mer än en.

134
00:06:11,260 --> 00:06:13,440
Därefter Boolean uttryck kontrolleras.

135
00:06:13,440 --> 00:06:17,850
Om uttrycket utvärderas till true,
exekvera kroppen slingan en gång.

136
00:06:17,850 --> 00:06:21,060
Om uttrycket utvärderas
false vi gjort.

137
00:06:21,060 --> 00:06:23,040
Vi inte verkställa
kropp av slingan alls.

138
00:06:23,040 --> 00:06:25,530
Efter att vi har utfört
kropp slingan en gång,

139
00:06:25,530 --> 00:06:29,487
vi sedan göra vad som finns i
inkrementet delen där.

140
00:06:29,487 --> 00:06:31,820
Som vanligtvis kommer att vara
något som jag plus, plus

141
00:06:31,820 --> 00:06:34,510
eller något liknande, att
modifierar en räknarvariabeln.

142
00:06:34,510 --> 00:06:37,390
Sedan, när vi öka, vi
kontrollera expressionen igen

143
00:06:37,390 --> 00:06:41,120
och upprepa dessa steg om och om igen
och om igen tills uttrycket är

144
00:06:41,120 --> 00:06:42,890
inte längre sant.

145
00:06:42,890 --> 00:06:44,469
>> Så vad är användningsfall för en loop?

146
00:06:44,469 --> 00:06:46,760
Använd du använder en while-slinga när
du vill ha en slinga för att upprepa

147
00:06:46,760 --> 00:06:51,200
ett okänt antal gånger, men
det möjligen kan inte köra alls.

148
00:06:51,200 --> 00:06:53,940
En riktigt vanligt exempel på
en stund looping används

149
00:06:53,940 --> 00:06:56,480
är att köra styrflödet för ett spel.

150
00:06:56,480 --> 00:06:59,040
Du kanske inte vet hur länge
användaren kommer att spela,

151
00:06:59,040 --> 00:07:01,440
men du vill behålla
gör samma sak.

152
00:07:01,440 --> 00:07:04,970
Uppdatering positionerna för
olika sprites på tavlan.

153
00:07:04,970 --> 00:07:07,490
Du vill hålla saker
i rörelse hela tiden,

154
00:07:07,490 --> 00:07:09,110
men du vet inte när
användaren kommer att sluta spela

155
00:07:09,110 --> 00:07:10,450
eller när de är på väg
få slut på liv.

156
00:07:10,450 --> 00:07:12,741
Så en while-slinga är verkligen
bra för något liknande.

157
00:07:12,741 --> 00:07:14,130
Det är en bra användningsfall.

158
00:07:14,130 --> 00:07:16,230
>> För en gör while-slinga,
det är ganska likartade.

159
00:07:16,230 --> 00:07:19,746
Vill du ha en slinga för att upprepa en okänd
antal gånger, men åtminstone en gång.

160
00:07:19,746 --> 00:07:22,370
Du kan använda detta för ett spel
också, men en riktigt vanlig användningsfall

161
00:07:22,370 --> 00:07:24,420
är som uppmanar användaren för inmatning.

162
00:07:24,420 --> 00:07:28,609
Generellt kan man säga något
liksom, ge mig ett positivt heltal,

163
00:07:28,609 --> 00:07:30,650
och du kan sätta det
insidan av en gör while-slinga.

164
00:07:30,650 --> 00:07:33,900
Så det kommer alltid att be dem på
minst en gång för ett positivt heltal.

165
00:07:33,900 --> 00:07:36,850
Om de ger dig ett positivt heltal,
du kan bryta ut ur loopen.

166
00:07:36,850 --> 00:07:37,599
Du kan göras.

167
00:07:37,599 --> 00:07:39,900
Boolean uttryck i
do medan kan vara falsk.

168
00:07:39,900 --> 00:07:41,137
>> Och du kommer inte att be dem igen.

169
00:07:41,137 --> 00:07:44,470
Om de ger dig ett negativt tal där
de skriver något ord eller något som är

170
00:07:44,470 --> 00:07:46,630
inte riktigt bra att
dig, kan du använda den

171
00:07:46,630 --> 00:07:49,770
gör medan slinga för att gå tillbaka och göra
det igen och igen och igen.

172
00:07:49,770 --> 00:07:52,410
Du vill absolut be
dem att ge dig ett nummer en gång,

173
00:07:52,410 --> 00:07:56,350
men du vet inte hur många gånger
efter att de kan vara skadedjur.

174
00:07:56,350 --> 00:08:00,540
Och så en gör samtidigt som det är en stor användning
fodral för att meddela användaren för inmatning.

175
00:08:00,540 --> 00:08:03,060
Och för slingor använder
fall är vanligtvis när

176
00:08:03,060 --> 00:08:06,230
du vill upprepa en slinga
ett diskret antal gånger,

177
00:08:06,230 --> 00:08:08,230
men du kanske inte
veta hur många gånger

178
00:08:08,230 --> 00:08:10,040
det ögonblick programmet kompileras.

179
00:08:10,040 --> 00:08:15,510
>> Så till exempel, kanske du har ett program
där du fråga användaren om ett nummer.

180
00:08:15,510 --> 00:08:17,660
Och de går in 100.

181
00:08:17,660 --> 00:08:20,510
Och sedan ditt för loop kommer
i så fall köra 100 gånger.

182
00:08:20,510 --> 00:08:22,480
Eller kanske de anger
1000 i ditt program

183
00:08:22,480 --> 00:08:24,570
och kör sedan loopen 1000 gånger.

184
00:08:24,570 --> 00:08:26,987
Det är ett visst antal gånger.

185
00:08:26,987 --> 00:08:28,820
De gör inte nödvändigtvis
vet vad det numret

186
00:08:28,820 --> 00:08:31,010
är det ögonblick programmet kompileras.

187
00:08:31,010 --> 00:08:35,010
Det är inte som en while-slinga
där det kan vara oändlig.

188
00:08:35,010 --> 00:08:37,127
Det är snarare ett antal
att du bara inte vet.

189
00:08:37,127 --> 00:08:39,210
Nu trots att jag har
beskrivs alla dessa användningsfall,

190
00:08:39,210 --> 00:08:41,501
ska du veta att i pretty
mycket varje omständighet,

191
00:08:41,501 --> 00:08:44,110
du kan byta alla
tre av dessa slingor.

192
00:08:44,110 --> 00:08:46,890
Du kan använda en for-loop där du
annars skulle använda en while-slinga.

193
00:08:46,890 --> 00:08:49,860
Du kan använda en for-loop varhelst
du skulle använda en gör while-slinga och så vidare.

194
00:08:49,860 --> 00:08:53,680
Det kan vara lite knepigt ibland,
så generellt är det en god praxis

195
00:08:53,680 --> 00:08:55,140
att ansluta sig till ett typiskt användningsfall.

196
00:08:55,140 --> 00:08:57,599
Använd en gör while-slinga om du
ville ha något en gång, åtminstone.

197
00:08:57,599 --> 00:09:00,514
Använd en for-loop om du vill göra
något ett visst antal gånger.

198
00:09:00,514 --> 00:09:03,730
När allt kommer omkring, det är därför det finns
tre olika typer av slingor.

199
00:09:03,730 --> 00:09:06,172
>> Så att de kan användas
i rätt sammanhang.

200
00:09:06,172 --> 00:09:07,880
Men du kan byta
dem om du vill.

201
00:09:07,880 --> 00:09:10,790
Om du känner dig bekväm med while-slingor
och du alltid vill använda medan slingor.

202
00:09:10,790 --> 00:09:12,623
Det är något som
du kan göra, även om det

203
00:09:12,623 --> 00:09:15,590
kan vara lite syntaktiskt
knepigt, där en for-loop

204
00:09:15,590 --> 00:09:17,850
skulle vara mycket enklare.

205
00:09:17,850 --> 00:09:21,100
>> Mitt namn är Doug Lloyd och det är CS50.

206
00:09:21,100 --> 00:09:22,688