跳到主要内容

3.1. 语言基础（语法/关键字/变量/数据类型）

语法​

ECMAScript中一切都区分大小写。无论是变量、函数名还是操作符，都区分大小写。

标识符​

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

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

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

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

    firstSecond
    myCar
    doSomethingImportant

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

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

注释​

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

    // 单行注释

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

    /＊ 这是多行
    注释＊/

严格模式​

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

"use strict";

也可以单独指定一个函数在严格模式下执行，只要把这个预处理指令放到函数体开头即可：

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

语句​

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

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

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

多条语句可以合并到一个C语言风格的代码块中。代码块由一个左花括号（{）标识开始，一个右花括号（}）标识结束：

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

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

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

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

关键字与保留字​

按照规定，保留的关键字不能用作标识符或属性名。ECMA-262第6版规定的所有关键字如下：

    break         do             in              typeof
    case          else           instanceof      var
    catch         export         new             void
    class         extends        return          while
    const         finally        super           with
    continue      for            switch          yield
    debugger      function       this
    default       if             throw
    delete        import         try

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

以下是ECMA-262第6版为将来保留的所有词汇。

    始终保留：
    enum
    严格模式下保留：
    implements    package      public
    interface     protected    static
    let           private
    模块代码中保留：
    await

这些词汇不能用作标识符，但现在还可以用作对象的属性名。一般来说，最好还是不要使用关键字和保留字作为标识符和属性名，以确保兼容过去和未来的ECMAScript版本。

变量​

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

var关键字​

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

    var message;

这行代码定义了一个名为message的变量，可以用它保存任何类型的值。（不初始化的情况下，变量会保存一个特殊值undefined，）ECMAScript实现变量初始化，因此可以同时定义变量并设置它的值：

    var message = "hi";

虽然不推荐改变变量保存值的类型，但这在ECMAScript中是完全有效的。

1．var声明作用域

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

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

这里，message变量是在函数内部使用var定义的。函数叫test()，调用它会创建这个变量并给它赋值。调用之后变量随即被销毁，因此示例中的最后一行会导致错误。不过，在函数内定义变量时省略var操作符，可以创建一个全局变量：

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

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

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

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

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

这里定义并初始化了3个变量。因为ECMAScript是松散类型的，所以使用不同数据类型初始化的变量可以用一条语句来声明。插入换行和空格缩进并不是必需的，但这样有利于阅读理解。

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

2．var声明提升

使用var时，下面的代码不会报错。这是因为使用这个关键字声明的变量会自动提升到函数作用域顶部：

    function foo() {
      console.log(age);
      var age = 26;
    }
    foo();   // undefined

之所以不会报错，是因为ECMAScript运行时把它看成等价于如下代码：

    function foo() {
      var age;
      console.log(age);
      age = 26;
    }
    foo();   // undefined

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

    function foo() {
      var age = 16;
      var age = 26;
      var age = 36;
      console.log(age);
    }
    foo();   // 36

let声明​

let跟var的作用差不多，但有着非常重要的区别。最明显的区别是，let声明的范围是块作用域，而var声明的范围是函数作用域。

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

在这里，age变量之所以不能在if块外部被引用，是因为它的作用域仅限于该块内部。块作用域是函数作用域的子集，因此适用于var的作用域限制同样也适用于let。

let也不允许同一个块作用域中出现冗余声明。这样会导致报错：

    var name;
    var name;
    let age;
    let age;   // SyntaxError；标识符age已经声明过了

当然，JavaScript引擎会记录用于变量声明的标识符及其所在的块作用域，因此嵌套使用相同的标识符不会报错，而这是因为同一个块中没有重复声明：

    var name = 'Nicholas';
    console.log(name);     // 'Nicholas'
    if (true) {
      var name = 'Matt';
      console.log(name);   // 'Matt'
    }
    let age = 30;
    console.log(age);     // 30
    if (true) {
      let age = 26;
      console.log(age);   // 26
    }

对声明冗余报错不会因混用let和var而受影响。这两个关键字声明的并不是不同类型的变量，它们只是指出变量在相关作用域如何存在。

    var name;
    let name; // SyntaxError
    let age;
    var age; // SyntaxError

1．暂时性死区

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

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

在解析代码时，JavaScript引擎也会注意出现在块后面的let声明，只不过在此之前不能以任何方式来引用未声明的变量。在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声明过同名变量，同时也就不可能在没有声明的情况下声明它。

    <script>
      var name = 'Nicholas';
      let age = 26;
    </script>
    <script>
      // 假设脚本不确定页面中是否已经声明了同名变量
      // 那它可以假设还没有声明过
      var name = 'Matt';
      // 这里没问题，因为可以被作为一个提升声明来处理
      // 不需要检查之前是否声明过同名变量
      let age = 36;
      // 如果age之前声明过，这里会报错
    </script>

使用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这个新的ES6声明关键字，不能依赖条件声明模式。

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循环。

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

声明风格及最佳实践​

ECMAScript 6增加let和const从客观上为这门语言更精确地声明作用域和语义提供了更好的支持。

1．不使用var

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

2．const优先，let次之

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

数据类型​

ECMAScript有6种简单数据类型（也称为原始类型）: Undefined、Null、Boolean、Number、String和Symbol。 Symbol（符号）是ECMAScript 6新增的。还有一种复杂数据类型叫Object（对象）。 Object是一种无序名值对的集合。因为在ECMAScript中不能定义自己的数据类型，所有值都可以用上述7种数据类型之一来表示。

typeof操作符​

对一个值使用typeof操作符会返回下列字符串之一：

  • "undefined"表示值未定义；
  • "boolean"表示值为布尔值；
  • "string"表示值为字符串；
  • "number"表示值为数值；
  • "object"表示值为对象（而不是函数）或null；
  • "function"表示值为函数；
  • "symbol"表示值为符号。
    let message = "some string";
    console.log(typeof message);     // "string"
    console.log(typeof(message));    // "string"
    console.log(typeof 95);           // "number"

在这个例子中，我们把一个变量（message）和一个数值字面量传给了typeof操作符。注意，因为typeof是一个操作符而不是函数，所以不需要参数（但可以使用参数）。

注意typeof在某些情况下返回的结果可能会让人费解，但技术上讲还是正确的。比如，调用typeof null返回的是"object"。这是因为特殊值null被认为是一个对空对象的引用。

Undefined类型​

Undefined类型只有一个值，就是特殊值undefined。当使用var或let声明了变量但没有初始化时，就相当于给变量赋予了undefined值：

    let message;
    console.log(message == undefined); // true

默认情况下，任何未经初始化的变量都会取得undefined值。

注意 一般来说，永远不用显式地给某个变量设置undefined值。字面值undefined主要用于比较，而且在ECMA-262第3版之前是不存在的。增加这个特殊值的目的就是为了正式明确空对象指针（null）和未初始化变量的区别。

注意，包含undefined值的变量跟未定义变量是有区别的。请看下面的例子：

    let message;     // 这个变量被声明了，只是值为undefined
    // 确保没有声明过这个变量
    // let age
    console.log(message); // "undefined"
    console.log(age);      // 报错

在上面的例子中，第一个console.log会指出变量message的值，即"undefined"。而第二个console.log要输出一个未声明的变量age的值，因此会导致报错。对未声明的变量，只能执行一个有用的操作，就是对它调用typeof。（对未声明的变量调用delete也不会报错，但这个操作没什么用，实际上在严格模式下会抛出错误。）

在对未初始化的变量调用typeof时，返回的结果是"undefined"，但对未声明的变量调用它时，返回的结果还是"undefined"，这就有点让人看不懂了。比如下面的例子：

    let message; // 这个变量被声明了，只是值为undefined
    // 确保没有声明过这个变量
    // let age
    console.log(typeof message);//"undefined"
    console.log(typeof age);     //"undefined"

无论是声明还是未声明，typeof返回的都是字符串"undefined"。逻辑上讲这是对的，因为虽然严格来讲这两个变量存在根本性差异，但它们都无法执行实际操作。

注意 即使未初始化的变量会被自动赋予undefined值，但我们仍然建议在声明变量的同时进行初始化。这样，当typeof返回"undefined"时，你就会知道那是因为给定的变量尚未声明，而不是声明了但未初始化。

undefined是一个假值。因此，如果需要，可以用更简洁的方式检测它。不过要记住，也有很多其他可能的值同样是假值。所以一定要明确自己想检测的就是undefined这个字面值，而不仅仅是假值。

    let message; // 这个变量被声明了，只是值为undefined
    // age没有声明
    if (message) {
      // 这个块不会执行
    }
    if (! message) {
      // 这个块会执行
    }
    if (age) {
      // 这里会报错
    }

Null类型​

Null类型同样只有一个值，即特殊值null。逻辑上讲，null值表示一个空对象指针，这也是给typeof传一个null会返回"object"的原因：

    let car = null;
    console.log(typeof car);   // "object"

在定义将来要保存对象值的变量时，建议使用null来初始化，不要使用其他值。这样，只要检查这个变量的值是不是null就可以知道这个变量是否在后来被重新赋予了一个对象的引用，比如：

    if (car ! = null) {
      // car是一个对象的引用
    }

undefined值是由null值派生而来的，因此ECMA-262将它们定义为表面上相等，如下面的例子所示：

    console.log(null == undefined);   // true

用等于操作符（==）比较null和undefined始终返回true。但要注意，这个操作符会为了比较而转换它的操作数（本章后面将详细介绍）。

即使null和undefined有关系，它们的用途也是完全不一样的。如前所述，永远不必显式地将变量值设置为undefined。但null不是这样的。任何时候，只要变量要保存对象，而当时又没有那个对象可保存，就要用null来填充该变量。这样就可以保持null是空对象指针的语义，并进一步将其与undefined区分开来。

null是一个假值。因此，如果需要，可以用更简洁的方式检测它。不过要记住，也有很多其他可能的值同样是假值。所以一定要明确自己想检测的就是null这个字面值，而不仅仅是假值。

    let message = null;
    let age;
    if (message) {
      // 这个块不会执行
    }
    if (! message) {
      // 这个块会执行
    }
    if (age) {
      // 这个块不会执行
    }
    if (! age) {
      // 这个块会执行
    }

Boolean类型​

Boolean（布尔值）类型是ECMAScript中使用最频繁的类型之一，有两个字面值：true和false。这两个布尔值不同于数值，因此true不等于1，false不等于0。

    let found = true;
    let lost = false;

注意，布尔值字面量true和false是区分大小写的，因此True和False（及其他大小混写形式）是有效的标识符，但不是布尔值。

虽然布尔值只有两个，但所有其他ECMAScript类型的值都有相应布尔值的等价形式。要将一个其他类型的值转换为布尔值，可以调用特定的Boolean()转型函数：

    let message = "Hello world! ";
    let messageAsBoolean = Boolean(message);

在这个例子中，字符串message会被转换为布尔值并保存在变量messageAsBoolean中。Boolean()转型函数可以在任意类型的数据上调用，而且始终返回一个布尔值。什么值能转换为true或false的规则取决于数据类型和实际的值。下表总结了不同类型与布尔值之间的转换规则。

图片

理解以上转换非常重要，因为像if等流控制语句会自动执行其他类型值到布尔值的转换，例如：

    let message = "Hello world! ";
    if (message) {
      console.log("Value is true");
    }

在这个例子中，console.log会输出字符串"Value is true"，因为字符串message会被自动转换为等价的布尔值true。由于存在这种自动转换，理解流控制语句中使用的是什么变量就非常重要。错误地使用对象而不是布尔值会明显改变应用程序的执行流。

Number类型​

Number类型使用IEEE 754格式表示整数和浮点值（在某些语言中也叫双精度值）。不同的数值类型相应地也有不同的数值字面量格式。

最基本的数值字面量格式是十进制整数，直接写出来即可：

    let intNum = 55;   // 整数

整数也可以用八进制（以8为基数）或十六进制（以16为基数）字面量表示。对于八进制字面量，第一个数字必须是零（0），然后是相应的八进制数字（数值0~7）。如果字面量中包含的数字超出了应有的范围，就会忽略前缀的零，后面的数字序列会被当成十进制数，如下所示：

    let octalNum1 = 070;   // 八进制的56
    let octalNum2 = 079;   // 无效的八进制值，当成79 处理
    let octalNum3 = 08;    // 无效的八进制值，当成8 处理

八进制字面量在严格模式下是无效的，会导致JavaScript引擎抛出语法错误。

要创建十六进制字面量，必须让真正的数值前缀0x（区分大小写），然后是十六进制数字（0~9以及A~F）。十六进制数字中的字母大小写均可。下面是几个例子：

    let hexNum1 = 0xA;    // 十六进制10
    let hexNum2 = 0x1f;   // 十六进制31

使用八进制和十六进制格式创建的数值在所有数学操作中都被视为十进制数值。

注意 由于JavaScript保存数值的方式，实际中可能存在正零（+0）和负零（-0）。正零和负零在所有情况下都被认为是等同的，这里特地说明一下。

1．浮点值​

要定义浮点值，数值中必须包含小数点，而且小数点后面必须至少有一个数字。虽然小数点前面不是必须有整数，但推荐加上。 下面是几个例子：

    let floatNum1 = 1.1;
    let floatNum2 = 0.1;
    let floatNum3 = .1;    // 有效，但不推荐

因为存储浮点值使用的内存空间是存储整数值的两倍，所以ECMAScript总是想方设法把值转换为整数。在小数点后面没有数字的情况下，数值就会变成整数。类似地，如果数值本身就是整数，只是小数点后面跟着0（如1.0），那它也会被转换为整数，如下例所示：

    let floatNum1 = 1.;    // 小数点后面没有数字，当成整数1 处理
    let floatNum2 = 10.0; // 小数点后面是零，当成整数10 处理

对于非常大或非常小的数值，浮点值可以用科学记数法来表示。科学记数法用于表示一个应该乘以10的给定次幂的数值。ECMAScript中科学记数法的格式要求是一个数值（整数或浮点数）后跟一个大写或小写的字母e，再加上一个要乘的10的多少次幂。 比如：

    let floatNum = 3.125e7; // 等于31250000

在这个例子中，floatNum等于31250000，只不过科学记数法显得更简洁。这种表示法实际上相当于说：“以3.125作为系数，乘以10的7次幂。”

科学记数法也可以用于表示非常小的数值，例如0.00000000000000003。这个数值用科学记数法可以表示为3e-17。默认情况下，ECMAScript会将小数点后至少包含6个零的浮点值转换为科学记数法（例如，0.000000 3会被转换为3e-7）。

浮点值的精确度最高可达17位小数，但在算术计算中远不如整数精确。例如，0.1加0.2得到的不是0.3，而是0.30000000000000004。由于这种微小的舍入错误，导致很难测试特定的浮点值。比如下面的例子：

    if (a + b == 0.3) {        // 别这么干！
      console.log("You got 0.3.");
    }

这里检测两个数值之和是否等于0.3。如果两个数值分别是0.05和0.25，或者0.15和0.15，那没问题。但如果是0.1和0.2，如前所述，测试将失败。因此永远不要测试某个特定的浮点值。

2．值的范围​

由于内存的限制，ECMAScript并不支持表示这个世界上的所有数值。ECMAScript可以表示的最小数值保存在Number.MIN_VALUE中，这个值在多数浏览器中是5e-324；可以表示的最大数值保存在Number.MAX_VALUE中，这个值在多数浏览器中是1.797693134862315 7e+308。如果某个计算得到的数值结果超出了JavaScript可以表示的范围，那么这个数值会被自动转换为一个特殊的Infinity（无穷）值。任何无法表示的负数以-Infinity（负无穷大）表示，任何无法表示的正数以Infinity（正无穷大）表示。

如果计算返回正Infinity或负Infinity，则该值将不能再进一步用于任何计算。这是因为Infinity没有可用于计算的数值表示形式。要确定一个值是不是有限大（即介于JavaScript能表示的最小值和最大值之间），可以使用isFinite()函数，如下所示：

    let result = Number.MAX_VALUE + Number.MAX_VALUE;
    console.log(isFinite(result));   // false

虽然超出有限数值范围的计算并不多见，但总归还是有可能的。因此在计算非常大或非常小的数值时，有必要监测一下计算结果是否超出范围。

注意 使用Number.NEGATIVE_INFINITY和Number.POSITIVE_INFINITY也可以获取正、负Infinity。没错，这两个属性包含的值分别就是-Infinity和Infinity。

3．NaN​

有一个特殊的数值叫NaN，意思是“不是数值”（Not a Number），用于表示本来要返回数值的操作失败了（而不是抛出错误）。比如，用0除任意数值在其他语言中通常都会导致错误，从而中止代码执行。但在ECMAScript中，0、+0或-0相除会返回NaN：

    console.log(0/0);     // NaN
    console.log(-0/+0);   // NaN

如果分子是非0值，分母是有符号0或无符号0，则会返回Infinity或-Infinity：****

    console.log(5/0);    // Infinity
    console.log(5/-0);   // -Infinity

NaN有几个独特的属性。首先，任何涉及NaN的操作始终返回NaN（如NaN/10），在连续多步计算时这可能是个问题。其次，NaN不等于包括NaN在内的任何值。例如，下面的比较操作会返回false：

    console.log(NaN == NaN); // false

为此，ECMAScript提供了isNaN()函数。该函数接收一个参数，可以是任意数据类型，然后判断这个参数是否“不是数值”。把一个值传给isNaN()后，该函数会尝试把它转换为数值。某些非数值的值可以直接转换成数值，如字符串"10"或布尔值。任何不能转换为数值的值都会导致这个函数返回true。 举例如下：

    console.log(isNaN(NaN));      // true
    console.log(isNaN(10));        // false，10 是数值
    console.log(isNaN("10"));     // false，可以转换为数值10
    console.log(isNaN("blue"));   // true，不可以转换为数值
    console.log(isNaN(true));     // false，可以转换为数值1

上述的例子测试了5个不同的值。首先测试的是NaN本身，显然会返回true。接着测试了数值10和字符串"10"，都返回false，因为它们的数值都是10。字符串"blue"不能转换为数值，因此函数返回true。布尔值true可以转换为数值1，因此返回false。

注意 虽然不常见，但isNaN()可以用于测试对象。此时，首先会调用对象的valueOf()方法，然后再确定返回的值是否可以转换为数值。如果不能，再调用toString()方法，并测试其返回值。

4．数值转换​

有3个函数可以将非数值转换为数值：Number()、parseInt()和parseFloat()。Number()是转型函数，可用于任何数据类型。后两个函数主要用于将字符串转换为数值。对于同样的参数，这3个函数执行的操作也不同。

Number()函数基于如下规则执行转换。

  • 布尔值，true转换为1，false转换为0。
  • 数值，直接返回。
  • null，返回0。
  • undefined，返回NaN。
  • 字符串，应用以下规则。
    • 如果字符串包含数值字符，包括数值字符前面带加、减号的情况，则转换为一个十进制数值。因此，Number("1")返回1, Number("123")返回123, Number("011")返回11（忽略前面的零）。
    • 如果字符串包含有效的浮点值格式如"1.1"，则会转换为相应的浮点值（同样，忽略前面的零）。
    • 如果字符串包含有效的十六进制格式如"0xf"，则会转换为与该十六进制值对应的十进制整数值。
    • 如果是空字符串（不包含字符），则返回0。
    • 如果字符串包含除上述情况之外的其他字符，则返回NaN。
  • 对象，调用valueOf()方法，并按照上述规则转换返回的值。如果转换结果是NaN，则调用toString()方法，再按照转换字符串的规则转换。

从不同数据类型到数值的转换有时候会比较复杂，看一看Number()的转换规则就知道了。下面是几个具体的例子：

    let num1 = Number("Hello world! ");   // NaN
    let num2 = Number("");                  // 0
    let num3 = Number("000011");          // 11
    let num4 = Number(true);               // 1

可以看到，字符串"Hello world"转换之后是NaN，因为它找不到对应的数值。空字符串转换后是0。字符串000011转换后是11，因为前面的零被忽略了。最后，true转换为1。

考虑到用Number()函数转换字符串时相对复杂且有点反常规，通常在需要得到整数时可以优先使用parseInt()函数。parseInt()函数更专注于字符串是否包含数值模式。字符串最前面的空格会被忽略，从第一个非空格字符开始转换。如果第一个字符不是数值字符、加号或减号，parseInt()立即返回NaN。 这意味着空字符串也会返回NaN（这一点跟Number()不一样，它返回0）。如果第一个字符是数值字符、加号或减号，则继续依次检测每个字符，直到字符串末尾，或碰到非数值字符。比如，"1234blue"会被转换为1234，因为"blue"会被完全忽略。类似地，"22.5"会被转换为22，因为小数点不是有效的整数字符。

假设字符串中的第一个字符是数值字符，parseInt()函数也能识别不同的整数格式（十进制、八进制、十六进制）。换句话说，如果字符串以"0x"开头，就会被解释为十六进制整数。如果字符串以"0"开头，且紧跟着数值字符，在非严格模式下会被某些实现解释为八进制整数。下面几个转换示例有助于理解上述规则：

    let num1 = parseInt("1234blue");   // 1234
    let num2 = parseInt("");             // NaN
    let num3 = parseInt("0xA");         // 10，解释为十六进制整数
    let num4 = parseInt(22.5);          // 22
    let num5 = parseInt("70");          // 70，解释为十进制值
    let num6 = parseInt("0xf");         // 15，解释为十六进制整数

不同的数值格式很容易混淆，因此parseInt()也接收第二个参数，用于指定底数（进制数）。 如果知道要解析的值是十六进制，那么可以传入16作为第二个参数，以便正确解析：

    let num = parseInt("0xAF", 16); // 175

事实上，如果提供了十六进制参数，那么字符串前面的"0x"可以省掉：

    let num1 = parseInt("AF", 16);   // 175
    let num2 = parseInt("AF");        // NaN

在这个例子中，第一个转换是正确的，而第二个转换失败了。区别在于第一次传入了进制数作为参数，告诉parseInt()要解析的是一个十六进制字符串。而第二个转换检测到第一个字符就是非数值字符，随即自动停止并返回NaN。通过第二个参数，可以极大扩展转换后获得的结果类型。 比如：

    let num1 = parseInt("10", 2);    // 2，按二进制解析
    let num2 = parseInt("10", 8);    // 8，按八进制解析
    let num3 = parseInt("10", 10);   // 10，按十进制解析
    let num4 = parseInt("10", 16);   // 16，按十六进制解析

因为不传底数参数相当于让parseInt()自己决定如何解析，所以为避免解析出错，建议始终传给它第二个参数。

注意 多数情况下解析的应该都是十进制数，此时第二个参数就要传入10。

parseFloat()函数的工作方式跟parseInt()函数类似，都是从位置0开始检测每个字符。同样，它也是解析到字符串末尾或者解析到一个无效的浮点数值字符为止。这意味着第一次出现的小数点是有效的，但第二次出现的小数点就无效了，此时字符串的剩余字符都会被忽略。因此，"22.34.5"将转换成22.34。

parseFloat()函数的另一个不同之处在于，它始终忽略字符串开头的零。这个函数能识别前面讨论的所有浮点格式，以及十进制格式（开头的零始终被忽略）。十六进制数值始终会返回0。因为parseFloat()只解析十进制值，因此不能指定底数。最后，如果字符串表示整数（没有小数点或者小数点后面只有一个零），则parseFloat()返回整数。下面是几个示例：

    let num1 = parseFloat("1234blue");   // 1234，按整数解析
    let num2 = parseFloat("0xA");         // 0
    let num3 = parseFloat("22.5");        // 22.5
    let num4 = parseFloat("22.34.5");    // 22.34
    let num5 = parseFloat("0908.5");     // 908.5
    let num6 = parseFloat("3.125e7");    // 31250000

String类型​

String（字符串）数据类型表示零或多个16位Unicode字符序列。字符串可以使用双引号（"）、单引号（'）或反引号（`）标示，因此下面的代码都是合法的：

    let firstName = "John";
    let lastName = 'Jacob';
    let lastName = `Jingleheimerschmidt`

跟某些语言中使用不同的引号会改变对字符串的解释方式不同，ECMAScript语法中表示字符串的引号没有区别。不过要注意的是，以某种引号作为字符串开头，必须仍然以该种引号作为字符串结尾。比如，下面的写法会导致语法错误：

    let firstName = 'Nicholas"; // 语法错误：开头和结尾的引号必须是同一种

1．字符字面量​

字符串数据类型包含一些字符字面量，用于表示非打印字符或有其他用途的字符，如下表所示：

image

这些字符字面量可以出现在字符串中的任意位置，且可以作为单个字符被解释：

    let text = "This is the letter sigma: \u03a3.";

在这个例子中，即使包含6个字符长的转义序列，变量text仍然是28个字符长。因为转义序列表示一个字符，所以只算一个字符。

字符串的长度可以通过其length属性获取：

    console.log(text.length); // 28

这个属性返回字符串中16位字符的个数。

注意 如果字符串中包含双字节字符，那么length属性返回的值可能不是准确的字符数。

2．字符串的特点​

ECMAScript中的字符串是不可变的（immutable），意思是一旦创建，它们的值就不能变了。要修改某个变量中的字符串值，必须先销毁原始的字符串，然后将包含新值的另一个字符串保存到该变量，如下所示：

    let lang = "Java";
    lang = lang + "Script";

这里，变量lang一开始包含字符串"Java"。紧接着，lang被重新定义为包含"Java"和"Script"的组合，也就是"JavaScript"。整个过程首先会分配一个足够容纳10个字符的空间，然后填充上"Java"和"Script"。最后销毁原始的字符串"Java"和字符串"Script"，因为这两个字符串都没有用了。所有处理都是在后台发生的，而这也是一些早期的浏览器（如Firefox 1.0之前的版本和IE6.0）在拼接字符串时非常慢的原因。这些浏览器在后来的版本中都有针对性地解决了这个问题。

3．转换为字符串​

有两种方式把一个值转换为字符串。首先是使用几乎所有值都有的toString()方法。这个方法唯一的用途就是返回当前值的字符串等价物。比如：

    let age = 11;
    let ageAsString = age.toString();        // 字符串"11"
    let found = true;
    let foundAsString = found.toString();   // 字符串"true"

toString()方法可见于数值、布尔值、对象和字符串值。（没错，字符串值也有toString()方法，该方法只是简单地返回自身的一个副本。）null和undefined值没有toString()方法。

多数情况下，toString()不接收任何参数。不过，在对数值调用这个方法时，toString()可以接收一个底数参数，即以什么底数来输出数值的字符串表示。默认情况下，toString()返回数值的十进制字符串表示。而通过传入参数，可以得到数值的二进制、八进制、十六进制，或者其他任何有效基数的字符串表示，比如：

    let num = 10;
    console.log(num.toString());      // "10"
    console.log(num.toString(2));     // "1010"
    console.log(num.toString(8));     // "12"
    console.log(num.toString(10));    // "10"
    console.log(num.toString(16));    // "a"

这个例子展示了传入底数参数时，toString()输出的字符串值也会随之改变。数值10可以输出为任意数值格式。注意，默认情况下（不传参数）的输出与传入参数10得到的结果相同。

如果你不确定一个值是不是null或undefined，可以使用String()转型函数，它始终会返回表示相应类型值的字符串。String()函数遵循如下规则。

  • 如果值有toString()方法，则调用该方法（不传参数）并返回结果。
  • 如果值是null，返回"null"。
  • 如果值是undefined，返回"undefined"。

下面看几个例子：

    let value1 = 10;
    let value2 = true;
    let value3 = null;
    let value4;
    console.log(String(value1)); // "10"
    console.log(String(value2));   // "true"
    console.log(String(value3));   // "null"
    console.log(String(value4));   // "undefined"

这里展示了将4个值转换为字符串的情况：一个数值、一个布尔值、一个null和一个undefined。数值和布尔值的转换结果与调用toString()相同。因为null和undefined没有toString()方法，所以String()方法就直接返回了这两个值的字面量文本。

注意 用加号操作符给一个值加上一个空字符串""也可以将其转换为字符串。

4．模板字面量​

ECMAScript 6新增了使用模板字面量定义字符串的能力。与使用单引号或双引号不同，模板字面量保留换行字符，可以跨行定义字符串：

    let myMultiLineString = 'first line\nsecond line';
    let myMultiLineTemplateLiteral = `first line
    second line`;
    console.log(myMultiLineString);
    // first line
    // second line"
    console.log(myMultiLineTemplateLiteral);
    // first line
    // second line
    console.log(myMultiLineString === myMultiLinetemplateLiteral); // true

顾名思义，模板字面量在定义模板时特别有用，比如下面这个HTML模板：

    let pageHTML = `
    <div>
      <a href="#">
        <span>Jake</span>
      </a>
    </div>`;

由于模板字面量会保持反引号内部的空格，因此在使用时要格外注意。格式正确的模板字符串看起来可能会缩进不当：

    // 这个模板字面量在换行符之后有25 个空格符
    let myTemplateLiteral = `first line
                              second line`;
    console.log(myTemplateLiteral.length);   // 47
    // 这个模板字面量以一个换行符开头
    let secondTemplateLiteral = `
    first line
    second line`;
    console.log(secondTemplateLiteral[0] === '\n'); // true
    // 这个模板字面量没有意料之外的字符
    let thirdTemplateLiteral = `first line
    second line`;
    console.log(thirdTemplateLiteral);
    // first line
    // second line

5．字符串插值​

模板字面量最常用的一个特性是支持字符串插值，也就是可以在一个连续定义中插入一个或多个值。技术上讲，模板字面量不是字符串，而是一种特殊的JavaScript句法表达式，只不过求值后得到的是字符串。模板字面量在定义时立即求值并转换为字符串实例，任何插入的变量也会从它们最接近的作用域中取值。

字符串插值通过在${}中使用一个JavaScript表达式实现：

    let value = 5;
    let exponent = 'second';
    // 以前，字符串插值是这样实现的：
    let interpolatedString =
      value + ' to the ' + exponent + ' power is ' + (value ＊ value);
    // 现在，可以用模板字面量这样实现：
    let interpolatedTemplateLiteral =
      `${ value } to the ${ exponent } power is ${ value ＊ value }`;
    console.log(interpolatedString);              // 5 to the second power is 25
    console.log(interpolatedTemplateLiteral);   // 5 to the second power is 25

所有插入的值都会使用toString()强制转型为字符串，而且任何JavaScript表达式都可以用于插值。嵌套的模板字符串无须转义：

    console.log(`Hello, ${ `World` }! `);   // Hello, World!

将表达式转换为字符串时会调用toString()：

    let foo = { toString: () => 'World' };
    console.log(`Hello, ${ foo }! `);        // Hello, World!

在插值表达式中可以调用函数和方法：

    function capitalize(word) {
      return `${ word[0].toUpperCase() }${ word.slice(1) }`;
    }
    console.log(`${ capitalize('hello') }, ${ capitalize('world') }! `); // Hello, World!

此外，模板也可以插入自己之前的值：

    let value = '';
    function append() {
      value = `${value}abc`
      console.log(value);
    }
    append();   // abc
    append();   // abcabc
    append();   // abcabcabc

6．模板字面量标签函数​

模板字面量也支持定义标签函数（tag function），而通过标签函数可以自定义插值行为。标签函数会接收被插值记号分隔后的模板和对每个表达式求值的结果。

标签函数本身是一个常规函数，通过前缀到模板字面量来应用自定义行为，如下例所示。标签函数接收到的参数依次是原始字符串数组和对每个表达式求值的结果。这个函数的返回值是对模板字面量求值得到的字符串。

最好通过一个例子来理解：

    let a = 6;
    let b = 9;
    function simpleTag(strings, aValExpression, bValExpression, sumExpression) {
      console.log(strings);
      console.log(aValExpression);
      console.log(bValExpression);
      console.log(sumExpression);
      return 'foobar';
    }
    let untaggedResult = `${ a } + ${ b } = ${ a + b }`;
    let taggedResult=simpleTag`${a}+${b}=${a+b}`;
    // ["", " + ", " = ", ""]
    // 6
    // 9
    // 15
    console.log(untaggedResult);    // "6 + 9 = 15"
    console.log(taggedResult);      // "foobar"

因为表达式参数的数量是可变的，所以通常应该使用剩余操作符（rest operator）将它们收集到一个数组中：

    let a = 6;
    let b = 9;
    functionsimpleTag(strings, ...expressions){
      console.log(strings);
      for(const expression of expressions) {
        console.log(expression);
      }
      return 'foobar';
    }
    let taggedResult = simpleTag`${ a } + ${ b } = ${ a + b }`;
    // ["", " + ", " = ", ""]
    // 6
    // 9
    // 15
    console.log(taggedResult);   // "foobar"

对于有n个插值的模板字面量，传给标签函数的表达式参数的个数始终是n，而传给标签函数的第一个参数所包含的字符串个数则始终是n+1。因此，如果你想把这些字符串和对表达式求值的结果拼接起来作为默认返回的字符串，可以这样做：

    let a = 6;
    let b = 9;
    function zipTag(strings, ...expressions) {
      return strings[0] +
              expressions.map((e, i) => `${e}${strings[i + 1]}`)
                        .join('');
    }
    let untaggedResult =     `${ a } + ${ b } = ${ a + b }`;
    let taggedResult = zipTag`${ a } + ${ b } = ${ a + b }`;
    console.log(untaggedResult);   // "6 + 9 = 15"
    console.log(taggedResult);     // "6 + 9 = 15"

7．原始字符串​

使用模板字面量也可以直接获取原始的模板字面量内容（如换行符或Unicode字符），而不是被转换后的字符表示。为此，可以使用默认的String.raw标签函数：

    // Unicode示例
    // \u00A9 是版权符号
    console.log(`\u00A9`);               // ©
    console.log(String.raw`\u00A9`);   // \u00A9
    // 换行符示例
    console.log(`first line\nsecond line`);
    // first line
    // second line
    console.log(String.raw`first line\nsecond line`); // "first line\nsecond line"
    // 对实际的换行符来说是不行的
    // 它们不会被转换成转义序列的形式
    console.log(`first line
    second line`);
    // first line
    // second line
    console.log(String.raw`first line
    second line`);
    // first line
    // second line

另外，也可以通过标签函数的第一个参数，即字符串数组的．raw属性取得每个字符串的原始内容：

    function printRaw(strings) {
      console.log('Actual characters:');
      for (const string of strings) {
        console.log(string);
      }
      console.log('Escaped characters; ');
      for (const rawString of strings.raw) {
        console.log(rawString);
      }
    }
    printRaw`\u00A9${ 'and' }\n`;
    // Actual characters:
    // ©
    //（换行符）
    // Escaped characters:
    // \u00A9
    // \n

Symbol类型​

Symbol（符号）是ECMAScript 6新增的数据类型。符号是原始值，且符号实例是唯一、不可变的。符号的用途是确保对象属性使用唯一标识符，不会发生属性冲突的危险。

尽管听起来跟私有属性有点类似，但符号并不是为了提供私有属性的行为才增加的（尤其是因为Object API提供了方法，可以更方便地发现符号属性）。相反，符号就是用来创建唯一记号，进而用作非字符串形式的对象属性。

1．符号的基本用法​

符号需要使用Symbol()函数初始化。因为符号本身是原始类型，所以typeof操作符对符号返回symbol。

    let sym = Symbol();
    console.log(typeof sym); // symbol

调用Symbol()函数时，也可以传入一个字符串参数作为对符号的描述（description），将来可以通过这个字符串来调试代码。但是，这个字符串参数与符号定义或标识完全无关：

    let genericSymbol = Symbol();
    let otherGenericSymbol = Symbol();
    let fooSymbol = Symbol('foo');
    let otherFooSymbol = Symbol('foo');
    console.log(genericSymbol == otherGenericSymbol);   // false
    console.log(fooSymbol == otherFooSymbol);             // false

符号没有字面量语法，这也是它们发挥作用的关键。按照规范，你只要创建Symbol()实例并将其用作对象的新属性，就可以保证它不会覆盖已有的对象属性，无论是符号属性还是字符串属性。

    let genericSymbol = Symbol();
    console.log(genericSymbol);   // Symbol()
    let fooSymbol = Symbol('foo');
    console.log(fooSymbol);        // Symbol(foo);

最重要的是，Symbol()函数不能与new关键字一起作为构造函数使用。这样做是为了避免创建符号包装对象，像使用Boolean、String或Number那样，它们都支持构造函数且可用于初始化包含原始值的包装对象：

    let myBoolean = new Boolean();
    console.log(typeof myBoolean); // "object"
    let myString = new String();
    console.log(typeof myString);   // "object"
    let myNumber = new Number();
    console.log(typeof myNumber);   // "object"
    letmySymbol=newSymbol();//TypeError: Symbolisnotaconstructor

如果你确实想使用符号包装对象，可以借用Object()函数：

    let mySymbol = Symbol();
    let myWrappedSymbol = Object(mySymbol);
    console.log(typeof myWrappedSymbol);    // "object"

2．使用全局符号注册表​

如果运行时的不同部分需要共享和重用符号实例，那么可以用一个字符串作为键，在全局符号注册表中创建并重用符号。

为此，需要使用Symbol.for()方法：

    let fooGlobalSymbol = Symbol.for('foo');
    console.log(typeof fooGlobalSymbol); // symbol

Symbol.for()对每个字符串键都执行幂等操作。第一次使用某个字符串调用时，它会检查全局运行时注册表，发现不存在对应的符号，于是就会生成一个新符号实例并添加到注册表中。后续使用相同字符串的调用同样会检查注册表，发现存在与该字符串对应的符号，然后就会返回该符号实例。

    let fooGlobalSymbol = Symbol.for('foo');         // 创建新符号
    let otherFooGlobalSymbol = Symbol.for('foo');   // 重用已有符号
    console.log(fooGlobalSymbol === otherFooGlobalSymbol);   // true

即使采用相同的符号描述，在全局注册表中定义的符号跟使用Symbol()定义的符号也并不等同：

    let localSymbol = Symbol('foo');
    let globalSymbol = Symbol.for('foo');
    console.log(localSymbol === globalSymbol); // false

全局注册表中的符号必须使用字符串键来创建，因此作为参数传给Symbol.for()的任何值都会被转换为字符串。此外，注册表中使用的键同时也会被用作符号描述。

    let emptyGlobalSymbol = Symbol.for();
    console.log(emptyGlobalSymbol);     // Symbol(undefined)

还可以使用Symbol.keyFor()来查询全局注册表，这个方法接收符号，返回该全局符号对应的字符串键。如果查询的不是全局符号，则返回undefined。

    // 创建全局符号
    let s = Symbol.for('foo');
    console.log(Symbol.keyFor(s));    // foo
    // 创建普通符号
    let s2 = Symbol('bar');
    console.log(Symbol.keyFor(s2));   // undefined

如果传给Symbol.keyFor()的不是符号，则该方法抛出TypeError：

    Symbol.keyFor(123); // TypeError: 123 is not a symbol

3．使用符号作为属性​

凡是可以使用字符串或数值作为属性的地方，都可以使用符号。这就包括了对象字面量属性和Object.defineProperty()/Object.defineProperties()定义的属性。对象字面量只能在计算属性语法中使用符号作为属性。

    let s1 = Symbol('foo'),
        s2 = Symbol('bar'),
        s3 = Symbol('baz'),
        s4 = Symbol('qux');
    let o = {
      [s1]: 'foo val'
    };
    // 这样也可以：o[s1] = 'foo val';
    console.log(o);
    // {Symbol(foo): foo val}
    Object.defineProperty(o, s2, {value: 'bar val'});
    console.log(o);
    // {Symbol(foo): foo val, Symbol(bar): bar val}
    Object.defineProperties(o, {
      [s3]: {value: 'baz val'},
      [s4]: {value: 'qux val'}
    });
    console.log(o);
    // {Symbol(foo): foo val, Symbol(bar): bar val,
    //   Symbol(baz): baz val, Symbol(qux): qux val}

类似于Object.getOwnPropertyNames()返回对象实例的常规属性数组，Object.getOwnProperty-Symbols()返回对象实例的符号属性数组。这两个方法的返回值彼此互斥。Object.getOwnProperty-Descriptors()会返回同时包含常规和符号属性描述符的对象。Reflect.ownKeys()会返回两种类型的键：

    let s1 = Symbol('foo'),
        s2 = Symbol('bar');
    let o = {
      [s1]: 'foo val',
      [s2]: 'bar val',
      baz: 'baz val',
      qux: 'qux val'
    };
    console.log(Object.getOwnPropertySymbols(o));
    // [Symbol(foo), Symbol(bar)]
    console.log(Object.getOwnPropertyNames(o));
    // ["baz", "qux"]
    console.log(Object.getOwnPropertyDescriptors(o));
    // {baz: {...}, qux: {...}, Symbol(foo): {...}, Symbol(bar): {...}}
    console.log(Reflect.ownKeys(o));
    // ["baz", "qux", Symbol(foo), Symbol(bar)]

因为符号属性是对内存中符号的一个引用，所以直接创建并用作属性的符号不会丢失。但是，如果没有显式地保存对这些属性的引用，那么必须遍历对象的所有符号属性才能找到相应的属性键：

    let o = {
      [Symbol('foo')]: 'fooval',
      [Symbol('bar')]: 'barval'
    };
    console.log(o);
    // {Symbol(foo): "foo val", Symbol(bar): "bar val"}
    let barSymbol = Object.getOwnPropertySymbols(o)
                  .find((symbol) => symbol.toString().match(/bar/));
    console.log(barSymbol);
    // Symbol(bar)

4．常用内置符号​

ECMAScript 6也引入了一批常用内置符号（well-known symbol），用于暴露语言内部行为，开发者可以直接访问、重写或模拟这些行为。这些内置符号都以Symbol工厂函数字符串属性的形式存在。

这些内置符号最重要的用途之一是重新定义它们，从而改变原生结构的行为。比如，我们知道for-of循环会在相关对象上使用Symbol.iterator属性，那么就可以通过在自定义对象上重新定义Symbol.iterator的值，来改变for-of在迭代该对象时的行为。

这些内置符号也没有什么特别之处，它们就是全局函数Symbol的普通字符串属性，指向一个符号的实例。所有内置符号属性都是不可写、不可枚举、不可配置的。

注意 在提到ECMAScript规范时，经常会引用符号在规范中的名称，前缀为@@。比如，@@iterator指的就是Symbol.iterator。

5．Symbol.asyncIterator​

根据ECMAScript规范，这个符号作为一个属性表示“一个方法，该方法返回对象默认的AsyncIterator。由for-await-of语句使用”。换句话说，这个符号表示实现异步迭代器API的函数。

for-await-of循环会利用这个函数执行异步迭代操作。循环时，它们会调用以Symbol.asyncIterator为键的函数，并期望这个函数会返回一个实现迭代器API的对象。很多时候，返回的对象是实现该API的AsyncGenerator：

    class Foo {
      async ＊[Symbol.asyncIterator]() {}
    }
    let f = new Foo();
    console.log(f[Symbol.asyncIterator]());
    // AsyncGenerator {<suspended>}

技术上，这个由Symbol.asyncIterator函数生成的对象应该通过其next()方法陆续返回Promise实例。可以通过显式地调用next()方法返回，也可以隐式地通过异步生成器函数返回：

    class Emitter {
      constructor(max) {
        this.max = max;
        this.asyncIdx = 0;
      }
      async＊[Symbol.asyncIterator](){
        while(this.asyncIdx < this.max) {
          yield new Promise((resolve) => resolve(this.asyncIdx++));
        }
      }
    }
    async function asyncCount() {
      let emitter = new Emitter(5);
      for await(const x of emitter) {
        console.log(x);
      }
    }
    asyncCount();
    // 0
    // 1
    // 2
    // 3
    // 4

6．Symbol.hasInstance​

根据ECMAScript规范，这个符号作为一个属性表示“一个方法，该方法决定一个构造器对象是否认可一个对象是它的实例。由instanceof操作符使用”。instanceof操作符可以用来确定一个对象实例的原型链上是否有原型。instanceof的典型使用场景如下：

    function Foo() {}
    let f = new Foo();
    console.log(f instanceof Foo); // true
    class Bar {}
    let b = new Bar();
    console.log(b instanceof Bar); // true

在ES6中，instanceof操作符会使用Symbol.hasInstance函数来确定关系。以Symbol. hasInstance为键的函数会执行同样的操作，只是操作数对调了一下：

    function Foo() {}
    let f = new Foo();
    console.log(Foo[Symbol.hasInstance](f)); // true
    class Bar {}
    let b = new Bar();
    console.log(Bar[Symbol.hasInstance](b)); // true

这个属性定义在Function的原型上，因此默认在所有函数和类上都可以调用。由于instanceof操作符会在原型链上寻找这个属性定义，就跟在原型链上寻找其他属性一样，因此可以在继承的类上通过静态方法重新定义这个函数：

    class Bar {}
    class Baz extends Bar {
      static[Symbol.hasInstance](){
        returnfalse;
      }
    }
    let b = new Baz();
    console.log(Bar[Symbol.hasInstance](b)); // true
    console.log(b instanceof Bar);              // true
    console.log(Baz[Symbol.hasInstance](b));//false
    console.log(binstanceofBaz);             //false

7．Symbol.isConcatSpreadable​

根据ECMAScript规范，这个符号作为一个属性表示“一个布尔值，如果是true，则意味着对象应该用Array.prototype.concat()打平其数组元素”。ES6中的Array.prototype.concat()方法会根据接收到的对象类型选择如何将一个类数组对象拼接成数组实例。覆盖Symbol.isConcat-Spreadable的值可以修改这个行为。

数组对象默认情况下会被打平到已有的数组，false或假值会导致整个对象被追加到数组末尾。类数组对象默认情况下会被追加到数组末尾，true或真值会导致这个类数组对象被打平到数组实例。其他不是类数组对象的对象在Symbol.isConcatSpreadable被设置为true的情况下将被忽略。

    let initial = ['foo'];
    let array = ['bar'];
    console.log(array[Symbol.isConcatSpreadable]);   // undefined
    console.log(initial.concat(array));                // ['foo', 'bar']
    array[Symbol.isConcatSpreadable]=false;
    console.log(initial.concat(array));                // ['foo', Array(1)]
    let arrayLikeObject = { length: 1, 0: 'baz' };
    console.log(arrayLikeObject[Symbol.isConcatSpreadable]);   // undefined
    console.log(initial.concat(arrayLikeObject));                // ['foo', {...}]
    arrayLikeObject[Symbol.isConcatSpreadable]=true;
    console.log(initial.concat(arrayLikeObject));                // ['foo', 'baz']
    let otherObject = new Set().add('qux');
    console.log(otherObject[Symbol.isConcatSpreadable]);   // undefined
    console.log(initial.concat(otherObject));                // ['foo', Set(1)]
    otherObject[Symbol.isConcatSpreadable]=true;
    console.log(initial.concat(otherObject));                // ['foo']

8．Symbol.iterator​

根据ECMAScript规范，这个符号作为一个属性表示“一个方法，该方法返回对象默认的迭代器。由for-of语句使用”。换句话说，这个符号表示实现迭代器API的函数。

for-of循环这样的语言结构会利用这个函数执行迭代操作。循环时，它们会调用以Symbol.iterator为键的函数，并默认这个函数会返回一个实现迭代器API的对象。很多时候，返回的对象是实现该API的Generator：

    class Foo {
      ＊[Symbol.iterator]() {}
    }
    let f = new Foo();
    console.log(f[Symbol.iterator]());
    // Generator {<suspended>}

技术上，这个由Symbol.iterator函数生成的对象应该通过其next()方法陆续返回值。可以通过显式地调用next()方法返回，也可以隐式地通过生成器函数返回：

    class Emitter {
      constructor(max) {
        this.max = max;
        this.idx = 0;
      }
      ＊[Symbol.iterator](){
        while(this.idx < this.max) {
          yield this.idx++;
        }
      }
    }
    function count() {
      let emitter = new Emitter(5);
      for (const x of emitter) {
        console.log(x);
      }
    }
    count();
    // 0
    // 1
    // 2
    // 3
    // 4

9．Symbol.match​

根据ECMAScript规范，这个符号作为一个属性表示“一个正则表达式方法，该方法用正则表达式去匹配字符串。由String.prototype.match()方法使用”。

String.prototype.match()方法会使用以Symbol.match为键的函数来对正则表达式求值。正则表达式的原型上默认有这个函数的定义，因此所有正则表达式实例默认是这个String方法的有效参数：

    console.log(RegExp.prototype[Symbol.match]);
    // f [Symbol.match]() { [native code] }
    console.log('foobar'.match(/bar/));
    // ["bar", index: 3, input: "foobar", groups: undefined]

给这个方法传入非正则表达式值会导致该值被转换为RegExp对象。如果想改变这种行为，让方法直接使用参数，则可以重新定义Symbol.match函数以取代默认对正则表达式求值的行为，从而让match()方法使用非正则表达式实例。Symbol.match函数接收一个参数，就是调用match()方法的字符串实例。返回的值没有限制：

    class FooMatcher {
      static[Symbol.match](target){
        returntarget.includes('foo');
      }
    }
    console.log('foobar'.match(FooMatcher)); // true
    console.log('barbaz'.match(FooMatcher)); // false
    class StringMatcher {
      constructor(str) {
        this.str = str;
      }
      [Symbol.match](target){
        returntarget.includes(this.str);
      }
    }
    console.log('foobar'.match(new StringMatcher('foo'))); // true
    console.log('barbaz'.match(new StringMatcher('qux'))); // false

10．Symbol.replace​

根据ECMAScript规范，这个符号作为一个属性表示“一个正则表达式方法，该方法替换一个字符串中匹配的子串。由String.prototype.replace()方法使用”。String.prototype.replace()方法会使用以Symbol.replace为键的函数来对正则表达式求值。正则表达式的原型上默认有这个函数的定义，因此所有正则表达式实例默认是这个String方法的有效参数：

    console.log(RegExp.prototype[Symbol.replace]);
    // f [Symbol.replace]() { [native code] }
    console.log('foobarbaz'.replace(/bar/, 'qux'));
    // 'fooquxbaz'

给这个方法传入非正则表达式值会导致该值被转换为RegExp对象。如果想改变这种行为，让方法直接使用参数，可以重新定义Symbol.replace函数以取代默认对正则表达式求值的行为，从而让replace()方法使用非正则表达式实例。Symbol.replace函数接收两个参数，即调用replace()方法的字符串实例和替换字符串。返回的值没有限制：

    class FooReplacer {
      static[Symbol.replace](target, replacement){
        returntarget.split('foo').join(replacement);
      }
    }
    console.log('barfoobaz'.replace(FooReplacer, 'qux'));
    // "barquxbaz"
    class StringReplacer {
      constructor(str) {
        this.str = str;
      }
      [Symbol.replace](target, replacement){
        returntarget.split(this.str).join(replacement);
      }
    }
    console.log('barfoobaz'.replace(new StringReplacer('foo'), 'qux'));
    // "barquxbaz"

11．Symbol.search​

根据ECMAScript规范，这个符号作为一个属性表示“一个正则表达式方法，该方法返回字符串中匹配正则表达式的索引。由String.prototype.search()方法使用”。

String.prototype.search()方法会使用以Symbol.search为键的函数来对正则表达式求值。正则表达式的原型上默认有这个函数的定义，因此所有正则表达式实例默认是这个String方法的有效参数：

    console.log(RegExp.prototype[Symbol.search]);
    // f [Symbol.search]() { [native code] }
    console.log('foobar'.search(/bar/));
    // 3

给这个方法传入非正则表达式值会导致该值被转换为RegExp对象。如果想改变这种行为，让方法直接使用参数，可以重新定义Symbol.search函数以取代默认对正则表达式求值的行为，从而让search()方法使用非正则表达式实例。Symbol.search函数接收一个参数，就是调用match()方法的字符串实例。返回的值没有限制：

    class FooSearcher {
      static[Symbol.search](target){
        returntarget.indexOf('foo');
      }
    }
    console.log('foobar'.search(FooSearcher)); // 0
    console.log('barfoo'.search(FooSearcher)); // 3
    console.log('barbaz'.search(FooSearcher)); // -1
    class StringSearcher {
      constructor(str) {
        this.str = str;
      }
      [Symbol.search](target){
        returntarget.indexOf(this.str);
      }
    }
    console.log('foobar'.search(new StringSearcher('foo'))); // 0
    console.log('barfoo'.search(new StringSearcher('foo'))); // 3
    console.log('barbaz'.search(new StringSearcher('qux'))); // -1

12．Symbol.species​

根据ECMAScript规范，这个符号作为一个属性表示“一个函数值，该函数作为创建派生对象的构造函数”。这个属性在内置类型中最常用，用于对内置类型实例方法的返回值暴露实例化派生对象的方法。用Symbol.species定义静态的获取器（getter）方法，可以覆盖新创建实例的原型定义：

    class Bar extends Array {}
    class Baz extends Array {
      staticget[Symbol.species](){
        returnArray;
      }
    }
    let bar = new Bar();
    console.log(bar instanceof Array); // true
    console.log(bar instanceof Bar);    // true
    bar = bar.concat('bar');
    console.log(bar instanceof Array); // true
    console.log(bar instanceof Bar);    // true
    let baz = new Baz();
    console.log(baz instanceof Array); // true
    console.log(baz instanceof Baz);    // true
    baz = baz.concat('baz');
    console.log(baz instanceof Array); // true
    console.log(bazinstanceofBaz);   //false

13．Symbol.split​

根据ECMAScript规范，这个符号作为一个属性表示“一个正则表达式方法，该方法在匹配正则表达式的索引位置拆分字符串。由String.prototype.split()方法使用”。String.prototype.split()方法会使用以Symbol.split为键的函数来对正则表达式求值。正则表达式的原型上默认有这个函数的定义，因此所有正则表达式实例默认是这个String方法的有效参数：

    console.log(RegExp.prototype[Symbol.split]);
    // f [Symbol.split]() { [native code] }
    console.log('foobarbaz'.split(/bar/));
    // ['foo', 'baz']

给这个方法传入非正则表达式值会导致该值被转换为RegExp对象。如果想改变这种行为，让方法直接使用参数，可以重新定义Symbol.split函数以取代默认对正则表达式求值的行为，从而让split()方法使用非正则表达式实例。Symbol.split函数接收一个参数，就是调用match()方法的字符串实例。返回的值没有限制：

    class FooSplitter {
      static[Symbol.split](target){
        returntarget.split('foo');
      }
    }
    console.log('barfoobaz'.split(FooSplitter));
    // ["bar", "baz"]
    class StringSplitter {
      constructor(str) {
        this.str = str;
      }
      [Symbol.split](target){
        returntarget.split(this.str);
      }
    }
    console.log('barfoobaz'.split(new StringSplitter('foo')));
    // ["bar", "baz"]

14．Symbol.toPrimitive​

根据ECMAScript规范，这个符号作为一个属性表示“一个方法，该方法将对象转换为相应的原始值。由ToPrimitive抽象操作使用”。很多内置操作都会尝试强制将对象转换为原始值，包括字符串、数值和未指定的原始类型。对于一个自定义对象实例，通过在这个实例的Symbol.toPrimitive属性上定义一个函数可以改变默认行为。

根据提供给这个函数的参数（string、number或default），可以控制返回的原始值：

    class Foo {}
    let foo = new Foo();
    console.log(3 + foo);         // "3[object Object]"
    console.log(3- foo);         // NaN
    console.log(String(foo));    // "[object Object]"
    class Bar {
      constructor() {
        this[Symbol.toPrimitive]=function(hint){
          switch(hint){
            case'number':
              return3;
            case'string':
              return'stringbar';
            case'default':
            default:
              return'defaultbar';
          }
        }
      }
    }
    let bar = new Bar();
    console.log(3 + bar);      // "3default bar"
    console.log(3- bar);      // 0
    console.log(String(bar)); // "string bar"

15．Symbol.toStringTag​

根据ECMAScript规范，这个符号作为一个属性表示“一个字符串，该字符串用于创建对象的默认字符串描述。由内置方法Object.prototype.toString()使用”。

通过toString()方法获取对象标识时，会检索由Symbol.toStringTag指定的实例标识符，默认为"Object"。内置类型已经指定了这个值，但自定义类实例还需要明确定义：

    let s = new Set();
    console.log(s);                            // Set(0) {}
    console.log(s.toString());              // [object Set]
    console.log(s[Symbol.toStringTag]);   // Set
    class Foo {}
    let foo = new Foo();
    console.log(foo);                            // Foo {}
    console.log(foo.toString());              // [object Object]
    console.log(foo[Symbol.toStringTag]);   // undefined
    class Bar {
      constructor() {
        this[Symbol.toStringTag] = 'Bar';
      }
    }
    let bar = new Bar();
    console.log(bar);                            // Bar {}
    console.log(bar.toString());              // [object Bar]
    console.log(bar[Symbol.toStringTag]);   // Bar

16．Symbol.unscopables​

根据ECMAScript规范，这个符号作为一个属性表示“一个对象，该对象所有的以及继承的属性，都会从关联对象的with环境绑定中排除”。设置这个符号并让其映射对应属性的键值为true，就可以阻止该属性出现在with环境绑定中，如下例所示：

    let o = { foo: 'bar' };
    with (o) {
      console.log(foo); // bar
    }
    o[Symbol.unscopables] = {
      foo: true
    };
    with (o) {
      console.log(foo); // ReferenceError
    }

注意不推荐使用with，因此也不推荐使用Symbol.unscopables。

Object类型​

ECMAScript中的对象其实就是一组数据和功能的集合。对象通过new操作符后跟对象类型的名称来创建。开发者可以通过创建Object类型的实例来创建自己的对象，然后再给对象添加属性和方法：

    let o = new Object();

这个语法类似Java，但ECMAScript只要求在给构造函数提供参数时使用括号。如果没有参数，如上面的例子所示，那么完全可以省略括号（不推荐）：

    let o = new Object;   // 合法，但不推荐

Object的实例本身并不是很有用，但理解与它相关的概念非常重要。类似Java中的java.lang. Object, ECMAScript中的Object也是派生其他对象的基类。 Object类型的所有属性和方法在派生的对象上同样存在。

每个Object实例都有如下属性和方法。

  • constructor：用于创建当前对象的函数。在前面的例子中，这个属性的值就是Object()函数。
  • hasOwnProperty（propertyName）：用于判断当前对象实例（不是原型）上是否存在给定的属性。要检查的属性名必须是字符串（如o.hasOwnProperty("name")）或符号。
  • isPrototypeOf（object）：用于判断当前对象是否为另一个对象的原型。（第8章将详细介绍原型。）
  • propertyIsEnumerable(propertyName)：用于判断给定的属性是否可以使用（本章稍后讨论的）for-in语句枚举。与hasOwnProperty()一样，属性名必须是字符串。
  • toLocaleString()：返回对象的字符串表示，该字符串反映对象所在的本地化执行环境。
  • toString()：返回对象的字符串表示。
  • valueOf()：返回对象对应的字符串、数值或布尔值表示。通常与toString()的返回值相同。

因为在ECMAScript中Object是所有对象的基类，所以任何对象都有这些属性和方法。