Wir müssen oft mehrmals hintereinander ähnliche Aktionen ausführen. Zum Beispiel, wenn wir Waren nacheinander aus einer Liste ausgeben müssen andere. Oder führen Sie einfach den gleichen Code für jede Zahl von 1 bis 10 aus.
Schleifen sind eine Möglichkeit, denselben Teil des Codes mehrmals zu wiederholen.
Die "while" -Schleife
Die while-Schleife hat die folgende Syntax:
while (Bedingung) {// Code // der sogenannte "Schleifenkörper"}
Während Bedingung Sein wahr (wahr), die Code läuft von der Schleifenkörper.
Die folgende Schleife erzeugt beispielsweise ich während (während) i <3:
sei i = 0; while (i <3) {// gibt 0 zurück, dann 1, dann 2 alert (i); i ++; }}
Eine einzelne Ausführung des Rumpfkörpers wird als Iteration bezeichnet. Die Schleife im obigen Beispiel führt drei Iterationen durch.
Wenn nicht i ++ en el ejemplo anterior, el bucle se repetiría (en teoría) para siempre. En la práctica, el Browser proporciona formas de detener dichos bucles, y para el JavaScript del lado del Server podemos detener el proceso.
Jeder Ausdruck oder jede Variable kann eine Schleifenbedingung sein, nicht nur ein Vergleich. Sie werden ausgewertet und bis dahin in einen Booleschen Wert konvertiert.
Zum Beispiel die kürzeste Art zu schreiben während (i! = 0) könnte sein während ich):
sei i = 3; während (i) {// wenn i 0 ist, ist die Bedingung falsch und die Schleife stoppt den Alarm (i); ich--; }}
Für einen einzelnen Leitungskörper sind keine Stützen erforderlich
Wenn der Hauptteil der Schleife nur eine Deklaration hat, können wir die Klammern {…} weglassen:
sei i = 3; während (i) Alarm (i--);
Die "do ... while" - oder Do ... While-Schleife
Die Bedingungsprüfung kann mithilfe der Syntax unter den Hauptteil der Schleife verschoben werden mach ... während:
do {// Body of the loop} while (Bedingung);
Die Schleife führt zuerst den Body aus, dann überprüft sie die Bedingung und führt sie, obwohl sie wahr ist, immer wieder aus.
Zum Beispiel:
sei i = 0; do {alert (i); i ++; } while (i <3);
Diese Form der Syntax wird selten verwendet, es sei denn, Sie möchten, dass der Hauptteil der Schleife mindestens einmal ausgeführt wird, unabhängig davon, ob die Bedingung erfüllt ist. Der andere Weg ist im Allgemeinen bevorzugt: während (…) {…}.
Die For- oder "for" -Schleife
Die for-Schleife wird am häufigsten verwendet.
Sieht es so aus:
for (Start; Bedingung; Schritt) {// ... Hauptteil der Schleife ...}
Lassen Sie uns die Bedeutung dieser Teile anhand eines Beispiels lernen. Die folgende Schleife wird für Alarm (i) von 0 bis i ausgeführt (jedoch nicht eingeschlossen) 3:
for (sei i = 0; i <3; i ++) {// gebe 0 zurück, dann 1, dann 2 alert (i); }}
Lassen Sie uns die Erklärung Teil für Teil untersuchen:
Teile
- Start i = 0 Es wird einmal beim Betreten der Schleife ausgeführt.
- Bedingung i <3 Wird vor jeder Schleifeniteration überprüft, ob die Schleife fehlschlägt, wenn sie fehlschlägt.
- Schritt i ++ Es läuft in jeder Iteration nach dem Körper, aber vor der Zustandsprüfung.
- Schleifenkörper, alert (i) Immer wieder ausführen, solange die Bedingung erfüllt ist.
Das Algorithmus de bucle general funciona así:
Beginn der Ausführung
→ (wenn die Bedingung → Laufkörper und Laufschritt)
→ (wenn die Bedingung → Laufkörper und Laufschritt)
→ (wenn die Bedingung → Laufkörper und Laufschritt)
→ ...
Wenn Sie mit Schleifen nicht vertraut sind, kann es hilfreich sein, zum Beispiel zurückzukehren und die Ausführung Schritt für Schritt auf einem Blatt Papier zu reproduzieren.
Genau das passiert in unserem Fall:
// für (let i = 0; i <3; i ++) alert (i) // Start der Ausführung let i = 0 // wenn die Bedingung → body ausführen und step ausführen if (i <3) {alert ( ich); i ++} // wenn die Bedingung → Körper ausführen und Schritt ausführen if (i <3) {alert (i); i ++} // wenn die Bedingung → Körper ausführen und Schritt ausführen if (i <3) {alert (i); i ++} // ... endet, weil jetzt i == 3
Online-Variablendeklaration
Hier die Variable «Zähler» ich es wird direkt in der Schleife deklariert. Das nennt man AnzeigeDeklaration der Variablen «online». Solche Variablen sind nur innerhalb der Schleife sichtbar.
für (sei i = 0; i <3; i ++) {alert (i); // 0, 1, 2} alert (i); // Fehler, keine solche Variable
Anstatt eine Variable zu definieren, können wir eine vorhandene verwenden:
sei i = 0; für (i = 0; i <3; i ++) {// eine vorhandene Variablenwarnung verwenden (i); // 0, 1, 2} alert (i); // 3, sichtbar, aber außerhalb der Schleife deklariert
Teile überspringen
Jeder Teil des for kann weggelassen werden.
Zum Beispiel können wir weglassen Anfang wenn wir zu Beginn des Zyklus nichts tun müssen.
Wie hier:
sei i = 0; // wir haben bereits deklariert und zugewiesen für (; i <3; i ++) {// keine Notwendigkeit, alert (i) zu "starten"; // 0, 1, 2}
Wir können auch den Schrittteil löschen:
sei i = 0; für (; i <3;) {alert (i ++); }}
Die Schleife wurde identisch mit gemacht während (i <3).
Wir können alles entfernen und so eine Endlosschleife erzeugen:
for (;;) {// wiederholt unendlich oft}
Beachten Sie, dass der Doppelpunkt; Sie müssen im for vorhanden sein, sonst wäre es ein Syntaxfehler.
Die Schleife brechen
Normalerweise wird die Schleife beendet, wenn die Bedingung falsch wird.
Wir können den Ausstieg aber jederzeit erzwingen.
Dafür gibt es eine spezielle Pausenrichtlinie.
Por ejemplo, el siguiente bucle le pide al Nutzername una serie de números, pero se «interrumpe» cuando no se ingresa ningún número:
sei sum = 0; while (true) {let value = + prompt ("Zahl eingeben", ''); if (! value) break; // (*) sum + = value; } alert ('Summe:' + Summe);
Die break-Direktive wird in der Zeile (*) ausgelöst, wenn der Benutzer eine leere Zeile eingibt oder die Eingabe abbricht. Stoppt die Schleife sofort und übergibt die Steuerung an die erste Zeile nach der Schleife. Nämlich wachsam.
Die Kombination "Endlosschleife + Unterbrechung nach Bedarf" ist ideal für Situationen, in denen der Zustand nicht am Anfang / Ende der Schleife, sondern in der Mitte oder sogar an verschiedenen Stellen des Körpers überprüft werden muss.
Fahren Sie mit der nächsten Iteration fort.
Richtlinie fortsetzen ist eine "leichtere Version" von brechen. Es stoppt nicht die gesamte Schleife. Stattdessen wird die aktuelle Iteration gestoppt und die Schleife gezwungen, eine neue zu starten (sofern die Bedingung dies zulässt).
Wir können es verwenden, wenn wir mit der aktuellen Iteration fertig sind und mit der nächsten fortfahren möchten.
Die folgende Schleife wird weiterhin verwendet, um nur ungerade Werte zu generieren:
für (sei i = 0; i <10; i ++) {// wenn wahr, überspringe den verbleibenden Teil des Körpers, wenn (i % 2 == 0) fortfährt; Alarm (i); // 1, dann 3, 5, 7, 9}
Für gerade Werte von i wird die Direktive continue verwendet, die Ausführung des Körpers wird gestoppt und die Steuerung an die nächste Iteration von for (mit der nächsten Nummer) übergeben. Der Alarm wird also nur für ungerade Werte aufgerufen.
Die Continue-Direktive hilft dabei, die Verschachtelung zu verringern.
Eine Schleife mit ungeraden Werten könnte folgendermaßen aussehen:
für (sei i = 0; i <10; i ++) {if (i % 2) {alert (i); }}
Aus technischer Sicht ist es identisch mit dem vorherigen Beispiel. Sicherlich können wir den Code stattdessen einfach in den if-Block einschließen fortsetzen.
