Are there lists in JavaScript?

Chapter 4Data Structures: Objects and Arrays

On two occasions I have been asked, Pray, Mr. Babbage, if you put into the machine wrong figures, will the right answers come out? [...] I am not able rightly to apprehend the kind of confusion of ideas that could provoke such a question.

Charles Babbage, Passages from the Life of a Philosopher [1864]

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 valuesincluding other objectsto build more complex structures.

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 introduce basic data structures. By the end of it, youll know enough to start writing useful programs.

The chapter will work through a more or less realistic programming example, introducing concepts as they apply to the problem at hand. The example code will often build on functions and bindings that were introduced earlier in the text.

The weresquirrel

Every now and then, usually between 8 p.m. and 10 p.m., Jacques finds himself transforming into a small furry rodent with a bushy tail.

On one hand, Jacques is quite glad that he doesnt have classic lycanthropy. Turning into a squirrel does cause fewer problems than turning into a wolf. Instead of having to worry about accidentally eating the neighbor [that would be awkward], he worries about being eaten by the neighbors cat. After two occasions where he woke up on a precariously thin branch in the crown of an oak, naked and disoriented, he has taken to locking the doors and windows of his room at night and putting a few walnuts on the floor to keep himself busy.

That takes care of the cat and tree problems. But Jacques would prefer to get rid of his condition entirely. The irregular occurrences of the transformation make him suspect that they might be triggered by something. For a while, he believed that it happened only on days when he had been near oak trees. But avoiding oak trees did not stop the problem.

Switching to a more scientific approach, Jacques has started keeping a daily log of everything he does on a given day and whether he changed form. With this data he hopes to narrow down the conditions that trigger the transformations.

The first thing he needs is a data structure to store this information.

Data sets

To work with a chunk of digital data, well first have to find a way to represent it in our machines memory. Say, for example, that we want to represent a collection of the numbers 2, 3, 5, 7, and 11.

We could get creative with stringsafter all, strings can have any length, so we can put a lot of data into themand use "2 3 5 7 11" as our representation. But this is awkward. Youd have to somehow extract the digits and convert them back to numbers to access them.

Fortunately, JavaScript provides a data type specifically for storing sequences of values. It is called an array and is written as a list of values between square brackets, separated by commas.

let listOfNumbers = [2, 3, 5, 7, 11]; console.log[listOfNumbers[2]]; // 5 console.log[listOfNumbers[0]]; // 2 console.log[listOfNumbers[2 - 1]]; // 3

The notation for getting at the elements inside an array also uses square brackets. A pair of square brackets immediately after an expression, with another expression inside of them, will look up the element in the left-hand expression that corresponds to the index given by the expression in the brackets.

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 tradition in technology and in certain ways makes a lot of sense, but it takes some getting used to. Think of the index as the amount of items to skip, counting from the start of the array.

Properties

Weve seen a few suspicious-looking expressions like myString.length [to get the length of a string] and Math.max [the maximum function] in past chapters. These are expressions that access a property of some value. In the first case, we access the length property of the value in myString. In the second, we access the property named max in the Math object [which is a collection of mathematics-related constants and functions].

Almost all JavaScript values have properties. The exceptions are null and undefined. If you try to access a property on one of these nonvalues, you get an error.

null.length; // TypeError: null has no properties

The two main ways to access properties in JavaScript are with a dot and with square brackets. Both value.x and value[x] access a property on valuebut not necessarily the same property. The difference is in how x is interpreted. When using a dot, the word 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 named x, value[x] tries to evaluate the expression x and uses the result, converted to a string, as the property name.

So if you know that the property you are interested in is called color, you say value.color. If you want to extract the property named by the value held in the binding i, you say value[i]. Property names are strings. They can be any string, but the dot notation works only with names that look like valid binding names. So if you want to access a property named 2 or John Doe, you must use square brackets: value[2] or value["John Doe"].

The elements in an array are stored as the arrays properties, using numbers as property names. Because you cant use the dot notation with numbers and usually want to use a binding that holds the index anyway, you have to use the bracket notation to get at them.

The length property of an array tells us how many elements it has. This property name is a valid binding name, and we know its name in advance, so to find the length of an array, you typically write array.length because thats easier to write than array["length"].

Methods

Both string and array values contain, in addition to the length property, a number of properties that hold function values.

let doh = "Doh"; console.log[typeof doh.toUpperCase]; // function console.log[doh.toUpperCase[]]; // DOH

Every string has a toUpperCase property. When called, it will return a copy of the string in which all letters have been converted to uppercase. There is also toLowerCase, going the other way.

Interestingly, even though the call to toUpperCase does not pass any arguments, the function somehow has access to the string "Doh", the value whose property we called. How this works is described in Chapter 6.

Properties that contain functions are generally called methods of the value they belong to, as in toUpperCase is a method of a string.

This example demonstrates two methods you can use to manipulate arrays:

let sequence = [1, 2, 3]; sequence.push[4]; sequence.push[5]; console.log[sequence]; // [1, 2, 3, 4, 5] console.log[sequence.pop[]]; // 5 console.log[sequence]; // [1, 2, 3, 4]

The push method adds values to the end of an array, and the pop method does the opposite, removing the last value in the array and returning it.

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 opposite order so that the thing that was added last is removed first. These are common in programmingyou might remember the function call stack from the previous chapter, which is an instance of the same idea.

Objects

Back to the weresquirrel. A set of daily log entries can be represented as an array. But the entries do not consist of just a number or a stringeach entry needs to store a list of activities and a Boolean value that indicates whether Jacques turned into a squirrel or not. Ideally, we would like to group these together into a single value and then put those grouped values into an array of log entries.

Values of the type object are arbitrary collections of properties. One way to create an object is by using braces as an expression.

let day1 = { squirrel: false, events: ["work", "touched tree", "pizza", "running"] }; console.log[day1.squirrel]; // false console.log[day1.wolf]; // undefined day1.wolf = false; console.log[day1.wolf]; // false

Inside the braces, there is a list of properties separated by commas. Each property has a name followed by a colon and a value. When an object is written over multiple lines, indenting it like in the example helps with readability. Properties whose names arent valid binding names or valid numbers have to be quoted.

let descriptions = { work: "Went to work", "touched tree": "Touched a tree" };

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 useful to start a statement with an object in braces, so the ambiguity between these two is not much of a problem.

Reading a property that doesnt exist will give you the value undefined.

It is possible to assign a value to a property expression with the = operator. This will replace the propertys value if it already existed or create a new property on the object if it didnt.

To briefly return to our tentacle model of bindingsproperty bindings are similar. They grasp values, but other bindings and properties might be holding onto those same values. You may think of objects as octopuses with any number of tentacles, each of which has a name tattooed on it.

The delete operator cuts off a tentacle from such an octopus. It is a unary operator that, when applied to an object property, will remove the named property from the object. This is not a common thing to do, but it is possible.

let anObject = {left: 1, right: 2}; console.log[anObject.left]; // 1 delete anObject.left; console.log[anObject.left]; // undefined console.log["left" in anObject]; // false console.log["right" in anObject]; // true

The binary in operator, when applied to a string and an object, tells you whether that object has a property with that name. The difference between setting a property to undefined and actually deleting it is that, in the first case, the object still has the property [it just doesnt have a very interesting value], whereas in the second case the property is no longer present and in will return false.

To find out what properties an object has, you can use the Object.keys function. You give it an object, and it returns an array of stringsthe objects property names.

console.log[Object.keys[{x: 0, y: 0, z: 2}]]; // ["x", "y", "z"]

Theres an Object.assign function that copies all properties from one object into another.

let objectA = {a: 1, b: 2}; Object.assign[objectA, {b: 3, c: 4}]; console.log[objectA]; // {a: 1, b: 3, c: 4}

Arrays, then, are just a kind of object specialized for storing sequences of things. If you evaluate typeof [], it produces "object". You can see them as long, flat octopuses with all their tentacles in a neat row, labeled with numbers.

We will represent the journal that Jacques keeps as an array of objects.

let journal = [ {events: ["work", "touched tree", "pizza", "running", "television"], squirrel: false}, {events: ["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], squirrel: false}, {events: ["weekend", "cycling", "break", "peanuts", "beer"], squirrel: true}, /* and so on... */ ];

Mutability

We will get to actual programming real soon now. First theres one more piece of theory to understand.

We saw that object values can be modified. The types of values discussed in earlier chapters, such as numbers, strings, and Booleans, are all immutableit is impossible to change values of those types. You can combine them and derive new values from them, but when you take a specific string value, that value will always remain the same. The text inside it cannot be changed. If you have a string that contains "cat", it is not possible for other code to change a character in your string to make it spell "rat".

Objects work differently. You can change their properties, causing a single object value to have different content at different times.

When we have two numbers, 120 and 120, we can consider them precisely the same number, whether or not they refer to the same physical bits. With objects, there is a difference between having two references to the same object and having two different objects that contain the same properties. Consider the following code:

let object1 = {value: 10}; let object2 = object1; let object3 = {value: 10}; console.log[object1 == object2]; // true console.log[object1 == object3]; // false object1.value = 15; console.log[object2.value]; // 15 console.log[object3.value]; // 10

The object1 and object2 bindings grasp the same object, which is why changing object1 also changes the value of object2. They are said to have the same identity. The binding object3 points to a different object, which initially contains the same properties as object1 but lives a separate life.

Bindings can also be changeable or constant, but this is separate from the way their values behave. Even though number values dont change, you can use a let binding to keep track of a changing number by changing the value the binding points at. Similarly, though a const binding to an object can itself not be changed and will continue to point at the same object, the contents of that object might change.

const score = {visitors: 0, home: 0}; // This is okay score.visitors = 1; // This isn't allowed score = {visitors: 1, home: 1};

When you compare objects with JavaScripts == operator, it compares by identity: it will produce true only if both objects are precisely 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, but it is possible to write it yourself [which is one of the exercises at the end of this chapter].

The lycanthropes log

So, Jacques starts up his JavaScript interpreter and sets up the environment he needs to keep his journal.

let journal = []; function addEntry[events, squirrel] { journal.push[{events, squirrel}]; }

Note that the object added to the journal looks a little odd. Instead of declaring properties like events: events, it just gives a property name. This is shorthand that means the same thingif a property name in brace notation isnt followed by a value, its value is taken from the binding with the same name.

So then, every evening at 10 p.m.or sometimes the next morning, after climbing down from the top shelf of his bookcaseJacques records the day.

addEntry[["work", "touched tree", "pizza", "running", "television"], false]; addEntry[["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], false]; addEntry[["weekend", "cycling", "break", "peanuts", "beer"], true];

Once he has enough data points, he intends to use statistics to find out which of these events may be related to the squirrelifications.

Correlation is a measure of dependence between statistical variables. A statistical variable is not quite the same as a programming variable. In statistics you typically have a set of measurements, and each variable is measured for every measurement. Correlation between variables is usually expressed as a value that ranges from -1 to 1. Zero correlation means the variables are not related. A correlation of one indicates that the two are perfectly relatedif you know one, you also know the other. Negative one also means that the variables are perfectly related but that they are oppositeswhen one is true, the other is false.

To compute the measure of correlation between two Boolean variables, we can use the phi coefficient [ϕ]. This is a formula whose input is a frequency table containing the number of times the different combinations of the variables were observed. The output of the formula is a number between -1 and 1 that describes the correlation.

We could take the event of eating pizza and put that in a frequency table like this, where each number indicates the amount of times that combination occurred in our measurements:

If we call that table n, we can compute ϕ using the following formula:

[If at this point youre putting the book down to focus on a terrible flashback to 10th grade math classhold on! I do not intend to torture you with endless pages of cryptic notationits just this one formula for now. And even with this one, all we do is turn it into JavaScript.]

The notation n01 indicates the number of measurements where the first variable [squirrelness] is false [0] and the second variable [pizza] is true [1]. In the pizza table, n01 is 9.

The value n1 refers to the sum of all measurements where the first variable is true, which is 5 in the example table. Likewise, n0 refers to the sum of the measurements where the second variable is false.

So for the pizza table, the part above the division line [the dividend] would be 1×764×9 = 40, and the part below it [the divisor] would be the square root of 5×85×10×80, or 340000. This comes out to ϕ 0.069, which is tiny. Eating pizza does not appear to have influence on the transformations.

Computing correlation

We can represent a two-by-two table in JavaScript with a four-element array [[76, 9, 4, 1]]. We could also use other representations, such as an array containing two two-element arrays [[[76, 9], [4, 1]]] or an object with property names like "11" and "01", but the flat array is simple and makes the expressions that access the table pleasantly short. Well interpret the indices to the array as two-bit binary numbers, where the leftmost [most significant] digit refers to the squirrel variable and the rightmost [least significant] digit refers to the event variable. For example, the binary number 10 refers to the case where Jacques did turn into a squirrel, but the event [say, pizza] didnt occur. This happened four times. And since binary 10 is 2 in decimal notation, we will store this number at index 2 of the array.

This is the function that computes the ϕ coefficient from such an array:

function phi[table] { return [table[3] * table[0] - table[2] * table[1]] / Math.sqrt[[table[2] + table[3]] * [table[0] + table[1]] * [table[1] + table[3]] * [table[0] + table[2]]]; } console.log[phi[[76, 9, 4, 1]]]; // 0.068599434

This is a direct translation of the ϕ formula into JavaScript. Math.sqrt is the square root function, as provided by the Math object in a standard JavaScript environment. We have to add two fields from the table to get fields like n1 because the sums of rows or columns are not stored directly in our data structure.

Jacques kept his journal for three months. The resulting data set is available in the coding sandbox for this chapter, where it is stored in the JOURNAL binding and in a downloadable file.

To extract a two-by-two table for a specific event from the journal, we must loop over all the entries and tally how many times the event occurs in relation to squirrel transformations.

function tableFor[event, journal] { let table = [0, 0, 0, 0]; for [let i = 0; i