Add index entries for Chapter 2

Author: marijnh

00_intro.txt

@@ -25,10 +25,10 @@ interfaces, such as instructing the computer to perform arbitrary
 tasks, we've had more luck with an approach that makes use of our
 talent for language: teaching the machine a language.
 
-Human languages allow words and sub-sentences to be combined in many,
-many ways, allowing us to say many, many different things. Computer
-languages, though typically less grammatically flexible, follow a
-similar principle.
+(((human language)))Human languages allow words and subsentences to be
+combined in many, many ways, allowing us to say many, many different
+things. Computer languages, though typically less grammatically
+flexible, follow a similar principle.
 
 (((JavaScript,availability of)))(((browser)))Casual computing has
 become become much more widespread in the past twenty years, and
@@ -385,11 +385,11 @@ browser.
 
 == Typographic conventions ==
 
-In this book, text written in a `monospaced` font should be understood
-to represent elements of programs—sometimes they are self-sufficient
-fragments, and sometimes they just refer to part of a nearby program.
-Programs (of which you have already seen a few), are written as
-follows:
+(((factorial function)))In this book, text written in a `monospaced`
+font should be understood to represent elements of programs—sometimes
+they are self-sufficient fragments, and sometimes they just refer to
+part of a nearby program. Programs (of which you have already seen a
+few), are written as follows:
 
 [source,javascript]
 ----
@@ -401,9 +401,9 @@ function fac(n) {
 }
 ----
 
-Sometimes, in order to show the output that a program produces, the
-expected output is written below it, with two slashes and an arrow in
-front:
+(((console.log)))Sometimes, in order to show the output that a program
+produces, the expected output is written below it, with two slashes
+and an arrow in front:
 
 [source,javascript]
 ----

01_values.txt

@@ -232,11 +232,12 @@ their content in quotes.
 Both single and double quotes can be used to mark strings as long as
 the quotes at the start and the end of the string match.
 
-(((newline)))Almost anything can be put between quotes, and JavaScript
-will make a string value out of it. But a few characters are more
-difficult. You can imagine how putting quotes between quotes might be
-hard. _Newlines_ (the characters you get when you press Enter) also
-can't be put between quotes. The string has to stay on a single line.
+(((newline character)))Almost anything can be put between quotes, and
+JavaScript will make a string value out of it. But a few characters
+are more difficult. You can imagine how putting quotes between quotes
+might be hard. _Newlines_ (the characters you get when you press
+Enter) also can't be put between quotes. The string has to stay on a
+single line.
 
 (((escaping,in strings)))(((backslash)))To be able to have such
 characters in a string, the following notation is used: whenever a
@@ -245,7 +246,7 @@ character after it has a special meaning. This is called _escaping_
 the character. A quote that is preceded by a backslash will not end
 the string but be part of it. When an “n” character occurs after a
 backslash, it is interpreted as a newline. Similarly, a “t” after a
-backslash means a tab character. Take the following string:
+backslash means a ((tab character)). Take the following string:
 
 [source,javascript]
 ----
@@ -494,15 +495,15 @@ console.log(false == 0)
 // → true
 ----
 
-(((+ operator)))(((arithmetic)))(((* operator)))(((- operator)))When
-an operator is applied to the “wrong” type of value, JavaScript will
-quietly convert that value to the type it wants, using a set of rules
-that often aren't what you want or expect. This is called _type
-coercion_. So the `null` in the first expression becomes `0`, and the
-`"5"` in the second expression becomes `5` (from string to number).
-Yet in the third expression, `+` tries string concatenation before
-numeric addition, so the `1` is converted to `"1"` (from number to
-string).
+(((+ operator)))(((arithmetic)))(((pass:[*] operator)))(((-
+operator)))When an operator is applied to the “wrong” type of value,
+JavaScript will quietly convert that value to the type it wants, using
+a set of rules that often aren't what you want or expect. This is
+called _((type coercion))_. So the `null` in the first expression becomes
+`0`, and the `"5"` in the second expression becomes `5` (from string
+to number). Yet in the third expression, `+` tries string
+concatenation before numeric addition, so the `1` is converted to
+`"1"` (from number to string).
 
 When something that doesn't map to a number in an obvious way (such as
 `"five"` or `undefined`) is converted to a number, the value `NaN` is
@@ -532,17 +533,17 @@ That last piece of behavior is often useful. When you want to test
 whether a value has a real value instead of `null` or `undefined`, you
 can simply compare it to `null` with the `==` (or `!=`) operator.
 
-(((=== operator)))(((!== operator)))(((comparison)))But what if you
-want to test whether something refers to the precise value `false`?
-The rules for converting strings and numbers to Boolean values state
-that `0`, `NaN`, and the empty string (`""`) count as `false`, while
-all the other values count as `true`. Because of this, expressions
-like `0 == false` and `"" == false` are also true. For cases like
-this, where you do _not_ want any automatic type conversions to
-happen, there are two extra operators: `===` and `!==`. The first
-tests whether a value is precisely equal to the other, and the second
-tests whether it is not precisely equal. So `"" === false` is false as
-expected.
+(((Boolean type,conversion to)))(((=== operator)))(((!==
+operator)))(((comparison)))But what if you want to test whether
+something refers to the precise value `false`? The rules for
+converting strings and numbers to Boolean values state that `0`,
+`NaN`, and the empty string (`""`) count as `false`, while all the
+other values count as `true`. Because of this, expressions like `0 ==
+false` and `"" == false` are also true. For cases like this, where you
+do _not_ want any automatic type conversions to happen, there are two
+extra operators: `===` and `!==`. The first tests whether a value is
+precisely equal to the other, and the second tests whether it is not
+precisely equal. So `"" === false` is false as expected.
 
 I recommend using the three-character comparison operators defensively to
 prevent unexpected type conversions from tripping you up. But when you're