Put operators in regular code font

marijnh · marijnh · commit e3e1bf5986d8 · 2014-06-11T11:58:52.000+02:00
diff --git a/01_values.txt b/01_values.txt
@@ -145,7 +145,7 @@ a new number from them. Here is what they look like in JavaScript:
 100 + 4 * 11
 ----
 
-(((\* operator)))(((+ operator)))The “+” and “*” symbols are called
+(((\* operator)))(((+ operator)))The `+` and `*` symbols are called
 _operators_. The first stands for addition, and the second stands for
 multiplication. Putting an operator between two values will
 (((application,of operators)))apply it to those values and produce a
@@ -163,21 +163,21 @@ parentheses.
 ----
 
 (((division)))(((subtraction)))(((- operator)))(((/ operator)))For
-subtraction, there is the “-” operator, and division can be done with
-the “/” operator.
+subtraction, there is the `-` operator, and division can be done with
+the `/` operator.
 
 When operators appear together without parentheses, the order in which
 they are applied is determined by the _((precedence))_ of the
 operators. The example shows that multiplication comes before
-addition. “/” has the same precedence as “*”. Likewise for “+” and
-“-”. When multiple operators with the same precedence appear next to
+addition. `/` has the same precedence as `*`. Likewise for `+` and
+`-`. When multiple operators with the same precedence appear next to
 each other (as in `1 - 2 + 1`), they are applied left to right.
 
 These rules of precedence are not something you should worry about.
 When in doubt, just add parentheses.
 
 (((remainder operation)))(((% operator)))There is one more arithmetic
-operator, which you might not recognize. The “%” symbol is used to
+operator, which you might not recognize. The `%` symbol is used to
 represent the _remainder_ operation. `X % Y` is the remainder of
 dividing `X` by `Y`. For example, `314 % 100` produces `14`, and `144
 % 12` gives `0`. Remainder's precedence is the same as that of
@@ -257,7 +257,7 @@ character is written like "\n"`” can be written:
 ----
 
 (((+ operator)))(((concatenation)))Strings cannot be divided,
-multiplied, or subtracted, but the “+” operator _can_ be used on them.
+multiplied, or subtracted, but the `+` operator _can_ be used on them.
 It does not add, but it __concatenates__—it glues two strings together.
 The following line will produce the string `"concatenate"`:
 
@@ -322,7 +322,7 @@ console.log(3 < 2)
 ----
 
 (((> operator)))(((< operator)))(((greater than)))(((less
-than)))(((comparing)))The “>” and “<” signs are the traditional symbols
+than)))(((comparing)))The `>` and `<` signs are the traditional symbols
 for “is greater than” and “is less than”, respectively. They are binary operators.
 Applying them results in a boolean value that indicates
 whether they hold true in this case.
@@ -348,9 +348,9 @@ JavaScript goes over them from left to right, comparing the numeric
 codes of the characters one by one.
 
 (((>= operator)))(((<= operator)))(((== operator)))(((!=
-operator)))Other similar operators are “>=” (greater than or equal
-to), “\<=” (less than or equal to), “==” (equal to), and
-“!=” (not equal to).
+operator)))Other similar operators are `>=` (greater than or equal
+to), `\<=` (less than or equal to), `==` (equal to), and
+`!=` (not equal to).
 
 [source,javascript]
 ----
@@ -377,7 +377,7 @@ applied to Boolean values themselves. JavaScript supports three
 logical operators: _and_, _or_, and _not_. These can be used to
 “reason” about Booleans.
 
-(((&& operator)))The “&&” operator represents logical _and_. It is a
+(((&& operator)))The `&&` operator represents logical _and_. It is a
 binary operator, and its result is true only if both the values
 given to it are true.
 
@@ -389,7 +389,7 @@ console.log(true && true)
 // → true
 ----
 
-(((|| operator)))The “||” operator denotes logical _or_. It produces
+(((|| operator)))The `||` operator denotes logical _or_. It produces
 true if either of the values given to it is true.
 
 [source,javascript]
@@ -401,14 +401,14 @@ console.log(false || false)
 ----
 
 (((negation)))(((! operator)))_Not_ is written as an exclamation mark
-(“!”). It is a unary operator that flips the value given to it—`!true`
+(`!`). It is a unary operator that flips the value given to it—`!true`
 produces `false` and `!false` gives `true`.
 
 (((precedence)))When mixing these Boolean operators with arithmetic
 and other operators, it is not always obvious when parentheses are
 needed. In practice, you can usually get by with knowing that of the
-operators we have seen so far, “||” has the lowest precedence, then
-comes “&&”, then the comparison operators (“>”, “==”, and so on), and
+operators we have seen so far, `||` has the lowest precedence, then
+comes `&&`, then the comparison operators (`>`, `==`, and so on), and
 then the rest. This order has been chosen such that, in typical
 expressions like the following one, as few parentheses as possible are
 necessary:
@@ -489,7 +489,7 @@ produced. Further arithmetic operations on `NaN` keep producing
 `NaN`, so if you find yourself getting one of those in an unexpected
 place, look for accidental type conversions.
 
-(((== operator)))When comparing values of the same type using “==”,
+(((== operator)))When comparing values of the same type using `==`,
 the outcome is easy to predict: you should get true when both
 values are the same. But when the types differ, JavaScript uses a
 complicated and confusing set of rules to determine what to do. I will
@@ -508,8 +508,8 @@ console.log(null == 0);
 
 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.
+or `undefined`, you can simply compare it to `null` with the `==` (or
+`!=`) operator.
 
 (((=== operator)))(((!== operator)))But what if you want to test
 whether something refers to the precise value `false`? The rules for
@@ -518,7 +518,7 @@ converting strings and numbers to Boolean values state that `0`,
 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
+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.
 
@@ -530,13 +530,13 @@ using the shorter operators.
 === Short-circuiting of logical operators ===
 
 (((|| operator)))(((&& operator)))(((?: operator)))(((operator)))The
-logical operators “&&” and “||” handle values of different types in a
+logical operators `&&` and `||` handle values of different types in a
 peculiar way. They _will_ convert the value on their left side to
 boolean type in order to decide what to do, but depending on the
 operator and the result of that conversion, they return either the
 _original_ left-hand value or the right-hand value.
 
-The “||” operator, for example, will return the value to its left when that can be
+The `||` operator, for example, will return the value to its left when that can be
 converted to true and will return the value on its right otherwise. This conversion works as 
 you'd expect for boolean values and should do something analogous for
 values of other types.
@@ -554,7 +554,7 @@ to fall back on a default value. If you give it an expression that might produce
 an empty value on the left, the value on the right will be used as a replacement
 in that case.
 
-The “&&” operator works similarly, but the other way around. When the
+The `&&` operator works similarly, but the other way around. When the
 value to its left is something that converts to false, it returns that
 value, and otherwise it returns the value on its right.
 
@@ -576,10 +576,10 @@ strings, Booleans, and undefined values.
 
 Such values are created by typing in their name (`true`, `null`) or
 value (`13`, `"abc"`). You can combine and transform values with operators. We saw binary
-operators for arithmetic (“+”, “-”, “*”, “/”,
-and “%”), string concatenation (“+”), comparison (“==”, “!=”,
-“===”, “!==”, “<”, “>”, “\<=”, “>=”), and logic (“&&”, “||”), as well
-as several unary operators (“-” to negate a number, “!” to negate
+operators for arithmetic (`+`, `-`, `*`, `/`,
+and `%`), string concatenation (`+`), comparison (`==`, `!=`,
+`===`, `!==`, `<`, `>`, `\<=`, `>=`), and logic (`&&`, `||`), as well
+as several unary operators (`-` to negate a number, `!` to negate
 logically, and `typeof` to find a value's type).
 
 This gives you enough information to use JavaScript as a pocket
diff --git a/02_program_structure.txt b/02_program_structure.txt
@@ -89,7 +89,7 @@ var caught = 5 * 5;
 (((var keyword)))And that gives us our second kind of statement. The
 special word (_keyword_) `var` indicates that this sentence is going
 to define a variable. It is followed by the name of the variable and,
-if we want to immediately give it a value, by an “=” operator and an
+if we want to immediately give it a value, by an `=` operator and an
 expression.
 
 The previous statement creates a variable called `caught` and uses it
@@ -114,7 +114,7 @@ variable name cannot include punctuation, except for the characters
 “$” and “_”.
 
 When a variable points at a value, that does not mean it is tied to
-that value forever. The “=” operator can be used at any time on
+that value forever. The `=` operator can be used at any time on
 existing variables to disconnect them from their current value and
 have them point to a new one:
 
@@ -621,7 +621,7 @@ console.log(current);
 ----
 
 (((remainder operation)))(((% operator)))The trick with the remainder
-(“%”) operator is an easy way to test whether a number is divisible by
+(`%`) operator is an easy way to test whether a number is divisible by
 another number. If it is, the remainder of their division is zero.
 
 The `for` construct in the example does not have a part that checks
@@ -896,7 +896,7 @@ endif::html_target[]
 
 Going over the numbers is clearly a looping job, and selecting what to
 print is a matter of conditional execution. Remember the trick of
-using the remainder (“%”) operator for checking whether a number is
+using the remainder (`%`) operator for checking whether a number is
 divisible by another number (has a remainder of zero).
 
 In the first version, there are three possible outcomes for
@@ -906,7 +906,7 @@ The second version of the program has a straightforward solution and a
 clever one. The simple way is to add another “branch” to 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 elegant use of the “||”
+if there is no word, potentially by making elegant use of the `||`
 operator.
 
 !!solution!!
diff --git a/03_functions.txt b/03_functions.txt
@@ -659,11 +659,11 @@ with `(1 + 5)` and `(1 * 3)`. The first call tries to find a solution
 that starts with `(1 + 5)`, and, using recursion, explores _every_
 solution that yields a number smaller than or equal to the target
 number. Since it doesn't find a solution that hits the target, it
-returns `null` back to the first call. There the “||” operator causes
+returns `null` back to the first call. There the `||` operator causes
 the call that explores `(1 * 3)` to happen. This search has more
 luck, as its first recursive call, through yet _another_ recursive
 call, hits upon the target number, 13. This innermost recursive call
-returns a string, and each of the “||” operators in the intermediate
+returns a string, and each of the `||` operators in the intermediate
 calls pass that string along, ultimately returning our solution.
 
 == Growing functions ==
diff --git a/04_data.txt b/04_data.txt
@@ -271,7 +271,7 @@ var descriptions = {
 
 (((property,assignment)))(((mutability)))(((= operator)))It is possible to
 assign a value to a property expression
-with the “=” operator. This will replace the property's value if it
+with the `=` operator. This will replace the property's value if it
 already existed, or create a new property on the object if it didn't.
 
 To briefly come back to our tentacle model of variable
@@ -807,7 +807,7 @@ after the start index. Strings also have a `slice`
 method, which has a similar effect.
 
 (((concat method)))The `concat` method can be used
-to glue arrays together, similar to what the “+”
+to glue arrays together, similar to what the `+`
 operator does for strings. The following
 example shows both `concat` and `slice` in action. It
 takes an array and an index, and returns a new array
@@ -1154,7 +1154,7 @@ method to add a value. Don't forget to return the array at the end of the
 function.
 
 Since the end boundary is inclusive, you'll need to use the “\<=”
-operator rather than simply “<” to check for the end of your loop.
+operator rather than simply `<` to check for the end of your loop.
 
 To check whether the optional step argument was given, either check
 `arguments.length` or compare the value of the argument to
@@ -1164,7 +1164,7 @@ To check whether the optional step argument was given, either check
 Having `range` understand negative step values is probably best done
 by writing two separate loops—one for counting up, one for
 counting down—because the comparison that checks whether the loop is
-finished needs to be “>=” rather than “\<=” when counting downwards.
+finished needs to be `>=` rather than “\<=” when counting downwards.
 
 It might also be worthwhile to use a different default step, namely
 -1, when the end of the range is smaller than the start. That way,
@@ -1332,15 +1332,15 @@ that's in this list's `rest` property.
 
 === Deep comparison ===
 
-The “==” operator compares objects by identity. But sometimes, you would
+The `==` operator compares objects by identity. But sometimes, you would
 prefer to compare the values of their actual properties.
 
 Write a function, `deepEqual`, that takes two values and returns true
 only if they are the same value, or are objects with the same properties
 whose values are also equal when compared with a recursive call to
 `deepEqual`.
 
-To find out whether to compare two things by identity (use the “===”
+To find out whether to compare two things by identity (use the `===`
 operator for that) or by looking at their properties, you can use the `typeof` operator.
 If it produces `"object"` for both values, you should do a deep comparison. But
 you have to take one silly exception into account: by a
@@ -1370,7 +1370,7 @@ endif::html_target[]
 Your test for whether you are dealing with a real object will look
 something like `typeof x == "object" && x != null`. Be careful to only
 compare properties when _both_ arguments are objects. In all other
-cases you can just immediately return the result of applying “===”.
+cases you can just immediately return the result of applying `===`.
 
 Use a `for`/`in` loop to go over the properties. You need to test
 whether both objects have the same set of property names, and whether
diff --git a/07_elife.txt b/07_elife.txt
@@ -933,7 +933,7 @@ PlantEater.prototype.act = function(context) {
 };
 ----
 
-We'll use the “*” character for plants, so that's what this creature
+We'll use the `*` character for plants, so that's what this creature
 will look for when it searches for food.
 
 == Bringing it to life ==
diff --git a/08_error.txt b/08_error.txt
@@ -641,7 +641,7 @@ properly reported.
 In cases where you only need one instance of your error (it
 always has the same message) and stack traces are not important, you
 can simplify things a little by defining a single error object
-rather than a constructor, and comparing exceptions to it with the “==”
+rather than a constructor, and comparing exceptions to it with the `==`
 operator.
 
 == Assertions ==
diff --git a/09_regexp.txt b/09_regexp.txt
diff --git a/11_language.txt b/11_language.txt
