1、Es6常用语法

一、变量let和常量const定义

1、变量定义let

var 定义的变量：只有全局作用域和函数作用域

let 定义的变量：有全局作用域和函数作用域，块级作用域

let作用域只限于当前代码

{
  let a =12;  
}
console.log(a);    #报错,a不存在

let声明的变量作用域不会被提升

    console.log(a);    #报错
    let = 12;      

在相同的作用域下不能声明相同的变量

{
   let a = 10;
   let a = 11;  //报错    
 }

for循环体现let的父子作用域

//使用var声明，需要用到“闭包”
    var btns = document.querySelectorAll("button");
      for(var i=0;i<btns.length;i++){
      （function(i){
           btns[i].onclick= function (){
            alert("点击了"+i+"个按钮")
          }
      })(i);
    }
    
    //let声明
     let btns = document.querySelectorAll("button");
      for(let i=0;i<btns.length;i++){
          btns[i].onclick= function (){
            alert("点击了"+i+"个按钮")
          }
      }

2、常量定义const

(1)、const作用域只限于当前代码块
(2)、const声明的变量作用域不会被提升
(3)、在相同的作用域下不能重复声明
(4)、声明的同时必须赋值，声明后值无法改变

{   
    const b; //报错
    
    const a = 123;
    a = 222; //报错
    
} 

针对对象就不一样了

{
    const obj = {
        name:"lisi"
     }
    console.log(obj.name); //lisi
    
    obj.name = "zhaoliu";
    console.log(obj.name);//zhaoliu
}
//在上面中定义的是一个常量对象，对象是储存在内存的“堆区”，通过一个地址描述出来，在“栈区”关联此地址。所以，obj存储的是地址，而不是值，是可以做修改的。

二、字符串模板引擎（字符串拼接） 

Es6的这种新的“字符串拼接”方法比较简单，没有繁琐的加号和引号，只需要在所需要的字符串“边界”加上``即可。（键盘 tab上面那个键 ${变量} 键盘 tab上面那个键）

var name = 'Datura';
    var age = 18;
    var sex = '其它';
    var hobby = '敲代码';
    var str1 = `我是${name}，今年${age}岁，性别${sex}的了，爱好${hobby}`; //注意此处有两个“ `` ”
    var str2 = '我是'+name+'，今年'+a

let {time=1000,id=0} = {};
console.log(time,id);   //  1000   0

ge+'岁，性别'+sex+'，爱好'+hobby+''; //这个是原来的写法
    alert(st1r);

 三、解构赋值

就根据“对应”赋值，请看以下几个例子：

 'use strict';
let a = 12;
 let b = 5;
 let c = 8;
//相当于
let [a,b,c] = [12,5,8];
console.log(a,b,c);  //12 5 8

json格式的赋值

let {a,b,c} = {a:12,b:5,c:8};
console.log(a,b,c);   //12  5  8
//数组里面嵌套数组
let [a,[b,c],d] = [12,[1,3],8];
console.log(a,b,c,d);   // 12  1  3  8

与顺序无关，与结构有关（左右结构一致）：

let {a,b,c} = {b:5,a:12,c:8};
console.log(a,b,c);   //12  5  8

应用，我们现在利用jsonp获取了一组数据

let json = {
        q:"aaa",
        p:false,
        s:["aaa云主机","爱奇艺vip免费试用","啊aaaaaaaa视频","aaaa","爱奇艺","aaa电池","工商银行","aaai","aaa短信轰炸机"]
    };
    
    let {s,q} = json;
    console.log(s,q);  //s为那组数组的数据，q为字符串aaa

解构赋值的默认值问题

let {time=1000,id=0} = {};
console.log(time,id);   //  1000   0

四、扩展运算符：三个点

我之前的文章曾提到过数组或者对象的深浅拷贝问题，今天我们就利用es6的三个点来处理下。

    var arr = [12,5,8];
    arr2 =arr;
    arr2.pop();
    alert(arr);  // 12 5

上面的代码就是arr2与arr公用一段内存地址，所以导致srr2数据改变的时候arr也必然会变的。这就是浅拷贝。那么我们下面就简单的说几种深度复制数组方式。
方式一：利用for循环把原数组的每一项都遍历，然后扔到新的数组中。

    var arr = [12,5,8];
    var arr2 =[];
    for(var i = 0;i<arr.length;i++){
        arr2.push(arr[i]);  
    }
    arr2.pop();
    alert(arr);   //  12  5  8

方式二：利用Array.from(原数组);

 var arr = [12,5,8];
    var arr2 = Array.from(arr);
    arr2.pop();
    console.log(arr2);  // 12  5 
    alert(arr);   // 12  5  8

方式三：三个点

 var arr = [12,5,8];
    var arr2 = [...arr]
    arr2.pop();
    console.log(arr2);//12 5
    alert(arr);  //12 5 8

说了这么多，我们现在就说下“三个点”的应用把，我们知道函数的参数是一个集合(arguments)并不是一个真正的数组。那么我们怎么才能在这个arguments中加一项呢？？

function show(){
        //因为类数组对象，并不具备数组的那些方法。所以此会报错
        arguments.push(8);
        console.log(arguments);
    }


    show(12,5);
      function show(...arr){
        arr.push(8);
        console.log(arr);
    }
    show(12,5);  //12 5 8

当然还有很多的对象深拷贝方式请参照（http://www.jianshu.com/p/4e613af9509c），这里就不一一论述了。

扩展：

将一个数组转化为用逗号分隔的参数数列

console.log(...[1, 2, 3])
// 1 2 3
console.log(1, ...[2, 3, 4], 5)
// 1 2 3 4 5

主要用于函数调用

array.push(...items)和add(...numbers)这两行，都是函数的调用，它们的都使用了扩展运算符。该运算符将一个数组，变为参数序列

function push(array, ...items) {
array.push(...items);
}


function add(x, y) {
return x + y;
}
var numbers = [4, 38];
add(...numbers) // 42

将数组转化为参数列表

// ES5 的写法
Math.max.apply(null, [14, 3, 77])
// ES6 的写法
Math.max(...[14, 3, 77])
//  等同于
Math.max(14, 3, 77);

合并数组

// ES5
[1, 2].concat(more)
// ES6
[1, 2, ...more]
var arr1 = ['a', 'b'];
var arr2 = ['c'];
var arr3 = ['d', 'e'];
// ES5 的合并数组
arr1.concat(arr2, arr3);
// [ 'a', 'b', 'c', 'd', 'e' ]
// ES6 的合并数组
[...arr1, ...arr2, ...arr3]
// [ 'a', 'b', 'c', 'd', 'e' ]

 与解构赋值结合使用：

扩展运算符可以与解构赋值结合起来，用于生成数组

// ES5
a = list[0], rest = list.slice(1)
// ES6
[a, ...rest] = list
下面是另外一些例子。
const [first, ...rest] = [1, 2, 3, 4, 5];
first // 1
rest // [2, 3, 4, 5]
const [first, ...rest] = [];
first // undefined
rest // []:
const [first, ...rest] = ["foo"];
first // "foo"
rest // []

如果将扩展运算符用于数组赋值，只能放在参数的最后一位，否则会报错

const [...butLast, last] = [1, 2, 3, 4, 5];
//  报错
const [first, ...middle, last] = [1, 2, 3, 4, 5];
//  报错

函数的返回值

JavaScript 的函数只能返回一个值，如果需要返回多个值，只能返回数组或对象。扩展运算符提供了解决这个问题的一种变通方法

var dateFields = readDateFields(database);
var d = new Date(...dateFields);

 字符串：

扩展运算符还可以将字符串转为真正的数组。

[...'hello']
// [ "h", "e", "l", "l", "o" ]

上面的写法，有一个重要的好处，那就是能够正确识别 32 位的 Unicode 字符

'xuD83DuDE80y'.length // 4

[...'xuD83DuDE80y'].length // 3

上面代码的第一种写法， JavaScript 会将 32 位 Unicode 字符，识别为 2 个字符，采用扩展运算符就没有这个问题。因此，正确返回字符串长度的函数，可以像下面这样写。

function length(str) {
 
return [...str].length;
 
}
 
length('xuD83DuDE80y') // 3

凡是涉及到操作 32 位 Unicode 字符的函数，都有这个问题。因此，最好都用扩展运算符改写。

let str = 'xuD83DuDE80y';
 
str.split('').reverse().join('')
 
// 'yuDE80uD83Dx'
 
[...str].reverse().join('')
 
// 'yuD83DuDE80x'

上面代码中，如果不用扩展运算符，字符串的reverse操作就不正确。

（ 5 ）实现了 Iterator 接口的对象

任何 Iterator 接口的对象，都可以用扩展运算符转为真正的数组。

var nodeList = document.querySelectorAll('div');
 
var array = [...nodeList];

上面代码中，querySelectorAll方法返回的是一个nodeList对象。它不是数组，而是一个类似数组的对象。这时，扩展运算符可以将其转为真正的数组，原因就在于NodeList对象实现了 Iterator 接口。

对于那些没有部署 Iterator 接口的类似数组的对象，扩展运算符就无法将其转为真正的数组。

let arrayLike = {
 
'0': 'a',
 
'1': 'b',
 
'2': 'c',
 
length: 3
 
};
 
// TypeError: Cannot spread non-iterable object.
 
let arr = [...arrayLike];

上面代码中，arrayLike是一个类似数组的对象，但是没有部署 Iterator 接口，扩展运算符就会报错。这时，可以改为使用Array.from方法将arrayLike转为真正的数组。

（ 6 ） Map 和 Set 结构， Generator 函数

扩展运算符内部调用的是数据结构的 Iterator 接口，因此只要具有 Iterator 接口的对象，都可以使用扩展运算符，比如 Map 结构。

let map = new Map([
 
[1, 'one'],
 
[2, 'two'],
 
[3, 'three'],
 
]);
 
let arr = [...map.keys()]; // [1, 2, 3]

Generator 函数运行后，返回一个遍历器对象，因此也可以使用扩展运算符。

var go = function*(){
 
yield 1;
 
yield 2;
 
yield 3;
 
};
 
[...go()] // [1, 2, 3]

上面代码中，变量go是一个 Generator 函数，执行后返回的是一个遍历器对象，对这个遍历器对象执行扩展运算符，就会将内部遍历得到的值，转为一个数组。
如果对没有iterator接口的对象，使用扩展运算符，将会报错。

var obj = {a: 1, b: 2};
 
let arr = [...obj]; // TypeError: Cannot spread non-iterable object