以下机制可以与所有循环一起使用：

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，然后只要 condition 成立就执行。例如

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

在 for 循环 中：

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

init 在循环之前执行一次，只要 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 语句会导致三个问题

以下是一个 with 语句导致代码脆弱的例子

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

您可以阻止第 (3) 行的函数调用工作，即使您没有访问数组 myData 的权限。

怎么做？通过向 Array.prototype 添加一个属性 values。例如

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

现在，第 (2) 行的代码调用的是 someArray.values.someMethod() 而不是 values.someMethod()。原因是在 with 语句内部，values 现在指的是 someArray.values，而不是第 (1) 行的局部变量了。

这不仅仅是一个思想实验：数组方法 values() 被添加到 Firefox 中，并破坏了 TYPO3 内容管理系统。Brandon Benvie 找到了问题所在。