以下のメカニズムは、すべてのループで使用できます。

whileループ：

while («condition»)
    «statement»

conditionが成立する限り、statementを実行します。conditionが常にtrueの場合、無限ループになります。

while (true) { ... }

次の例では、配列のすべての要素を削除し、コンソールに記録します。

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

出力は次のとおりです。

a
b
c

do-whileループ：

do «statement»
while («condition»);

statementを少なくとも1回実行し、その後、conditionが成立する限り実行します。次に例を示します。

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

forループ：

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

initはループの前に1回実行され、conditionがtrueである限りループは続きます。initでvarを使用して変数を宣言できますが、それらの変数のスコープは常に周囲の関数全体です。post_iterationは、ループの各反復の後に実行されます。これらをすべて考慮すると、上記のループは次のwhileループと同等です。

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

次の例は、配列を反復処理する従来の方法です（他の可能性については、ベストプラクティス：配列の反復処理を参照してください）。

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

ヘッドのすべての部分を省略すると、forループは無限になります。

for (;;) {
    ...
}

for-inループ：

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

継承されたものを含め、objectのすべてのプロパティキーを反復処理します。ただし、列挙不可としてマークされているプロパティは無視されます（プロパティ属性とプロパティ記述子を参照）。for-inループには、次の規則が適用されます。

> 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);
    }
}

このループはFirefoxにのみ存在します。使用しないでください。

if-then-elseステートメント：

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

then_branchとelse_branchは、単一のステートメントまたはステートメントのブロックにすることができます（ループと条件分岐の本体を参照）。

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»
    }
}

switchステートメント：

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

expressionを評価し、結果と一致するラベルを持つcase句にジャンプします。一致するラベルがない場合、switchは、default句が存在する場合はそこにジャンプし、そうでない場合は何も行いません。

caseの後の「オペランド」は任意の式です。===を使用してswitchのパラメータと比較されます。

句を終了ステートメントで終了しない場合、実行は次の句に続きます。最も頻繁に使用される終了ステートメントはbreakです。しかし、returnとthrowも機能します。通常はswitchステートメントだけを終了するわけではありませんが。

次の例は、throwまたはreturnを使用する場合、breakする必要がないことを示しています。

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

この例では、default句はありません。したがって、fruitがいずれのcaseラベルとも一致しない場合、何も起こりません。

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

ここでは、複数のcaseラベルが連続しています。

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);
}

この例は、caseの後の値が任意の式になることを示しています。

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

上記のswitchステートメントは、case句を調べて、パラメータtrueと一致するものを探します。case式のいずれかがtrueと評価された場合、対応するcase本文が実行されます。したがって、上記のコードは次のifステートメントと同等です。

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

通常は後者の解決策の方が望ましいです。より分かりやすいです。

withステートメントの構文は次のとおりです。

with («object»)
    «statement»

objectのプロパティを、statementのローカル変数に変換します。次に例を示します。

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

その使用目的は、オブジェクトに複数回アクセスする際の冗長性を回避することです。冗長性のあるコードの例を次に示します。

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

withを使用すると、これが短くなります。

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

withステートメントの使用は一般的に推奨されません（次のセクションでその理由を説明します）。たとえば、厳格モードでは禁止されています。

> 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));

withが非推奨とされる理由を理解するために、次の例を見て、関数の引数がどのように動作を完全に変えるかを確認してください。

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

optsにプロパティmsgがある場合、行(1)のステートメントはパラメータmsgにアクセスしなくなります。プロパティにアクセスします。

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

withステートメントによって発生する問題は3つあります。

withによってコードが脆弱になる例を次に示します。

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

配列myDataにアクセスできなくても、(3)行目の関数呼び出しが機能しないようにすることができます。

どのようにするのでしょうか？ Array.prototypeにプロパティvaluesを追加することで可能です。 例えば、

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

これで、(2)行目のコードは、values.someMethod()ではなく、someArray.values.someMethod()を呼び出すようになります。その理由は、with文の中では、valuesが(1)行目のローカル変数ではなく、someArray.valuesを参照するようになるからです。

これは単なる思考実験ではありません。配列メソッドvalues()がFirefoxに追加されたことで、コンテンツ管理システムTYPO3に障害が発生しました。Brandon Benvie氏が問題の原因を突き止めました。