Numbers, Booleans, and strings are the atoms that ((data)) structures

are built from. Many types of information require more than one

atom, though. _Objects_ allow us to group values—including other

The programs we have built so far have been limited by the fact that

they were operating only on simple data types. This chapter will

{{index "weresquirrel example", lycanthropy}}

((Jacques)) finds himself transforming into a small furry rodent with

a bushy tail.

The first index of an array is zero, not one. So the first element is

retrieved with `listOfNumbers[0]`. Zero-based counting has a long

it takes some getting used to. Think of the index as the amount of

items to skip, counting from the start of the array.

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

numbers as property names. Because you can't use the dot notation with

anyway, you have to use the bracket notation to get at them.

{{index ["length property", "for array"], [array, "length of"]}}

[Chapter ?](object#obj_methods).

Properties that contain functions are generally called _methods_ of

string".

{{id array_methods}}

These somewhat silly names are the traditional terms for operations on

a _((stack))_. A stack, in programming, is a ((data structure)) that

allows you to push values into it and pop them out again in the

These are common in programming—you might remember the function ((call

stack)) from [the previous chapter](functions#stack), which is an

instance of the same idea.

This means that ((braces)) have _two_ meanings in JavaScript. At

the start of a ((statement)), they start a ((block)) of statements. In

any other position, they describe an object. Fortunately, it is rarely

ambiguity between these two is not much of a problem.

{{index undefined}}

{{index "== operator", [comparison, "of objects"], "deep comparison"}}

When you compare objects with JavaScript's `==` operator, it compares

the same value. Comparing different objects will return `false`, even

if they have identical properties. There is no "deep" comparison

operation built into JavaScript, which compares objects by contents,

{{index "weresquirrel example", lycanthropy, "addEntry function"}}

environment he needs to keep his ((journal)).

```{includeCode: true}

Note that the object added to the journal looks a little odd. Instead

of declaring properties like `events: events`, it just gives a

value is taken from the binding with the same name.

climbing down from the top shelf of his bookcase—Jacques records the

day.

To compute the measure of correlation between two Boolean variables,

we can use the _phi coefficient_ (_ϕ_). This is a formula whose input

combinations of the variables were observed. The output of the formula

is a number between -1 and 1 that describes the correlation.

(If at this point you're putting the book down to focus on a terrible

flashback to 10th grade math class—hold on! I do not intend to torture

now. And even with this one, all we do is turn it into JavaScript.)

The notation [_n_~01~]{if html}[[$n_{01}$]{latex}]{if tex} indicates

is available in the [coding

sandbox](https://eloquentjavascript.net/code#4) for this chapter[

([_https://eloquentjavascript.net/code#4_](https://eloquentjavascript.net/code#4))]{if

downloadable

[file](https://eloquentjavascript.net/code/journal.js).

When a `for` loop looks like this, with the word `of` after a variable

definition, it will loop over the elements of the value given after

other data structures. We'll discuss _how_ it works in [Chapter

?](object).

there to the `events` array, the function collects every type of

event.

than the others. Eating ((peanuts)) has a strong positive effect on

the chance of turning into a squirrel, whereas brushing his teeth has

a significant negative effect.

{{index [array, searching], "indexOf method", "lastIndexOf method"}}

searches through the array from the start to the end and returns the

index at which the requested value was found—or -1 if it wasn't found.

To search from the end instead of the start, there's a similar method

The following example shows both `concat` and `slice` in action. It takes

an array and an index, and it returns a new array that is a copy of

Values of type string, number, and Boolean are not objects, and though

the language doesn't complain if you try to set new properties on

such values are immutable and cannot be changed.

{{index [string, methods], "slice method", "indexOf method", [string, searching]}}

{{id split}}

You can split a string on every occurrence of another string with

{{index array, "square brackets"}}

Square bracket array notation similarly allows the triple-dot operator

{{index "Math object", "Math.min function", "Math.max function", "Math.sqrt function", minimum, maximum, "square root"}}

functions, such as `Math.max` (maximum), `Math.min` (minimum), and

`Math.sqrt` (square root).

Many languages will stop you, or at least warn you, when you are

defining a binding with a name that is already taken. JavaScript does

this for bindings you declared with `let` or `const`

with `var` or `function`.

{{index "Math.cos function", "Math.sin function", "Math.tan function", "Math.acos function", "Math.asin function", "Math.atan function", "Math.PI constant", cosine, sine, tangent, "PI constant", pi}}

Multiplying the random number by 10 gives us a number greater than or

expression will produce, with equal chance, any number from 0 through

{{index "phi function"}}

```{test: wrap}

the outer array, containing (among other things) a binary number that

represents the position of the inner array.

computer over the network, you have to somehow convert these tangles

of memory addresses to a description that can be stored or sent. You

_could_ send over your entire computer memory along with the address

down—because the comparison that checks whether the loop is finished

needs to be `>=` rather than `<=` when counting downward.

-1, when the end of the range is smaller than the start. That way,

`range(5, 2)` returns something meaningful, rather than getting stuck

in an ((infinite loop)). It is possible to refer to previous

{{index "reversing (exercise)", "reverse method", [array, methods]}}

the order in which its elements appear. For this exercise, write two

functions, `reverseArray` and `reverseArrayInPlace`. The first,

`reverseArray`, takes an array as argument and produces a _new_ array

{{index "list (exercise)", "linked list"}}

Building up a list is easier when done back to front. So `arrayToList`

each element, add an object to the list. You can use a local binding

to hold the part of the list that was built so far and use an

assignment like `list = {value: X, rest: list}` to add an element.

to the current sublist, and the body can read its `value` property to

get the current element. At the end of an iteration, `node` moves to

the next sublist. When that is null, we have reached the end of the

{{index recursion}}

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

smaller part of the "tail" of the list and at the same time count down

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

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

node. To get element _N_ + 1, you take the _N_th element of the list

that's in this list's `rest` property.

properties have identical values. One way to do that is to ensure that

both objects have the same number of properties (the lengths of the

property lists are the same). And then, when looping over one of the

the other actually has a property by that name. If they have the same

other, they have the same set of property names.

{{index "return value"}}