JavaScript高级程序设计（第四版）阅读笔记

第三章_语言基础

内容有点多，所以分为上下两部分。

本文重点

JavaScript这门语言是区分大小写的，大小写不同则表示的变量也是不同的，同时也要注意不要使用一些的关键字或者保留字来命名变量。

JavaScript的语句一般以;结尾，这样可以有效的告诉编译器语句到这里就结束了，否则可能会与下一行内容串联起来导致报错，或语义不明确。

声明变量的关键字有三种:var ,let ,const;三者各有不用。(注意，是声明变量的关键字有三种，而不是声明方式)

使用var关键字声明变量，会有声明提升(声明的变量会自动提升到函数作用域顶部); 声明的范围是函数作用域;反复多次使用 var 声明同一个变量也没有问题。

使用let关键字声明变量，不会有声明提升; 声明的范围是块作用域;不可反复声明同一个变量。let的暂时性死区是指在let声明前引用let所声明的变量,会抛出 ReferenceError。且let在全局作用域中声明的变量也不会成为window的属性。

使用const关键字声明变量，不会有声明提升; 声明的范围是块作用域;不可反复声明同一个变量，声明变量时必须同时初始化变量，且尝试修改 const 声明的变量会导致运行时错误。const 声明的限制只适用于它指向的变量的引用。换句话说，如果 const 变量引用的是一个对象，那么修改这个对象内部的属性并不违反 const 的限制。(也就是能解释为什么在用const声明一个对象时，修改对象内部属性不会报错的原因)

总结var,let,const的区别

使用var声明的变量，其作用域为该语句所在的函数内，且存在变量提升现象；

使用let声明的变量，其作用域为该语句所在的代码块内，不存在变量提升；

使用const声明的是常量，在后面出现的代码中不能再修改该常量的值。const声明对象时存的是地址指针，这个指针不可以变，但是可以改变堆中该对象的属性内容。

声明风格及最佳实践是:1. 不使用 var (限制自己只使用 let 和 const 有助于提升代码质量，因为变量有了明确的作用域、声明位置，以及不变的值。)2. const 优先，let 次之 (这样可以让开发者更有信心地推断某些变量的值永远不会变，同时也能迅速发现因意外赋值导致的非预期行为。)

3.1语法

ECMAScript的语法很大程度上借鉴了 C语言和其他类 C语言，如 Java和 Perl。熟悉这些语言的开发者，应该很容易理解 ECMAScript宽松的语法。

3.1.1 区分大小写

首先要知道的是，ECMAScript 中一切都区分大小写。无论是变量、函数名还是操作符，都区分大小写。换句话说，变量 test 和变量 Test 是两个不同的变量。类似地，typeof 不能作为函数名，因为它是一个关键字（后面会介绍）。但 Typeof 是一个完全有效的函数名。

3.1.2 标识符

所谓标识符，就是变量、函数、属性或函数参数的名称。标识符可以由一或多个下列字符组成：

第一个字符必须是一个字母、下划线（_）或美元符号（$）；
剩下的其他字符可以是字母、下划线、美元符号或数字。

标识符中的字母可以是扩展 ASCII（Extended ASCII）中的字母，也可以是 Unicode 的字母字符，如 À和 Æ（但不推荐使用）。

按照惯例，ECMAScript 标识符使用驼峰大小写形式，即第一个单词的首字母小写，后面每个单词的首字母大写，如：

firstSecond myCar doSomethingImportant

虽然这种写法并不是强制性的，但因为这种形式跟 ECMAScript内置函数和对象的命名方式一致，所以算是佳实践。

关键字、保留字、true、false 和 null 不能作为标识符。

3.1.3 注释

ECMAScript采用 C语言风格的注释，包括单行注释和块注释。单行注释以两个斜杠字符开头，如：

 // 单行注释

块注释以一个斜杠和一个星号（/）开头，以它们的反向组合（/）结尾，如：

/* 这是多行 注释 */

3.1.4 严格模式

ECMAScript 5增加了严格模式（strict mode）的概念。严格模式是一种不同的 JavaScript解析和执行模型，ECMAScript 3的一些不规范写法在这种模式下会被处理，对于不安全的活动将抛出错误。要对个脚本启用严格模式，在脚本开头加上这一行：

"use strict";

虽然看起来像个没有赋值给任何变量的字符串，但它其实是一个预处理指令。任何支持的 JavaScript 引擎看到它都会切换到严格模式。选择这种语法形式的目的是不破坏 ECMAScript 3语法。也可以单独指定一个函数在严格模式下执行，只要把这个预处理指令放到函数体开头即可：

function doSomething() {   
  "use strict";   // 函数体  
}

严格模式会影响 JavaScript 执行的很多方面，因此本书在用到它时会明确指出来。所有现代浏览器都支持严格模式。

3.1.5 语句

ECMAScript 中的语句以分号结尾。省略分号意味着由解析器确定语句在哪里结尾，如下面的例子所示：

let sum = a + b      // 没有分号也有效，但不推荐 
let diff = a - b;    // 加分号有效，推荐

即使语句末尾的分号不是必需的，也应该加上。记着加分号有助于防止省略造成的问题，比如可以避免输入内容不完整。此外，加分号也便于开发者通过删除空行来压缩代码（如果没有结尾的分号，只删除空行，则会导致语法错误）。加分号也有助于在某些情况下提升性能，因为解析器会尝试在合适的位置补上分号以纠正语法错误。

代码块由一个左花括号（{）标识开始，一个右花括号（}）标识结束：

  if (test) {    
    test = false;   
    console.log(test);
  }

if 之类的控制语句只在执行多条语句时要求必须有代码块。不过，最佳实践是始终在控制语句中使用代码块，即使要执行的只有一条语句，如下例所示：

// 有效，但容易导致错误，应该避免 
if (test)   
console.log(test); 
 
// 推荐 
if (test) {   
  console.log(test); 
}

在控制语句中使用代码块可以让内容更清晰，在需要修改代码时也可以减少出错的可能性。

3.2 关键字与保留字

ECMA-262描述了一组保留的关键字，这些关键字有特殊用途，比如表示控制语句的开始和结束，或者执行特定的操作。按照规定，保留的关键字不能用作标识符或属性名。ECMA-262第 6版规定的所有关键字如下:

规范中也描述了一组未来的保留字，同样不能用作标识符或属性名。虽然保留字在语言中没有特定用途，但它们是保留给将来做关键字用的。未来的保留字如下：

3.3 变量

ECMAScript 变量是松散类型的，意思是变量可以用于保存任何类型的数据。每个变量只不过是一个用于保存任意值的命名占位符。有 3 个关键字可以声明变量：var、const 和 let。其中，var 在 ECMAScript的所有版本中都可以使用，而 const 和 let 只能在 ECMAScript 6及更晚的版本中使用。

3.3.1 var 关键字

要定义变量，可以使用 var 操作符（注意 var 是一个关键字），后跟变量名（即标识符，如前所述）：

 var message

可以用它保存任何类型的值。（不初始化的情况下，变量会保存一个特殊值 undefined。

var message = "hi";
message = 100;  // 合法，但不推荐

1. var 声明作用域

使用 var 操作符定义的变量会成为包含它的函数的局部变量。比如，使用 var 在一个函数内部定义一个变量，就意味着该变量将在函数退出时被销毁：

function test() {  
  var message = "hi"; // 局部变量 
}
test(); 
console.log(message); // 出错！

去掉之前的 var 操作符之后，message 就变成了全局变量。只要调用一次函数 test()，就会定义这个变量，并且可以在函数外部访问到。如下图所示：

function test() {  
  message = "hi";     // 全局变量 
}
test();
console.log(message); // "hi"

虽然可以通过省略 var 操作符定义全局变量，但不推荐这么做。在局部作用域中定义的全局变量很难维护，也会造成困惑。这是因为不能一下子断定省略 var 是不是有意而为之。在严格模式下，如果像这样给未声明的变量赋值，则会导致抛出 ReferenceError。

如果需要定义多个变量，可以在一条语句中用逗号分隔每个变量（及可选的初始化）：

var message = "hi", 
found = false,   
age = 29;

在严格模式下，不能定义名为 eval 和 arguments 的变量，否则会导致语法错误。

2. var 声明提升

这就是所谓的“提升”（hoist），也就是把所有变量声明都拉到函数作用域的顶部。此外，反复多次使用 var 声明同一个变量也没有问题。代码综合起来可以这么看：

function foo() {   
 //var的声明提升，实际上在这一行就已经执行了 var age;
  console.log(age);      
  var age = 26; //这一行实际上的操作是赋值：age=26;
  //如果接下来还有如下代码:
  //var age =36; 此时进行的是age=36的赋值操作，var的声明也早已提升至代码块顶部；
  //console.log(age)  此时输出的就是最后面的赋值。  36已经覆盖了26的赋值操作，此时age的值是36    
}
foo();  //undefined

3.3.2 let 声明

let 跟 var 的作用差不多，但有着非常重要的区别。明显的区别是，let 声明的范围是块作用域，而 var 声明的范围是函数作用域。 并且let 也不允许同一个块作用域中出现冗余声明。

if (true) {   
var name = 'Matt'; 
console.log(name); // Matt 
let age=15;
console.log(age);//15 
let name; // SyntaxError 
let age;// SyntaxError
} 
console.log(name);   // Matt 
console.log(age);   // 报错 ReferenceError: age 没有定义

1. 暂时性死区

let 与 var 的另一个重要的区别，就是 let 声明的变量不会在作用域中被提升。

// name 会被提升 
console.log(name); // undefined 
var name = 'Matt'; 
 
// age 不会被提升 
console.log(age); // ReferenceError：age 没有定义
let age = 26;

在 let 声明之前的执行瞬间被称为“暂时性死区”（temporal dead zone），在此阶段引用任何后面才声明的变量都会抛出 ReferenceError。

2. 全局声明

与 var 关键字不同，使用 let 在全局作用域中声明的变量不会成为 window 对象的属性（var 声明的变量则会）。

var name = 'Matt';
console.log(window.name); // 'Matt' 
 
let age = 26;
console.log(window.age);  // undefined

不过，let 声明仍然是在全局作用域中发生的，相应变量会在页面的生命周期内存续。因此，为了避免 SyntaxError，必须确保页面不会重复声明同一个变量。

3. 条件声明

在使用 var 声明变量时，由于声明会被提升，JavaScript引擎会自动将多余的声明在作用域顶部合并为一个声明。因为 let 的作用域是块，所以不可能检查前面是否已经使用 let 声明过同名变量，同时也就不可能在没有声明的情况下声明它。所以在之前的代码中如果已经声明过的情况下再次使用let声明会报错。使用 try/catch 语句或 typeof 操作符也不能解决，因为条件块中 let 声明的作用域仅限于该块。

<script>   
let name = 'Nicholas'; 
let age = 36; 
</script>

<script>  
// 假设脚本不确定页面中是否已经声明了同名变量  
// 那它可以假设还没有声明过 
if (typeof name === 'undefined') {
 let name;   
}   
// name 被限制在 if {} 块的作用域内   
// 因此这个赋值形同全局赋值   
name = 'Matt';  
try {    
console.log(age); 
// 如果 age 没有声明过，则会报错  
} catch(error) {     
 let age; 
}   
 // age 被限制在 catch {}块的作用域内   
 // 因此这个赋值形同全局赋值   
 age = 26; 
 </script>

不能使用 let 进行条件式声明是件好事，因为条件声明是一种反模式，它让程序变得更难理解。如果你发现自己在使用这个模式，那一定有更好的替代方式。

4. for 循环中的 let 声明

在 let 出现之前，for 循环定义的迭代变量会渗透到循环体外部：

for (var i = 0; i < 5; ++i) {   
// 循环逻辑  
} 
console.log(i); // 5 改成使用

let 之后，这个问题就消失了，因为迭代变量的作用域仅限于 for 循环块内部：

for (let i = 0; i < 5; ++i) {   
// 循环逻辑 
} 
console.log(i); // ReferenceError: i

没有定义在使用 var 的时候，常见的问题就是对迭代变量的奇特声明和修改：

for (var i = 0; i < 5; ++i) {     
  setTimeout(() => console.log(i), 0) 
} 
// 你可能以为会输出 0、1、2、3、4 
// 实际上会输出 5、5、5、5、5

之所以会这样，是因为在退出循环时，迭代变量保存的是导致循环退出的值：5。在之后执行超时逻辑时，所有的 i 都是同一个变量，因而输出的都是同一个终值。

而在使用 let 声明迭代变量时，JavaScript引擎在后台会为每个迭代循环声明一个新的迭代变量。每个 setTimeout 引用的都是不同的变量实例，所以 console.log 输出的是我们期望的值，也就是循环执行过程中每个迭代变量的值。

for (let i = 0; i < 5; ++i) { 
  setTimeout(() => console.log(i), 0)
} 
// 会输出 0、1、2、3、4

这种每次迭代声明一个独立变量实例的行为适用于所有风格的 for 循环，包括 for-in 和 for-of 循环。

3.3.3 const 声明

const 的行为与 let 基本相同，唯一一个重要的区别是用它声明变量时必须同时初始化变量，且尝试修改 const 声明的变量会导致运行时错误。

const age = 26; 
age = 36; // TypeError: 给常量赋值 
// const 也不允许重复声明
const name = 'Matt';
const name = 'Nicholas'; // SyntaxError 
 
// const 声明的作用域也是块
const name = 'Matt';
if (true) {  
  const name = 'Nicholas';
} 
console.log(name); // Matt

const 声明的限制只适用于它指向的变量的引用。换句话说，如果 const 变量引用的是一个对象，那么修改这个对象内部的属性并不违反 const 的限制。

const person = {};
person.name = 'Matt';  // ok

JavaScript引擎会为 for 循环中的 let 声明分别创建独立的变量实例，虽然 const 变量跟 let 变量很相似，但是不能用 const 来声明迭代变量（因为迭代变量会自增）：

for (const i = 0; i < 10; ++i) {} // TypeError：给常量赋值

不过，如果你只想用 const 声明一个不会被修改的 for 循环变量，那也是可以的。也就是说，每次迭代只是创建一个新变量。这对 for-of 和 for-in 循环特别有意义：

let i = 0; 
for (const j = 7; i < 5; ++i) {
  console.log(j); 
} // 7, 7, 7, 7, 7 
 
for (const key in {a: 1, b: 2}) {
console.log(key); 
} // a, b 
 
for (const value of [1,2,3,4,5]) {
console.log(value); 
} // 1, 2, 3, 4, 5

3.3.4 声明风格及佳实践

1. 不使用 var

有了 let 和 const，大多数开发者会发现自己不再需要 var 了。限制自己只使用 let 和 const 有助于提升代码质量，因为变量有了明确的作用域、声明位置，以及不变的值。

2. const 优先，let 次之

使用 const 声明可以让浏览器运行时强制保持变量不变，也可以让静态代码分析工具提前发现不合法的赋值操作。因此，很多开发者认为应该优先使用 const 来声明变量，只在提前知道未来会有修改时，再使用 let。这样可以让开发者更有信心地推断某些变量的值永远不会变，同时也能迅速发现因意外赋值导致的非预期行为。

参考文献：

《JavaScript高级程序设计（第4版）》

JavaScript高级程序设计（第四版）阅读笔记_第三章(上)（持续更新...)