The following mechanisms can be used with all loops:

A while loop:

while («condition»)
    «statement»

executes statement as long as condition holds. If condition is always true, you get an infinite loop:

while (true) { ... }

In the following example, we remove all elements of an array and log them to the console:

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

Here is the output:

a
b
c

A do-while loop:

do «statement»
while («condition»);

executes statement at least once and then as long as condition holds. For example:

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

In a for loop:

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

init is executed once before the loop, which continues as long as condition is true. You can use var in init to declare variables, but the scope of those variables is always the complete surrounding function. post_iteration is executed after each iteration of the loop. Taking all of this into consideration, the preceding loop is equivalent to the following while loop:

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

The following example is the traditional way of iterating over arrays (other possibilities are described in Best Practices: Iterating over Arrays):

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

A for loop becomes infinite if you omit all parts of the head:

for (;;) {
    ...
}

A for-in loop:

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

iterates over all property keys of object, including inherited ones. However, properties that are marked as not enumerable are ignored (see Property Attributes and Property Descriptors). The following rules apply to for-in loops:

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

This loop exists only on Firefox. Don’t use it.

In an if-then-else statement:

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

then_branch and else_branch can be either single statements or blocks of statements (see 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»
    }
}

A switch statement:

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

evaluates expression and then jumps to the case clause whose label matches the result. If no label matches, switch jumps to the default clause if it exists or does nothing otherwise.

The “operand” after case can be any expression; it is compared via === with the parameter of switch.

If you don’t finish a clause with a terminating statement, execution continues into the next clause. The most frequently used terminating statement is break. But return and throw also work, even though they normally leave more than just the switch statement.

The following example illustrates that you don’t need to break if you use throw or return:

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

In this example, there is no default clause. Therefore, nothing happens if fruit matches none of the case labels:

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

Here, there are multiple case labels in a row:

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

This example demonstrates that the value after case can be an arbitrary expression:

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

The preceding switch statement looks for a match for its parameter true by going through the case clauses. If one of the case expressions evaluates to true, the corresponding case body is executed. Therefore, the preceding code is equivalent to the following if statement:

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

You normally should prefer the latter solution; it is more self-explanatory.

The syntax of the with statement is as follows:

with («object»)
    «statement»

It turns the properties of object into local variables for statement. For example:

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

Its intended use is to avoid redundancy when accessing an object several times. The following is an example of code with redundancies:

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

with makes this shorter:

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

The use of the with statement is generally discouraged (the next section explains why). For example, it is forbidden in strict mode:

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

To understand why with is deprecated, look at the following example and notice how the function’s argument completely changes how it works:

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

If opts has a property msg, then the statement in line (1) doesn’t access the parameter msg anymore. It accesses the property:

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

There are three problems that the with statement causes:

Here is an example of with making code brittle:

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

You can prevent the function call in line (3) from working, even if you don’t have access to the array myData.

How? By adding a property values to Array.prototype. For example:

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

Now the code in line (2) calls someArray.values.someMethod() instead of values.someMethod(). The reason is that, inside the with statement, values now refers to someArray.values and not the local variable from line (1) anymore.

This is not just a thought experiment: the array method values() was added to Firefox and broke the TYPO3 content management system. Brandon Benvie figured out what went wrong.