Die folgenden Mechanismen können mit allen Schleifen verwendet werden:

Eine while-Schleife:

while («condition»)
    «statement»

führt statement aus, solange condition wahr ist. Wenn condition immer true ist, erhalten Sie eine Endlosschleife

while (true) { ... }

Im folgenden Beispiel entfernen wir alle Elemente eines Arrays und protokollieren sie in der Konsole

var arr = [ 'a', 'b', 'c' ];
while (arr.length > 0) {
    console.log(arr.shift());
}

Hier ist die Ausgabe

a
b
c

Eine do-while-Schleife:

do «statement»
while («condition»);

führt statement mindestens einmal aus und dann, solange condition wahr ist. Zum Beispiel

var line;
do {
    line = prompt('Enter a number:');
} while (!/^[0-9]+$/.test(line));

In einer for-Schleife:

for (⟦«init»⟧; ⟦«condition»⟧; ⟦«post_iteration»⟧)
    «statement»

init wird einmal vor der Schleife ausgeführt, die fortgesetzt wird, solange condition true ist. Sie können var in init verwenden, um Variablen zu deklarieren, aber der Scope dieser Variablen ist immer die gesamte umgebende Funktion. post_iteration wird nach jeder Iteration der Schleife ausgeführt. Wenn man all dies berücksichtigt, ist die vorherige Schleife äquivalent zur folgenden while-Schleife

«init»;
while («condition») {
    «statement»
    «post_iteration»;
}

Das folgende Beispiel ist der traditionelle Weg zur Iteration über Arrays (andere Möglichkeiten werden in Best Practices: Iterating over Arrays) beschrieben

var arr = [ 'a', 'b', 'c' ];
for (var i=0; i<arr.length; i++) {
    console.log(arr[i]);
}

Eine for-Schleife wird endlos, wenn Sie alle Teile des Kopfes weglassen

for (;;) {
    ...
}

Eine for-in-Schleife:

for («variable» in «object»)
    «statement»

iteriert über alle Eigenschaftsschlüssel von object, einschließlich vererbter. Jedoch werden Eigenschaften, die als nicht aufzählbar markiert sind, ignoriert (siehe Property Attributes and Property Descriptors). Die folgenden Regeln gelten für for-in-Schleifen

> var arr = [ 'a', 'b', 'c' ];
> for (var key in arr) { console.log(key); }
0
1
2

> var arr = [ 'a', 'b', 'c' ];
> arr.foo = true;
> for (var key in arr) { console.log(key); }
0
1
2
foo

function Person(name) {
    this.name = name;
}
Person.prototype.describe = function () {
    return 'Name: '+this.name;
};

var person = new Person('Jane');
for (var key in person) {
    console.log(key);
}

name
describe

for (var key in person) {
    if (person.hasOwnProperty(key)) {
        console.log(key);
    }
}

name

for (var key in person) {
    if (Object.prototype.hasOwnProperty.call(person, key)) {
        console.log(key);
    }
}

Diese Schleife existiert nur in Firefox. Verwenden Sie sie nicht.

In einer if-then-else-Anweisung:

if («condition»)
    «then_branch»
⟦else
    «else_branch»⟧

then_branch und else_branch können entweder einzelne Anweisungen oder Blöcke von Anweisungen sein (siehe The Bodies of Loops and Conditionals).

if (s1 > s2) {
    return 1;
} else if (s1 < s2) {
    return -1;
} else {
    return 0;
}

if («cond1») if («cond2») «stmt1» else «stmt2»

if («cond1») {
    if («cond2») {
        «stmt1»
    } else {
        «stmt2»
    }
}

Eine switch-Anweisung:

switch («expression») {
    case «label1_1»:
    case «label1_2»:
        ...
        «statements1»
        ⟦break;⟧
    case «label2_1»:
    case «label2_2»:
        ...
        «statements2»
        ⟦break;⟧
    ...
    ⟦default:
        «statements_default»
        ⟦break;⟧⟧
}

wertet expression aus und springt dann zur case-Klausel, deren Label dem Ergebnis entspricht. Wenn kein Label übereinstimmt, springt switch zur default-Klausel, falls vorhanden, oder tut nichts sonst.

Der „Operand“ nach case kann jeder Ausdruck sein; er wird über === mit dem Parameter von switch verglichen.

Wenn Sie eine Klausel nicht mit einer beendenden Anweisung abschließen, wird die Ausführung in die nächste Klausel fortgesetzt. Die am häufigsten verwendete beendende Anweisung ist break. Aber return und throw funktionieren ebenfalls, auch wenn sie normalerweise mehr als nur die switch-Anweisung verlassen.

Das folgende Beispiel verdeutlicht, dass Sie break nicht verwenden müssen, wenn Sie throw oder return verwenden

function divide(dividend, divisor) {
    switch (divisor) {
        case 0:
            throw 'Division by zero';
        default:
            return dividend / divisor;
    }
}

In diesem Beispiel gibt es keine default-Klausel. Daher geschieht nichts, wenn fruit keinem der case-Labels entspricht

function useFruit(fruit) {
    switch (fruit) {
        case 'apple':
            makeCider();
            break;
        case 'grape':
            makeWine();
            break;
        // neither apple nor grape: do nothing
    }
}

Hier gibt es mehrere case-Labels hintereinander

function categorizeColor(color) {
    var result;
    switch (color) {
        case 'red':
        case 'yellow':
        case 'blue':
            result = 'Primary color: '+color;
            break;
        case 'orange':
        case 'green':
        case 'violet':
            result = 'Secondary color: '+color;
            break;
        case 'black':
        case 'white':
            result = 'Not a color';
            break;
        default:
            throw 'Illegal argument: '+color;
    }
    console.log(result);
}

Dieses Beispiel zeigt, dass der Wert nach case ein beliebiger Ausdruck sein kann

function compare(x, y) {
    switch (true) {
        case x < y:
            return -1;
        case x === y:
            return 0;
        default:
            return 1;
    }
}

Die vorherige switch-Anweisung sucht nach einer Übereinstimmung für ihren Parameter true, indem sie die case-Klauseln durchläuft. Wenn einer der case-Ausdrücke zu true ausgewertet wird, wird der entsprechende case-Körper ausgeführt. Daher ist der vorherige Code äquivalent zur folgenden if-Anweisung

function compare(x, y) {
    if (x < y) {
        return -1;
    } else if (x === y) {
        return 0;
    } else {
        return 1;
    }
}

Normalerweise sollten Sie die letztere Lösung bevorzugen; sie ist selbsterklärender.

Die Syntax der with-Anweisung ist wie folgt

with («object»)
    «statement»

Sie verwandelt die Eigenschaften von object in lokale Variablen für statement. Zum Beispiel

var obj = { first: 'John' };
with (obj) {
    console.log('Hello '+first); // Hello John
}

Ihr beabsichtigter Verwendungszweck ist es, Redundanz zu vermeiden, wenn mehrmals auf ein Objekt zugegriffen wird. Das Folgende ist ein Beispiel für Code mit Redundanzen

foo.bar.baz.bla   = 123;
foo.bar.baz.yadda = 'abc';

with macht dies kürzer

with (foo.bar.baz) {
    bla   = 123;
    yadda = 'abc';
}

Die Verwendung der with-Anweisung wird generell abgeraten (der nächste Abschnitt erklärt warum). Sie ist zum Beispiel im Strict Mode verboten:

> function foo() { 'use strict'; with ({}); }
SyntaxError: strict mode code may not contain 'with' statements

// Don't do this:
with (foo.bar.baz) {
    console.log('Hello '+first+' '+last);
}

var b = foo.bar.baz;
console.log('Hello '+b.first+' '+b.last);

(function () {
    var b = foo.bar.baz;
    console.log('Hello '+b.first+' '+b.last);
}());

(function (b) {
    console.log('Hello '+b.first+' '+b.last);
}(foo.bar.baz));

Um zu verstehen, warum with veraltet ist, schauen Sie sich das folgende Beispiel an und beachten Sie, wie das Argument der Funktion die Funktionsweise komplett verändert:

function logMessage(msg, opts) {
    with (opts) {
        console.log('msg: '+msg); // (1)
    }
}

Wenn opts eine Eigenschaft msg hat, dann greift die Anweisung in Zeile (1) nicht mehr auf den Parameter msg zu. Sie greift auf die Eigenschaft zu

> logMessage('hello', {})  // parameter msg
msg: hello
> logMessage('hello', { msg: 'world' })  // property opts.msg
msg: world

Es gibt drei Probleme, die die with-Anweisung verursacht

Hier ist ein Beispiel dafür, wie with Code anfällig macht

function foo(someArray) {
    var values = ...;  // (1)
    with (someArray) {
        values.someMethod(...);  // (2)
        ...
    }
}
foo(myData);  // (3)

Sie können den Funktionsaufruf in Zeile (3) verhindern, selbst wenn Sie keinen Zugriff auf das Array myData haben.

Wie? Indem Sie eine Eigenschaft values zu Array.prototype hinzufügen. Zum Beispiel

Array.prototype.values = function () {
    ...
};

Jetzt ruft der Code in Zeile (2) someArray.values.someMethod() anstelle von values.someMethod() auf. Der Grund ist, dass values innerhalb der with-Anweisung jetzt someArray.values und nicht mehr die lokale Variable aus Zeile (1) bezeichnet.

Dies ist kein reines Gedankenexperiment: die Array-Methode values() wurde zu Firefox hinzugefügt und brach das TYPO3-Content-Management-System. Brandon Benvie fand heraus, was schiefgelaufen war.