>> DOUG LLOYD: Oke, dus laten we praten over loops.
Dus lussen zijn wel cool omdat ze het programma staan
om lijnen van de code uit te voeren over en over en voorbij.
Herhaaldelijk, zonder te kopiëren en plakken of anderszins herhalen.
Er zijn drie belangrijke soorten lussen je zult zien.
Je zult waarschijnlijk gelegenheid te gebruiken een ieder als je vooruitgang door de CS50.
Sommige van deze loops zijn vrij u bekend voor uit Scratch,
Dus nogmaals, zoals wij deden met voorwaardelijke, we zullen ze zetten side by side
als er een analogie kunnen we trekken.
>> De eerste is voor altijd uit Scratch, die vergelijkt met while (true).
Dit is wat we een oneindige lus noemen.
De lijnen van de code tussen de curly bretels, net als de puzzelstukjes
die passen binnen het C van de altijd blokkeren,
wordt herhaaldelijk uitvoeren van boven naar beneden, over en over en over,
altijd.
Immers, als je herinneren ons bespreking van Booleaanse expressies,
true altijd waar.
Dus als we doen iets zo lang als echte
wordt true-- het lijkt een beetje Silly-- ware is altijd waar, dus het zal altijd draaien.
Het zal voor altijd rennen en alle eeuwigheid totdat we
een manier vinden om van te maken om te breken met een break-statement, die opnieuw,
we een tijdje geleden zagen we hadden het over schakelaar.
>> Of anders gewoon vermoorden ons programma, dat overigens
Als je ooit in een situatie met een oneindige lus
en je weet niet hoe om te stoppen het programma van het lopen.
Gewoon op controle en C en dat zal je programma voor je vermoorden.
Maar wederom is riep een oneindige lus.
Het is een lus die voor altijd zal lopen.
Nu, terwijl de loops niet altijd oneindig, want ook
kunnen we de Booleaanse vervangen expressie met iets
een beetje nuttiger dan alleen waar.
Dus hier is een ander voorbeeld.
Terwijl en enkele Booleaanse expressie en vervolgens accolades.
Dat is vrij veel analoog herhalen totdat, vanaf nul.
Hoewel het in een tweede, zal ik verklaren het verschil.
>> Dus C, als de Booleaanse uitdrukking binnenzijde van de while lus
true, de lijnen van code tussen de accolades
zal over en herhaaldelijk uitvoeren en over totdat Booleaanse uitdrukking
evalueert op false.
Dus bijvoorbeeld, zou je hebben een soort van teller.
Dus zeggen dat je aan het begin van deze lus zeggen int x gelijk is aan nul.
Terwijl x minder is dan 100, doe een paar dingen binnen die accolades,
dan aan het einde van je loop, zeg je x plus plus, je verhogen x.
Uiteindelijk x krijgt 100 en je zult
stoppen, omdat de aandoening x is dan 100
zal niet langer waar als zijn Zodra x gelijk aan 100.
100 ten minste 100.
>> Nu enigszins verwarrend, het gedrag van de kras blok wordt teruggedraaid.
Wees dus heel voorzichtig als dit je eerste uitstapje in het gebruik van loops.
Kortom, de herhaling totdat blok in Scratch
iets zal herhalen over en over en over,
tot de expressie, de Boolean expressie in de zeshoek waar.
Dus het zal blijven doen totdat het is waar.
Ondertussen, terwijl de lus blijven doen totdat het vals.
Dus ze zijn vrij gelijkaardig, maar er is dat weinig onderscheid net
voorzichtig zijn van vooral als je te maken uw eerste uitstapje van de overgang
krassen in c.
De volgende soort lus eigenlijk redelijk vergelijkbaar.
Het heet de do while lus.
Deze lus zal alle lijnen uit te voeren van de code tussen de accolades een keer,
en dan zal het controleren de Booleaanse uitdrukking.
Als de Booleaanse uitdrukking true,
het zal terug gaan en herhaal dat proces over en voorbij
en over totdat de Booleaanse expressie naar false evalueert.
Dus deze lus, in tegenstelling tot een tijdje loop, is gegarandeerd ten minste één keer uitgevoerd.
Dit kan erg handig.
>> Tot slot hebben we een lus.
Voor loops zijn soort syntactisch onaantrekkelijk
en er is veel gaande hier, dus geduld met mij
als we proberen en breek deze stukken uit elkaar.
In het algemeen, het gebruik case van een lus is dat je
iets willen een herhaling bepaald aantal keren.
In dit voorbeeld hier, Ik heb de herhaling blok
vanuit het niets, dat is analoog aan de lus
in C, wat 10 keer herhalen.
En de lus op de linkerkant, die
is een vier lus die zou hetzelfde doen.
Dit zou gaan 10 keer.
Gerekend vanaf nul, we increment elke passage van de lus.
En we blijven dat doen totdat ik minder dan 10.
>> Dus wat gebeurt er?
Er is een heleboel code daar.
Laten we het af te breken om wat er gebeurt stap
stap als we graven door een lus.
Het eerste wat er gebeurd is de teller variabele centrum.
Alles wat links van die eerste puntkomma tussen de haakjes
wordt uitgevoerd.
In dit geval zijn wij zeggen int i gelijk is aan 0.
Waarbij een nieuwe variabele genaamd i, dat variabelen is een integer
en we de waarde van binnen te zeggen die variabele gaat nul.
>> Het tweede wat we doen is we vervolgens direct evalueren
de Booleaanse uitdrukking.
Booleaanse uitdrukking is in het midden van de twee puntkomma's.
I kleiner is dan 10.
Dat is hier waar, toch?
We hebben net zei dat ik gelijk aan nul en dus 0 is dan 10,
en zodat toestand waar is en we zullen nu
overgaan tot het lichaam van de lus uit te voeren.
Als het vals was.
Als, bijvoorbeeld, zei ik in plaats van i gelijk is aan 0 daar heb ik zei dat ik gelijk aan 15,
int i is gelijk aan 15.
Wel 15 niet minder dan 10, dus zou nooit het lichaam van de lus in te voeren
omdat de Booleaanse uitdrukking Er evalueert vals te zijn.
>> Na gaan we door van boven naar beneden, we tegenkomen dat het sluiten accolade,
een derde ding gebeurt.
De teller variabele opgehoogd, of liever de lijnen
van de code van een verklaring na de tweede puntkomma binnenkant van de
voor lussen haakjes wordt uitgevoerd.
Dus we gaan door zeggen int i gelijk is aan 0.
Dan controleren we of niet de Booleaanse expressie waar is.
0 minder dan 10 dus het is waar.
Dus we gaan om verder te gaan in het lichaam de lus.
Dingen zullen gebeuren in de lus, en toen we tegenkomen dat het sluiten krullend
brace, het volgende wat we doen is dat we zeggen dat ik plus, plus.
Ik was nul nu i is één.
Dan hebben we opnieuw controleren van de waarde van de Booleaanse uitdrukking in het midden.
Een kleiner is dan 10.
Dus we gaan door middel van deze verwerken opnieuw en opnieuw.
We zullen tot de sluiting te krijgen accolade opnieuw.
We zullen i verhogen van 1-2 en 2-3.
En zo voort en zo voort en zo verder, totdat Uiteindelijk heb ik de waarde van wordt 10.
Is 10 kleiner dan 10?
Nee.
Geteld vanaf 0, zijn we gegaan tot en met 10 iteraties van de lus.
We hebben 10 keer herhaald, net zoals we in de Scratch blok.
En dat is dus in principe de Werkwijze voor vier lus.
>> Nu is het wegnemen van de eigenlijke code en zetten het
in slechts een aantal fundamentele algemene uitspraken.
Hier is wat er gebeurt.
Alle verklaringen in start eerst uitgevoerd.
Je zou meer dan één hebben.
Vervolgens wordt de Booleaanse uitdrukking gecontroleerd.
Als de expressie true, voeren het lichaam de loop een keer.
Als de expressie evalueert vals, we zijn klaar.
We niet voeren van de orgaan van de lus op alle.
Nadat we hebben uitgevoerd de instantie de lus een keer,
we dan doen wat in de toename deel daar.
Die wordt meestal gaat worden iets als ik plus, plus
of iets dergelijks, dat wijzigt een teller variabele.
Dan, na verhogen, we Controleer de uitdrukking weer
en over en herhaal die stappen en over totdat de expressie
niet meer waar.
>> Dus wat zijn de use cases voor een lus?
Gebruik je een tijdje lus bij gebruik U wilt een lus te herhalen
een onbekend aantal malen, maar Het zou misschien niet allemaal lopen.
Een heel bekend voorbeeld van een tijdje looping wordt gebruikt
is de besturingsstroom voor een spel werking.
Je zou niet weten hoe lang de gebruiker gaat spelen,
maar u wilt bewaren hetzelfde te doen.
De posities van het bijwerken verschillende sprites op het bord.
Je dingen wilt houden bewegen allen tijde,
maar je weet niet wanneer de gebruiker gaat stoppen met spelen
of wanneer ze gaan van leven te lopen.
Dus een tijdje lus is echt goed voor iets dergelijks.
Dat is een goed use case.
>> Voor een doe while lus, het is redelijk vergelijkbaar.
U wilt een lus om een ​​onbekende herhalen aantal keren, maar ten minste eenmaal.
Je kan dit gebruiken voor een spel ook, maar een echt gemeenschappelijke use case
is dat de gebruiker voor input.
In het algemeen zou je iets te zeggen als, geef mij een positief geheel getal,
en je zou kunnen brengen dat binnenkant van een do while lus.
Dus het zal ze altijd vragen op tenminste eenmaal voor een positief geheel getal.
Als ze geven je een positief geheel getal, je zou uit de lus te breken.
Je zou kunnen worden gedaan.
De Booleaanse expressie in het doen terwijl misschien vals.
>> En je zal ze niet meer vragen.
Als ze geven u een negatief getal, waar ze typt een woord of iets dat
niet echt nuttig u, zou u gebruik maken van de
do while lus om terug te gaan en te doen het opnieuw en opnieuw en opnieuw.
U zeker wilt vragen ze geven u een aantal keer,
maar je weet niet hoe vaak waarna ze misschien plagen.
En dus doen terwijl het is een groot gebruik geval voor dat de gebruiker voor input.
En een voor loops gebruiken geval is meestal wanneer
U wilt een lus herhalen een discreet aantal keren
hoewel je misschien niet weet het aantal keren
het moment dat het programma wordt gecompileerd.
>> Dus bijvoorbeeld, misschien heb je een programma waar u de gebruiker voor een aantal vragen.
En ze in 100.
En dan is uw lus zal In dat geval lopen 100 keer.
Of misschien zijn ze in te voeren 1000 in het programma
en vervolgens de lus 1000 keer.
Het is een bepaald aantal keren.
Ze doen niet noodzakelijkerwijs weten wat dat getal
is het moment dat het programma wordt samengesteld.
Het is niet zoals een tijdje lus wanneer het kan oneindig.
Het is nogal een aantal dat je gewoon niet weten.
Nu hoewel ik heb geschetst al deze use cases,
je moet weten dat in de mooie veel elke omstandigheid,
U kunt alle wisselen drie van deze lussen.
U kunt gebruik maken van een lus waar je anders gebruik maken van een while lus.
U kunt gebruik maken van een lus waar je zou een do while lus en ga zo maar door.
Het kan soms een beetje lastig zijn, dus over het algemeen is het een goede gewoonte
zich te houden aan een typische use case.
Gebruik een do while lus als je wilde iets een keer, tenminste.
Gebruik een lus als je wilt doen iets een bepaald aantal keren.
Immers, dat is de reden waarom er drie verschillende soorten lussen.
>> Zo kunnen ze worden gebruikt in de juiste context.
Maar je kunt wisselen ze als je wilt.
Als je je comfortabel voelt terwijl loops en je altijd wilt gebruiken terwijl loops.
Het is iets dat je kunt doen, maar het
misschien een beetje syntactisch zijn lastig, waarbij een lus
zou een stuk eenvoudiger zijn.
>> Mijn naam is Doug Lloyd en dit is CS50.