Appendix 1: More (obscure) control structures

In chapter 2, a number of control statements were introduced, such as `while`, `for`, and `break`. To keep things simple, I left out some others, which, in my experience, are a lot less useful. This appendix briefly describes these missing control statements.

First, there is `do`. `do` works like `while`, but instead of executing the loop body zero or more times, it executes it one or more times. A `do` loop looks like this:

```do {
var answer = prompt("Say 'moo'.", "");

To emphasise the fact that the condition is only checked after the loop has run once, it is written at the end of the loop's body.

Next, there is `continue`. This one is closely related to `break`, and can be used in the same places. While `break` jumps out of a loop and causes the program to proceed after the loop, `continue` jumps to the next iteration of the loop.

```for (var i = 0; i < 10; i++) {
if (i % 3 != 0)
continue;
print(i, " is divisible by three.");
}```

A similar effect can usually be produced using just `if`, but there are cases where `continue` looks nicer.

When there is a loop sitting inside another loop, a `break` or `continue` statement will affect only the inner loop. Sometimes you want to jump out of the outer loop. To be able to refer to a specific loop, loop statements can be labelled. A label is a name (any valid variable name will do), followed by a colon (`:`).

```outer: for (var sideA = 1; sideA < 10; sideA++) {
inner: for (var sideB = 1; sideB < 10; sideB++) {
var hypotenuse = Math.sqrt(sideA * sideA + sideB * sideB);
if (hypotenuse % 1 == 0) {
print("A right triangle with straight sides of length ",
sideA, " and ", sideB, " has a hypotenuse of ",
hypotenuse, ".");
break outer;
}
}
}```

Next, there is a construct called `switch` which can be used to choose which code to execute based on some value. This is a very useful thing to do, but the syntax JavaScript uses for this (which it took from the C programming language) is so clumsy and ugly that I usually prefer to use a chain of `if` statements instead.

```function weatherAdvice(weather) {
switch(weather) {
case "rainy":
print("Remember to bring an umbrella.");
break;
case "sunny":
print("Dress lightly.");
case "cloudy":
print("Go outside.");
break;
default:
print("Unknown weather type: ", weather);
break;
}
}

Inside the block opened by `switch`, you can write a number of `case` labels. The program will jump to the label that corresponds to the value that `switch` was given (comparing the values with an equivalent of `===`, so without automatic type conversion), or to `default` if no matching value is found. Then it start executing statements there, and continues past other labels, until it reaches a `break` statement. In some cases, such as the `"sunny"` case in the example, this can be used to share some code between cases (it recommends going outside for both sunny and cloudy weather). Most of the time, this just adds a lot of ugly `break` statements, or causes problems when you forget to add one.

Like loops, `switch` statements can be given a label.

Finally, there is a keyword named `with`. I've never actually used this in a real program, but I have seen other people use it, so it is useful to know what it is. Code using `with` looks like this:

```var scope = "outside";
var object = {name: "Ignatius", scope: "inside"};
with(object) {
print("Name == ", name, ", scope == ", scope);
name = "Raoul";
var newVariable = 49;
}
show(object.name);
show(newVariable);```

Inside the block, the properties of the object given to `with` act as variables. Newly introduced variables are not added as properties to this object though. I assume the idea behind this construct was that it could be useful in methods that make lots of use of the properties of their object. You could start such a method with ```with(this) {...}```, and not have to write `this` all the time after that.