ECMAScript6简介

一. ECMAScript6简介

1. ECMAScript和JavaScript的关系

   1. 1996年，JavaScript的创造者NetScape公司,将JavaScript提交给国际标准化组织ECMA,希望成为国际标准，次年ECMA组织发布了ECAMScript标准，也就是ECMAScript 1.0版本

   2. 为什么不使用原来的名字呢

   a. java是sun公司的商标，

   b. 想体现这门语言的制定者是ECMA，不是NetScape，这样有利于保证这门语言的开放性和中立性

2. ES6与ECMAScript2015的关系

   1. 2011年，ECMAScript 5.1版发布后,此标准成为ISO国际标准,

   2. 2015年6月，ECMA 6发布正式版本

   3. 标准在每年的6月份正式发布一次，作为当年的正式版本,这样,就不需要以前的版本号了，只要用年份标记就可以了，所以ECMA 6的正式名字是ECMAScript 2015

二. let和const命令

1. let命令

   1. a用来声明变量。它的用法类似于var，但是所声明的变量，只在let命令所在的代码块内有效

   2. for循环的计数器，就很合适使用let命令

   3. 思考下面两句代码的输出

      var a = [];
              for (var i = 0; i < 10; i++) {
      
                 a[i] = function () {
                    console.log(i);
                 };
              }
      
              a[6](); 
      
              var a = [];
              for (let i = 0; i < 10; i++) {
      
                 a[i] = function () {
                    console.log(i);
                 };
              }
      
              a[6](); 
      

   4. var命令会发生”声明提前“现象，let命令改变了语法行为，它所声明的变量一定要在声明后使用，否则报错

   5. 暂时性死区

      a. 只要块级作用域内存在let命令，它所声明的变量就“绑定”（binding）这个区域，形成了封闭作用域,不再受外部的影响。

      b. 在代码块内，使用let命令声明变量之前，该变量都是不可用的。这在语法上，称为“暂时性死区”

   6. let不允许在相同作用域内，重复声明同一个变量。

2. 块级作用域

   1. ES6的块级作用域

      任何一对花括号（｛和｝）中的语句集都属于一个块，在这之中定义的所有变量在代码块外都是不可见的，我们称之为块级作用域。

   2. ES5只有全局作用域和函数作用域(属于块级作用域)，没有块级作用域，这带来很多不合理的场景

    a) 用来计数的循环变量泄漏为全局变量
   
         var s = 'hello';
   
                 for (var i = 0; i < s.length; i++) {
                   console.log(s[i]);
                 }
   
                 console.log(i); // 5
   
    b) 内层变量可能会覆盖外层变量
   
         var tmp = new Date();
   
                 function f() {
                   console.log(tmp);
                   if (false) {
                     var tmp = "hello world";
                   }
                 }
   
                 f(); // undefined
   

3. const命令

   1. 声明一个只读的常量，一旦声明，常量的值就不能改变,所以const一旦声明变量，就必须立即初始化，不能留到以后赋值

   2. const的作用域与let命令相同，只在声明所在的块级作用域内有效

   3. const命令声明的变量也是不提升，同样存暂时性死区，只能在声明的位置后面使用

   4. 不可重复声明

   5. 本质
      const实际上保证的，并不是变量的值不得改动，而是变量指向的那个内存地址不得改动。对于简单类型的数据（数值、字符串、布尔值），值就保存在变量指向的那个内存地址，因此等同于常量。但对于复合类型的数据（主要是对象和数组），变量指向的内存地址，保存的只是一个指针，const只能保证这个指针是固定的，至于它指向的数据结构是不是可变的，就完全不能控制了

    部分修改常量是不允许的，全部修改常量是允许的
   
     const foo = {};
   
         // 为 foo 添加一个属性，可以成功
         foo.prop = 123;
         foo.prop // 123
   
         // 将 foo 指向另一个对象，就会报错
         foo = {}; 
   

4. 顶层对象的属性

   1. 顶层对象的属性与全局变量挂钩，被认为是JavaScript语言最大的设计败笔之一,

   a. 特别容易创建全局变量，
   b. 对象的属性是到处可以读写的，另外window指的是浏览器的窗口对象，这非常不利于模块化编程

   2. ES6为了保持兼容性，规定var命令和function命令声明的全局变量，依旧是顶层对象的属性；同时规定，let命令、const命令、class命令声明的全局变量，不属于顶层对象的属性。也就是说，从ES6开始，全局变量将逐步与顶层对象的属性脱钩

三. 数组的解构赋值

1. ES6 允许按照一定模式，从数组和对象中提取值，对变量进行赋值，这被称为解构（Destructuring），比如

   let [a, b, c] = [1, 2, 3];
   

2. 本质上，这种写法属于“模式匹配”，只要等号两边的模式相同，左边的变量就会被赋予对应的值。下面是一些使用嵌套数组进行解构的例子，如果结构不成，变量的值就为undefined。

   let [foo, [[bar], baz]] = [1, [[2], 3]];
   

   foo // 1
   bar // 2
   baz // 3

   let [ , , third] = ["foo", "bar", "baz"];
   third // "baz"

   let [x, , y] = [1, 2, 3];
   x // 1
   y // 3

   let [head, ...tail] = [1, 2, 3, 4];
   head // 1
   tail // [2, 3, 4]

   let [x, y, ...z] = ['a'];
   x // "a"
   y // undefined
   z // []

3. 不完全解构，即等号左边的模式，只匹配一部分的等号右边的数组。这种情况下，解构依然可以成功。

   let [x, y] = [1, 2, 3];
   x // 1
   y // 2
   
   let [a, [b], d] = [1, [2, 3], 4];
   a // 1
   b // 2
   d // 4
   

4. 结构赋值允许指定默认值
   let [foo = true] = [];
   foo // true

   let [x, y = 'b'] = ['a']; // x='a', y='b'
   let [x, y = 'b'] = ['a', undefined]; // x='a', y='b'
   

5. 默认值是一个表达式，那么这个表达式是惰性求值的，即只有值为undefind时才会执行表达式

   function f() {
     console.log('aaa');
   }
   
   let [x = f()] = [1];
   

四. 对象的解构赋值

1. 对象的解构与数组有一个重要的不同。数组的元素是按次序排列的，变量的取值由它的位置决定；而对象的属性没有次序，变量必须与属性同名，才能取到正确的值。

    let { foo, bar } = { foo: "aaa", bar: "bbb" };
   
    foo // "aaa"
    bar // "bbb"
   

2. 对象的解构其实是下面形式的简写

    let { foo: foo, bar: bar } = { foo: "aaa", bar: "bbb" };
   

   ，采用这种写法时，变量的声明和赋值是一体的。对于let和const来说，变量不能重新声明，所以一旦赋值的变量以前声明过，就会报错

   let foo;
   let {foo} = {foo: 1};

3. 对象的解构也可以指定默认值,默认值生效的条件是，对象的属性值严格等于undefined

    var {x = 3} = {};
   
    var {x, y = 5} = {x: 1};
   

五. 字符串的解构赋值

1. 本质是字符串被转换成了一个类似数组的对象

   const [a, b, c, d, e] = 'hello';
    a // "h"
    b // "e"
    c // "l"
    d // "l"
    e // "o"
   

2. 似数组的对象都有一个length属性，因此还可以对这个属性解构赋值

    let {length : len} = 'hello';
    len // 5
   

六. 数值和布尔值的解构赋值

1. 解构赋值时，如果等号右边是数值和布尔值，则会先转为对象。

   let {toString: s} = 123;
   s === Number.prototype.toString // true
   
   let {toString: s} = true;
   s === Boolean.prototype.toString // true
   

2. 解构赋值的规则是，只要等号右边的值不是对象或数组，就先将其转为对象。由于undefined和null无法转为对象，所以对它们进行解构赋值，都会报错

   let { prop: x } = undefined; // TypeError
   let { prop: y } = null; // TypeError
   

七. 函数参数的解构赋值

1. 函数的参数也可以使用解构赋值

   function add([x, y]){
     return x + y;
   }
   
   add([1, 2]); 
   

   函数add的参数表面上是一个数组，但在传入参数的那一刻，数组参数就被解构成变量x和y。对于函数内部的代码来说，它们能感受到的参数就是x和y

2. 函数参数的解构也可以使用默认值

    function move({x = 0, y = 0} = {}) {
      return [x, y];
    }
   
    move({x: 3, y: 8}); // [3, 8]
    move({x: 3}); // [3, 0]
    move({}); // [0, 0]
    move(); // [0, 0]
   

   函数move的参数是一个对象，通过对这个对象进行解构，得到变量x和y的值。如果解构失败，x和y等于默认值。

八. 解构赋值-用途

1. 交换变量的值

   let x = 1;
   let y = 2;
   
   [x, y] = [y, x];
   

 面代码交换变量x和y的值，这样的写法不仅简洁，而且易读，语义非常清晰

2. 从函数返回多个值

   function example() {
    return [1, 2, 3];
   }
   let [a, b, c] = example();
   

   // 返回一个对象

   function example() {
        return {
          foo: 1,
          bar: 2
        };
      }
      let { foo, bar } = example();
   

 函数只能返回一个值，如果要返回多个值，只能将它们放在数组或对象里返回。有了解构赋值，取出这些值就非常方便。

3. 提取JSON数据

   解构赋值对提取JSON对象中的数据，尤其有用。

         let jsonData = {
           id: 42,
           status: "OK",
           data: [867, 5309]
         };
   
         let { id, status, data: number } = jsonData;
   
         console.log(id, status, number);
   

4. 函数参数的默认值

       jQuery.ajax = function (url, {
           async = true,
           beforeSend = function () {},
           cache = true,
          complete = function () {},
           crossDomain = false,
           global = true,
           // ... more config
      }) {
           // ... do stuff
      };
   

 指定参数的默认值，就避免了在函数体内部再写var foo = config.foo || 'default foo';

5. 遍历Map结构

         var map = new Map();
         map.set('first', 'hello');
         map.set('second', 'world');
   
         for (let [key, value] of map) {
           console.log(key + " is " + value);
         }
         // first is hello
         // second is world
   

   如果只想获取键名，或者只想获取键值

         // 获取键名
         for (let [key] of map) {
           // ...
         }
   
         // 获取键值
         for (let [,value] of map) {
           // ...
         }
   

6. 输入模块的指定方法

   加载模块时，往往需要指定输入哪些方法。解构赋值使得输入语句非常清晰

       const { SourceMapConsumer, SourceNode } = require("source-map");