2

2.md

@@ -30,7 +30,7 @@
 
 最简单的一条语句由一个表达式和其后的分号组成。比如这就是一个程序：
 
-```
+```js
 1;
 !false;
 ```
@@ -43,7 +43,7 @@
 
 程序如何保持内部状态？ 它如何记住东西？ 我们已经看到如何从旧值中产生新值，但这并没有改变旧值，新值必须立即使用，否则将会再度消失。 为了捕获和保存值，JavaScript 提供了一种称为绑定或变量的东西：
 
-```
+```js
 let caught = 5 * 5;
 ```
 
@@ -53,7 +53,7 @@ let caught = 5 * 5;
 
 在定义绑定之后，它的名称可以用作表达式。 这种表达式的值是绑定当前所持有的值。 这是一个例子：
 
-```
+```js
 let ten = 10;
 console.log(ten * ten);
 // → 100
@@ -61,7 +61,7 @@ console.log(ten * ten);
 
 当绑定指向某个值时，并不意味着它永远与该值绑定。 可以在现有的绑定上随时使用`=`运算符，将它们与当前值断开连接，并让它们指向一个新值：
 
-```
+```js
 var mood = "light";
 console.log(mood);
 // → light
@@ -74,7 +74,7 @@ console.log(mood);
 
 我们来看另一个例子。 为了记住 Luigi 欠你的美元数量，你需要创建一个绑定。 然后当他还你 35 美元时，你赋予这个绑定一个新值：
 
-```
+```js
 let luigisDebt = 140;
 luigisDebt = luigisDebt - 35;
 console.log(luigisDebt);
@@ -85,7 +85,7 @@ console.log(luigisDebt);
 
 一个`let`语句可以同时定义多个绑定，定义必需用逗号分隔。
 
-```
+```js
 let one = 1, two = 2;
 console.log(one + two);
 // → 3
@@ -93,7 +93,7 @@ console.log(one + two);
 
 `var`和`const`这两个词也可以用来创建绑定，类似于`let`。
 
-```
+```js
 var name = "Ayda";
 const greeting = "Hello ";
 console.log(greeting + name);
@@ -128,7 +128,7 @@ switch this throw true try typeof var void while with yield
 
 在默认环境中提供的许多值的类型为函数。 函数是包裹在值中的程序片段。 为了运行包裹的程序，可以将这些值应用于它们。 例如，在浏览器环境中，绑定`prompt`包含一函数，个显示一个小对话框，请求用户输入。 它是这样使用的：
 
-```
+```js
 prompt("Enter passcode");
 ```
 
@@ -144,7 +144,7 @@ prompt("Enter passcode");
 
 > 在英文版页面上运行示例（或自己的代码）时，会在示例之后显示`console.log`输出，而不是在浏览器的 JavaScript 控制台中显示。
 
-```
+```js
 let x = 30;
 console.log("the value of x is", x);
 // → the value of x is 30
@@ -156,14 +156,14 @@ console.log("the value of x is", x);
 
 显示对话框或将文字写入屏幕是一个副作用。 由于它们产生的副作用，很多函数都很有用。 函数也可能产生值，在这种情况下，他们不需要有副作用就有用。 例如，函数`Math.max`可以接受任意数量的参数并返回最大值。
 
-```
+```js
 console.log(Math.max(2, 4));
 // → 4
 ```
 
 当一个函数产生一个值时，它被称为返回该值。 任何产生值的东西都是 JavaScript 中的表达式，这意味着可以在较大的表达式中使用函数调用。 在这里，`Math.min`的调用（与`Math.max`相反）用作加法表达式的一部分：
 
-```
+```js
 console.log(Math.min(2, 4) + 100);
 // → 102
 ```
@@ -174,7 +174,7 @@ console.log(Math.min(2, 4) + 100);
 
 当你的程序包含多个语句时，这些语句就像是一个故事一样从上到下执行。 这个示例程序有两个语句。 第一个要求用户输入一个数字，第二个在第一个之后执行，显示该数字的平方。
 
-```
+```js
 let theNumber = Number(prompt("Pick a number"));
 console.log("Your number is the square root of " +
             theNumber * theNumber);
@@ -195,7 +195,7 @@ console.log("Your number is the square root of " +
 
 在 JavaScript 中，条件执行使用`if`关键字创建。 在简单的情况下，当且仅当某些条件成立时，我们才希望执行一些代码。 例如，仅当输入实际上是一个数字时，我们可能打算显示输入的平方。
 
-```
+```js
 let theNumber = Number(prompt("Pick a number", ""));
 if (!isNaN(theNumber))
   alert("Your number is the square root of " +
@@ -211,14 +211,14 @@ if (!isNaN(theNumber))
 
 在这个例子中，`if`下面的语句被大括号（`{`和`}`）括起来。 它们可用于将任意数量的语句分组到单个语句中，称为代码块。 在这种情况下，你也可以忽略它们，因为它们只包含一个语句，但为了避免必须考虑是否需要，大多数 JavaScript 程 序员在每个这样的被包裹的语句中使用它们。 除了偶尔的一行，我们在本书中大多会遵循这个约定。
 
-```
+```js
 if (1 + 1 == 2) console.log("It's true");
 // → It's true
 ```
 
 您通常不会只执行条件成立时代码，还会处理其他情况的代码。 该替代路径由图中的第二个箭头表示。 可以一起使用`if`和`else`关键字，创建两个单独的替代执行路径。
 
-```py
+```js
 let theNumber = Number(prompt("Pick a number"));
 if (!Number.isNaN(theNumber)) {
   console.log("Your number is the square root of " +
@@ -230,7 +230,7 @@ if (!Number.isNaN(theNumber)) {
 
 如果我们需要执行的路径多于两条，可以将多个`if/else`对链接在一起使用。如下所示例子：
 
-```
+```js
 let num = Number(prompt("Pick a number", "0"));
 
 if (num < 10) {
@@ -252,7 +252,7 @@ if (num < 10) {
 
 现考虑编写一个程序，输出 0 到 12 之间的所有偶数。其中一种编写方式如下所示：
 
-```
+```js
 console.log(0);
 console.log(2);
 console.log(4);
@@ -268,7 +268,7 @@ console.log(12);
 
 我们可以使用循环控制流来让程序执行回到之前的某个位置，并根据程序状态循环执行代码。如果我们在循环中使用一个绑定计数，那么就可以按照如下方式编写代码：
 
-```
+```js
 let number = 0;
 while (number <= 12) {
   console.log(number);
@@ -286,7 +286,7 @@ while (number <= 12) {
 
 作为一个实际上有用的例子，现在我们可以编写一个程序来计算并显示`2**10`（2 的 10 次方）的结果。  我们使用两个绑定：一个用于跟踪我们的结果，一个用来计算我们将这个结果乘以 2 的次数。 该循环测试第二个绑定是否已达到 10，如果不是，则更新这两个绑定。
 
-```
+```js
 let result = 1;
 let counter = 0;
 while (counter < 10) {
@@ -301,7 +301,7 @@ console.log(result);
 
 `do`循环控制结构类似于`while`循环。两者之间只有一个区别：`do`循环至少执行一遍循环体，只有第一次执行完循环体之后才会开始检测循环条件。`do`循环中将条件检测放在循环体后面，正反映了这一点：
 
-```
+```js
 let yourName;
 do {
   yourName = prompt("Who are you?");
@@ -317,7 +317,7 @@ console.log(yourName);
 
 块内缩进的作用是使代码结构显而易见。 在其他块内开启新的代码块中，可能很难看到块的结束位置，和另一个块开始位置。 通过适当的缩进，程序的视觉形状对应其内部块的形状。 我喜欢为每个开启的块使用两个空格，但风格不同 - 有些人使用四个空格，而有些人使用制表符。 重要的是，每个新块添加相同的空格量。
 
-```
+```js
 if (false != true) {
   console.log("That makes sense.");
   if (1 < 2) {
@@ -334,7 +334,7 @@ if (false != true) {
 
 由于这种规律非常常见，JavaScript 和类似的语言提供了一个稍短而且更全面的形式，`for`循环：
 
-```
+```js
 for (let number = 0; number <= 12; number = number + 2)
   console.log(number);
 // → 0
@@ -348,7 +348,7 @@ for (let number = 0; number <= 12; number = number + 2)
 
 下面的代码中使用了`for`循环代替`while`循环，来计算`2**10`：
 
-```
+```js
 var result = 1;
 for (var counter = 0; counter < 10; counter = counter + 1)
   result = result * 2;
@@ -362,7 +362,7 @@ console.log(result);
 
 下面的程序展示了`break`语句的用法。该程序的作用是找出第一个大于等于 20 且能被 7 整除的数字。
 
-```
+```js
 for (let current = 20; ; current++) {
   if (current % 7 == 0) 
     break;
@@ -385,13 +385,13 @@ for (let current = 20; ; current++) {
 
 程序经常需要根据绑定的原值进行计算并更新值，特别是在循环过程中，这种情况更加常见。
 
-```
+```js
 counter = counter + 1;
 ```
 
 JavaScript 提供了一种简便写法：
 
-```
+```js
 counter += 1;
 ```
 
@@ -399,7 +399,7 @@ JavaScript 还为其他运算符提供了类似的简便方法，比如`result*=
 
 这样可以稍微简化我们的计数示例代码。
 
-```
+```js
 for (let number = 0; number <= 12; number += 2)
   console.log(number);
 ```
@@ -410,7 +410,7 @@ for (let number = 0; number <= 12; number += 2)
 
 我们很少会编写如下所示的代码。
 
-```
+```js
 if (x == "value1") action1();
 else if (x == "value2") action2();
 else if (x == "value3") action3();
@@ -419,7 +419,7 @@ else defaultAction();
 
 有一种名为`switch`的结构，为了以更直接的方式表达这种“分发”。 不幸的是，JavaScript 为此所使用的语法（它从 C/Java 语言中继承而来）有些笨拙 - `if`语句链看起来可能更好。 这里是一个例子：
 
-```
+```js
 switch (prompt("What is the weather like?")) {
   case "rainy":
     console.log("Remember to bring an umbrella.");
@@ -441,7 +441,7 @@ switch (prompt("What is the weather like?")) {
 
 绑定名中不能包含空格，但很多时候使用多个单词有助于清晰表达绑定的实际用途。当绑定名中包含多个单词时可以选择多种写法，以下是可以选择的几种绑定名书写方式：
 
-```
+```js
 fuzzylittleturtle
 fuzzy_little_turtle
 FuzzyLittleTurtle
@@ -458,7 +458,7 @@ fuzzyLittleTurtle
 
 注释是程序中的一段文本，而在程序执行时计算机会完全忽略掉这些文本。JavaScript 中编写注释有两种方法，写单行注释时，使用两个斜杠字符开头，并在后面添加文本注释。
 
-```
+```js
 let accountBalance = calculateBalance(account);
 // It's a green hollow where a river sings
 accountBalance.adjust();
@@ -471,7 +471,7 @@ addToReport(accountBalance, report);
 
 `//`注释只能到达行尾。 `/*`和`*/`之间的一段文本将被忽略，不管它是否包含换行符。 这对添加文件或程序块的信息块很有用。
 
-```
+```js
 /*
  I first found this number scrawled on the back of one of
  an old notebook. Since then, it has often dropped by,
@@ -514,7 +514,7 @@ const myNumber = 11213;
 
 这里给出一个小技巧，在字符串后加上`.length`可以获取字符串的长度。
 
-```
+```js
 let abc = "abc";
 console.log(abc.length);
 // → 3