{{index ["if keyword", chaining]}}

If we have more than two paths to choose from, multiple `if`/`else`

{{index syntax, "while loop", "counter variable"}}

Many loops follow the pattern seen in the `while` examples. First, a

comes a `while` loop, whose test expression usually checks whether the

counter has reached its end value. At the end of the loop body, the

counter is updated to track progress.

This program is exactly equivalent to the

[earlier](program_structure#loops) even-number-printing example. The

only change is that all the ((statement))s that are related to the

The ((parentheses)) after a `for` keyword must contain two

((semicolon))s. The part before the first semicolon _initializes_ the

{{index assignment, "+= operator", "-= operator", "/= operator", "*= operator", state, "side effect"}}

to hold a value based on that binding's previous value.

```{test: no}

{{index "|| operator", ["if keyword", chaining]}}

The second version of the program has a straightforward solution and a

precisely test the given condition. For the clever method, build up a

string containing the word or words to output, and print either this

word or the number if there is no word, potentially by making good use

Write a program that creates a string that represents an 8×8 grid,

using newline characters to separate lines. At each position of the

form a chess board.

Passing this string to `console.log` should show something like this:

The place where the computer stores this context is the _((call

stack))_. Every time a function is called, the current context is

the top context from the stack and uses it to continue execution.

{{index "infinite loop", "stack overflow", recursion}}

Storing this stack requires space in the computer's memory. When the

illustrates this by asking the computer a really hard question, which

causes an infinite back-and-forth between two functions. Rather, it

_would_ be infinite, if the computer had an infinite stack. As it is,

```{test: no}

{{index "call stack", "local binding", [function, "as value"], scope}}

The ability to treat functions as values, combined with the fact that

brings up an interesting question. What happens to local bindings when

the function call that created them is no longer active?

This feature—being able to reference a specific instance of local

bindings in an enclosing function—is called _((closure))_. A function

behavior not only frees you from having to worry about lifetimes of

bindings but also allows for some creative use of function values.

Recursion is not always just a inefficient alternative to looping.

Some problems are really easier to solve with recursion than with

loops. Most often these are problems that require exploring or

into more branches.

{{id recursive_puzzle}}

A useful principle is not to add cleverness unless you are absolutely

sure you're going to need it. It can be tempting to write general

Resist that urge. You won't get any real work done, you'll just end up

writing a lot of code that you'll never use.

characters have positions 0 and 1.

Write a function `countBs` that takes a string as its only argument

there are in the string.

Next, write a function called `countChar` that behaves like `countBs`,

except it takes a second argument that indicates the character that is

Rewrite `countBs` to make use of this new function.

{{if interactive

{{quote {author: "Charles Babbage", title: "Passages from the Life of a Philosopher (1864)", chapter: true}

[...] I am not able rightly to apprehend the kind of confusion of

ideas that could provoke such a question.

after the dot is the literal name of the property. When using square

brackets, the expression between the brackets is _evaluated_ to get

the property name. Whereas `value.x` fetches the property of `value`

the result as the property name.

So if you know that the property you are interested in is called

named by the value held in the binding `i`, you say `value[i]`.

Property names can be any string, and the dot notation only allows

names that look like valid binding names, so if you want to access a

`value[2]` or `value["John Doe"]`.

The elements in an ((array)) are stored as the array's properties, using

[Chapter ?](object#obj_methods).

Properties that contain functions are generally called _methods_ of

{{id array_methods}}

{{index journal, "weresquirrel example"}}

```{test: wrap}

JavaScript's `==` operator, when comparing objects, will return `true`

only if both objects are precisely the same value. Comparing different

objects will return `false`, even if they have identical contents.

looks at object's contents, but it is possible to write it yourself

(which will be one of the [exercises](data#exercise_deep_compare) at

the end of this chapter).

What we can do is _serialize_ the data. That means it is converted

into a flat description. A popular format is called _((JSON))_

is widely used as a data storage and communication format on the Web,

even in languages other than JavaScript.

{{index "optional argument"}}

As a bonus assignment, modify your `range` function to take an

up the array. If no step is given, the array elements go up by

increments of one, corresponding to the old behavior. The function

call `range(1, 10, 2)` should return `[1, 3, 5, 7, 9]`. Make sure it

{{index recursion}}

The recursive version of `nth` will, similarly, look at an ever

the index until it reaches zero, at which point it can return the

`value` property of the node it is looking at. To get the zeroeth

element of a list, you simply take the `value` property of its head

{{index [function, "as value"], [function, application]}}

This uses the argument named `test`, a function value, to fill in a

element, and its return value determines whether an element is

included in the returned array.

The `map` method transforms an array by applying a function to all of

its elements and building a new array from the returned values. The

new array will have the same length as the input array, but its

Being able to pass function values to other functions is not just a

gimmick—it's a deeply useful aspect of JavaScript. It allows us to

that calls these functions can fill in the gaps by providing function

values.

{{index "flattening (exercise)", "reduce method", "concat method", array}}

Use the `reduce` method in combination with the `concat` method to

elements of the input arrays.

{{if interactive

for defining methods. It creates a property called `speak` and gives

it a function as its value.

shared by all rabbits. An individual rabbit object, like the killer

rabbit, contains properties that apply only to itself—in this case its

type—and derives shared properties from its prototype.

differ per instance, such as our rabbits' `type` ((property)), need to

be stored directly in the objects themselves.

So in order to create an instance of a given class, you have to make

an object that derives from the proper prototype, but you _also_ have

to make sure it, itself, has the properties that instances of this

`.join(",")` on it—it puts commas between the values in the array.

Directly calling `Object.prototype.toString` with an array produces a

different string. That function doesn't know about arrays, so it

brackets.

Give the `Vec` prototype two methods, `plus` and `minus`, that take

another vector as a parameter and return a new vector that has the sum

parameter) _x_ and _y_ values.

Add a ((getter)) property `length` to the prototype that computes the

{{index "artificial intelligence", "Dijkstra, Edsger", "project chapter", "reading code", "writing code"}}

brief moment and instead work through a program with you. Theory is

indispensable when learning to program, but it is best accompanied by

reading and understanding nontrivial programs.

{{quote {author: "Joe Armstrong", title: "interviewed in Coders at Work"}

implicit environment that they carry around with them. You wanted a

banana but what you got was a gorilla holding the banana and the

entire jungle.

_Right_. Dividing 13 by 10 does not produce a whole number. Instead of

`n /= base`, what we actually want is `n = Math.floor(n / base)` so

{{index "JavaScript console", "debugger statement"}}

If exceptions always zoomed right down to the bottom of the stack,

they would not be of much use. They'd just provide a novel way to blow

up your program. Their power lies in the fact that you can set

down. Once you've caught an exception, you can do something with it to

address the problem, and then continue to run the program.

But that isn't always practical. So there is another feature that

`try` statements have. They may be followed by a `finally` block

either instead of or in addition to a `catch` block. A `finally` block

cleanup code should usually be put into a `finally` block.

```{includeCode: true}