Intro to While Loops | Computer Programming | Khan Academy

Reden wir über Schleifen. Ich habe hier eine while-Schleife, und mit einigen wenigen Zeilen Code kann ich den Bildschirm mit dieser Ausgabe füllen.

Wenn ich die Ausgabe ändere, damit sie besser ausschaut,

ändern sich alle Zeilen!

Wie funktioniert das denn? Wir schauen uns den Code gleich an,

aber gehen wir mal einen Schritt zurück und überlegen, wie wir dieses Programm

nur mit dem, was wir schon über Schleifen wissen, schreiben könnten.

Dazu müssten wir ja einfach den Ausgabetext wieder und wieder und wieder schreiben, oder?

Wir sagen, text, message, am Anfang, und dann müssten wir nur noch

das Ganze oft genug wiederholen,
bis der Bildschirm voll ist.

Das ist aber eine Menge Arbeit, nicht?

Weil der untere Bildschirmrand weit entfernt ist. Und es wird schlimmer, wenn

du mich dann darauf hinweisen würdest, dass 70 zu viel ist, es solle enger sein,

etwa 60. Das beeinflusst das nächste, es muss ja dann auch enger sein,

und so weiter, je mehr Aufrufe wir von text haben.

Tatsächlich bräuchten wir so noch länger, bis wir unten ankommen.

Das Ganze ist echt nervig, und zum Glück haben wir Schleifen, die uns helfen können.

Ab jetzt solltest du, jedes Mal wenn du solchen wiederholten Code siehst, als Erstes

denken, "Könnte ich eine Schleife verwenden?" Mit einer Schleife kann man diesen Codeabschnitt wieder und wieder und

wieder laufen lassen, und jedes Mal nur kleine Veränderungen machen. Also

könnten wir diesen Code mit einer Schleife neu schreiben. Als Erstes geben wir "while" ein,

dann die Klammern, und die geschweiften Klammern. Wir bekommen diese Warnung,

aber das kommt daher, dass wir noch nicht fertig sind. Keine Sorge, die wird verschwinden, sobald wir alles eingegeben haben.

Immer, wenn du eine Schleife schreibst, muss du drei wichtige Fragen beantworten.

Hier sind sie. Erstens,

"Was soll wiederholt werden?" Alles, was

wiederholt werden soll, kommt zwischen die geschweiften Klammern.

Hier wollen wir den text-Aufruf wiederholen, also stecken wir den hinein.

Das ist aber etwas doof, oder? Weil so werden wir nur exakt das Gleiche

wieder und wieder ausführen, was uns nichts bringt - etwas muss sich von Aufruf zu Aufruf ändern.

Das bringt uns zur nächsten Frage: "Was möchte ich jedes Mal ändern?"

Wir wollen hier diese "y"-Position ändern, oder? Wir wollen, dass sie den Wert 60 und

dann den Wert 80 einnimmt. Also machen wir sie zur Variablen,

die wir "y" nennen, weil es ja die y-Position ist. Also deklarieren wir mal eine Variable

hier oben. Ich beginne sie bei 40. Jetzt müssen wir nur noch

jedes Mal y ändern. Das machen wir hier unten, wir können sagen, "y wird zu y +

20" und es wird mit jedem Mal größer. Tatsächlich können wir unsere

Lektion "Inkrementoperatoren" nutzen. Wir können einfach

den Shortcut benutzen. Fantastisch! Jetzt müssen wir nur noch

die dritte Frage beantworten: "Wie lang sollen wir das wiederholen"?

Wir wollen es ja wieder und wieder und wieder ausführen, aber nicht wirklich ewig, oder?

Wenn wir es ewig tun wollen, dauert es erstens ziemlich lange, und zweitens könnte es deinen Browser zum Absturz bringen.

Hoffentlich also nicht. Wir wollen eigentlich nur

das Ganze so lange ausführen, bis wir zum unteren Rand der Seite kommen, oder? Also wollen wir es ausführen,

solange y kleiner als 400 ist. Also stecken wird das einfach hier hinein,

und das war's schon! Wir haben unsere Ausgabe bis ganz nach unten auf dem Bildschirm.

Offensichtlich ist das viel einfacher, als unser vorheriger Ansatz, für den wir etwa

genauso lang gebraucht haben, aber nicht mal zu einem Viertel fertig waren.

Diesen Code können wir jetzt löschen,
und hier haben wir nun unser Programm.

Versuchen wir mal, besser zu verstehen, was hier passiert. Dazu werde ich

y jedes Mal ausgeben lassen. Ich sage, "y is now" (also "y ist jetzt"), und da unten

hefte ich einfach y an das Ende der Ausgabe, damit wir es sehen können.

Im Moment ändert sich der Wert um 20, und wir können das ändern,

einfach indem wir diese Variable hier verändern. Oder wir können es auf, was weiß ich,

50 einstellen. Und jetzt ändern sie sich um 50. Genauso

kannst du mit diesen anderen Werten herumspielen und sie ändern. Und

du kannst sehen, wie dadurch beeinflusst wird, wo das Programm anhält.

Um das zu verstehen, kannst du es dir eigentlich wie eine Art

"if"-Bedingung vorstellen. Wir haben hier unsere Boolsche Bedingung,

genauso wie du es gelernt hast. Dann haben wir den Körper des Ausdrucks,

dieser Teil wird nur ausgeführt, falls der Boolean wahr ist, sonst springen wir einfach

zum Ende. Was aber interessant ist, ist dass in einer while-Schleife wir in Wirklichkeit

am Ende insgeheim dieses Ding haben, dass sagt, "geh zurück zum Anfang

der Schleife". Was diese geheime Anweisung bedeutet, ist, dass

statt die Schleife zu verlassen und einfach weiterzumachen, wie bei einer "if"-Bedingung,

jedes mal, wenn wir der Körper der Schleife ausführen, gehen wir zurück und schauen,

ob die Bedingung immer noch wahr ist. Falls sie es ist, werden wir die Schleife einfach noch einmal

wiederholen. Wie du vermutlich schon erraten hast, machen wir das Gleiche bei der zweiten Wiederholung -

wir gehen zurück zum Anfang und prüfen - "Hey, ist y immer noch kleiner als

279?" Falls es kleiner ist, werden wir die Schleife noch einmal wiederholen und weiter prüfen.

Und falls es nicht kleiner ist, gehen wir zurück zum Start hier und können schließlich

die Schleife verlassen und mit unserem Programm weitermachen.

Voll gut! Es gibt eine Menge anderer interessanter Möglichkeiten, wie man Schleifen benutzen kann, die wir uns bald anschauen werden, aber

im Moment hast du damit erst einmal eine super Einführung!