>> DOUG LLOYD: Okay, så lad os tale om sløjfer.
Så loops er slags cool fordi de tillader dit program
at udføre linjer kode igen og igen og igen.
Gentagne gange, uden at skulle kopiere og indsæt eller på anden måde gentage dem.
Der er tre store former for løkker, du vil se.
Du vil sandsynligvis have lejlighed til at bruge hver enkelt som du fremskridt gennem CS50.
Nogle af disse sløjfer er temmelig velkendt for dig fra bunden,
så igen, som vi gjorde med betingede, vi vil sætte dem op ved siden af ​​hinanden
hvis der er en analogi, vi kan tegne.
>> Først er for evigt fra bunden, der sammenlignes med, mens (sand).
Dette er, hvad vi kalder en uendelig løkke.
De linjer kode mellem krøllede seler, ligesom puslespilsbrikker
der passer inde i C af evigt blokere,
vil udføre gentagne gange fra top til bund, igen og igen og igen,
evigt.
Efter alt, hvis du husker vores diskussion af Boolske udtryk,
sandt, er altid sandt.
Så hvis vi laver noget, så længe sand
er true-- det virker lidt Silly-- sandt er altid sandt, så det vil altid køre.
Det vil køre for evigt og evigt og altid, indtil vi
finde en måde at bryde ud af det med en pause erklæring, som igen,
vi så for lidt siden vi talte om kontakten.
>> Eller på anden måde bare dræbe vores program, som i øvrigt,
hvis du nogensinde finde dig selv i en Situationen med en uendelig løkke
og du ved ikke, hvordan at stoppe dit program fra at køre.
Bare hit kontrol og C, og der vil dræbe din program for dig.
Men dette er igen kaldes en uendelig løkke.
Det er en løkke, der løber evigt.
Nu, mens loops er ikke altid uendelig, fordi også
vi kan erstatte den booleske ekspression med noget
lidt mere nyttigt end blot sandt.
Så her er et andet eksempel.
Mens nogle boolesk og udtryk og derefter krøllede parenteser.
Det er temmelig meget analog gentage indtil, fra bunden.
Selv i en anden, vil jeg forklare forskellen.
>> Så i C, hvis Boolsk udtryk indersiden af ​​while-løkke
evaluerer til sand, i retning af kode mellem de krøllede parenteser
vil udføre gentagne gange over og over og igen, indtil Boolsk udtryk
evalueres til falsk.
Så for eksempel kan du har en slags tæller.
Så siger du i starten af denne løkke sige int x er lig med nul.
Mens x er mindre end 100, skal du gøre et par ting inde at krøllede parenteser,
så i slutningen af ​​din løkke, siger du x plus plus, er du forøge x.
Til sidst x får til 100, og du vil
stopper fordi betingelsen x er mindre end 100
vil ikke længere være sandt som snart x er lig med 100.
100 ikke er mindre end 100.
>> Nu noget forvirrende, adfærd af bunden blokken er vendt.
Så være virkelig forsigtig, hvis dette er din første strejftog i at bruge sløjfer.
Dybest set, gentagelse indtil blok i Scratch
vil gentage noget igen og igen og igen,
indtil udtrykket, den booleske udtryk i sekskant er sandt.
Så det vil holde gør det, indtil det er sandt.
I mellemtiden, mens sløjfen fortsætte med at gøre det, indtil det er falsk.
Så de er helt ens, men der er den lille forskel bare
at være forsigtig med, især som du gør din første strejftog fra overgangen
at ridse i c.
Den næste slags løkke er faktisk temmelig ens.
Det hedder gøre, mens løkken.
Denne løkke vil udføre alle linjer kode mellem de krøllede parenteser én gang,
og så vil det kontrollere den boolsk udtryk.
Hvis Boolsk udtryk evalueres til sand,
Det vil gå tilbage og gentage denne proces igen og igen
og igen, indtil den booleske udtryk evalueres til falsk.
Så denne løkke, i modsætning til en while-løkke, er garanteret at køre mindst én gang.
Dette kan være temmelig nyttig.
>> Endelig har vi en for-løkke.
For loops er slags syntaktisk utiltrækkende
og der er en masse i gang på her, så bær over med mig
som vi forsøger og bryde disse stykker fra hinanden.
Generelt brugstilfældet af en for-løkke er dig
ønsker at gentage noget bestemt antal gange.
I dette eksempel her, Jeg har den gentage blok
fra bunden, hvilket er analog til for-løkken
i C, gentage noget 10 gange.
Og for-løkken om venstre der, som
er en fire løkke, ville gøre det samme.
Dette ville gå 10 gange.
Tælle fra nul, vi tilvækst hvert gennemløb af løkken.
Og vi holde gør, at indtil jeg er mindre end 10.
>> Så hvad sker der?
Der er en hel masse kode der.
Lad os bryde det ned til hvad der sker trin
trin som vi grave gennem en for-løkke.
Det første, der skete, er tællervariablen er centrum.
Alt til venstre for den første semikolon i parentes
udføres.
I dette tilfælde er vi siger int i er lig med 0.
Erklære en ny variabel kaldet i, at variabler er en type heltal
og vi siger værdien inde variablen bliver nul.
>> Den anden ting, vi gør, er vi derefter straks evaluere
den boolsk udtryk.
Boolsk udtryk er i midt mellem de to semikoloner.
I er mindre end 10.
Det er sandt her, ikke?
Vi har lige sagt i er lig med nul, og så 0 er mindre end 10,
og således at betingelsen er sandt, og vi vil nu
Fortsæt at udføre kroppen af ​​løkken.
Hvis det var falske.
Hvis, for eksempel, sagde jeg i stedet for Jeg er lig med 0 der jeg sagde, jeg er lig 15,
int i lig 15.
Nå 15 ikke er mindre end 10, så vi ville aldrig ind i kroppen af ​​løkken
fordi Boolsk udtryk der ville vurdere at være falsk.
>> Efter at vi går igennem fra top til bund, vi støder på, at lukke krøllet tandbøjle,
en tredje ting sker.
Tælleren variabel er øges, eller rettere, linjerne
kode af en erklæring efter andet semikolon indersiden af
efter sløjfer parenteser udføres.
Så vi starter ud ved siger int i er lig med 0.
Så tjekker vi, om den booleske udtryk er sandt.
0 er mindre end 10, så det er sandt.
Så vi kommer til at fortsætte i kroppen løkken.
Ting vil ske inde i løkken, og når vi støder på, at lukning krøllet
tandbøjle, den næste ting, vi gøre, er vi siger jeg plus, plus.
Jeg var nul nu jeg er en.
Derefter har vi igen kontrollere værdien af den boolsk udtryk i midten.
Den ene er mindre end 10.
Så vi vil gå gennem denne behandle igen og igen.
Vi vil komme til lukning krøllet klammeparentes igen.
Vi vil forøge i fra 1 til 2 og fra 2 til 3.
Og så videre og så videre og så videre, indtil sidst jeg værdi bliver 10.
Er 10 mindre end 10?
Nej.
Tælle fra 0, har vi gået gennem 10 iterationer af loop.
Vi har gentaget 10 gange, bare som vi gjorde i Scratch blokken.
Og så det er dybest set den fremgangsmåde til en fire sløjfe.
>> Nu tager væk faktiske kode og sætte det
på bare nogle grundlæggende generelle udsagn.
Her er hvad der sker.
Alle udsagn i starte udføres først.
Du har måske mere end én.
Derefter Boolsk udtryk kontrolleret.
Hvis udtrykket evalueres til sand, udføre kroppen løkken én gang.
Hvis udtrykket evalueres til falsk, vi gjort.
Vi har ikke udføre krop af løkken på alle.
Efter at vi har gennemført den organ løkken én gang,
vi så gør, hvad der er i tilvækst del der.
Som normalt vil være noget som jeg plus, plus
eller sådan noget, at modificerer en tæller variabel.
Så efter vi tilvækst, vi kontrollere ekspressionen igen
og gentag disse trin igen og igen og igen, indtil udtrykket er
ikke længere tilfældet.
>> Så hvad er tilfælde for en løkke brug?
Brug du bruger en while-løkke, når du vil have en løkke til at gentage
et ukendt antal gange, men det eventuelt kan ikke køre alle.
En rigtig almindeligt eksempel på et stykke looping anvendes
er at køre flow for et spil kontrol.
Du kan ikke vide, hvor længe bruger vil være at spille,
men du ønsker at holde gøre det samme.
Opdatering holdninger forskellige sprites på brættet.
Du ønsker at holde tingene i konstant bevægelse,
men du ved ikke, hvornår det bruger kommer til at stoppe med at spille
eller når de kommer at løbe tør for liv.
Så en while-løkke er virkelig god til sådan noget.
Det er en god brug sag.
>> For en gør while-løkke, det er ret ens.
Du ønsker en løkke til at gentage en ukendt antal gange, men mindst én gang.
Du kan bruge dette til et spil også, men en virkelig fælles brug tilfælde
er at spørge brugeren om input.
Generelt kan man sige noget lignende, giv mig et positivt heltal,
og du kan sætte det indersiden af ​​en gør while-løkke.
Så det vil altid spørge dem på mindst én gang for et positivt heltal.
Hvis de giver dig et positivt heltal, du kan bryde ud af løkken.
Du kan blive gjort.
Den boolesk udtryk i den gøre, mens kan være falske.
>> Og du vil ikke bede dem igen.
Hvis de giver dig et negativt tal, hvor de skrive nogle ord eller noget, der er
ikke rigtig nyttigt at dig, kan du bruge
gøre, mens løkke til at gå tilbage og gøre det igen og igen og igen.
Du helt sikkert vil spørge dem til at give dig en række én gang,
men du ved ikke, hvor mange gange efter at de kunne være skadedyr.
Og så en gør, mens det er en stor brug tilfældet for at spørge brugeren om input.
Og en efter sløjfer bruger tilfælde typisk er, når
du ønsker at gentage en løkke et diskret antal gange,
selvom du måske ikke kender antallet af gange
det tidspunkt, hvor programmet kompileres.
>> Så for eksempel, måske du har et program hvor du bede brugeren om et nummer.
Og de kommer ind 100.
Og så din for sløjfen i så fald køre 100 gange.
Eller måske de ind 1.000 i dit program
og derefter køre løkken 1.000 gange.
Det er et bestemt antal gange.
De gør ikke nødvendigvis ved, hvad det nummer
er det øjeblik programmet er kompileret.
Det er ikke som en while-løkke hvor det kunne være uendelig.
Det er snarere en række at du bare ikke kender.
Nu selvom jeg har skitseret alle disse use cases,
du skal vide, at i smuk meget hver omstændighed,
du kan udveksle alle tre af disse sløjfer.
Du kan bruge en for-løkke, hvor du ellers ville bruge en while-løkke.
Du kan bruge en for-løkke, hvor det du ville bruge en gør while-løkke og så videre.
Det kan være lidt tricky til tider, så generelt er det en god praksis
at holde sig til en typisk brug sag.
Brug en gør mens løkke, hvis du ønskede noget én gang, i hvert fald.
Brug en for-løkke, hvis du ønsker at gøre noget et bestemt antal gange.
Efter alt, det er derfor der er tre forskellige slags løkker.
>> Så de kan bruges i den rette kontekst.
Men du kan udveksle dem, hvis du ønsker.
Hvis du føler dig tryg med, mens sløjfer og du altid ønsker at bruge, mens sløjfer.
Det er noget, du kan gøre, selv om det
kan være lidt syntaktisk tricky, hvor en for-løkke
ville være meget mere ligetil.
>> Mit navn er Doug Lloyd og det er CS50.