摘要：聲明的變量不得改變值，這意味著，一旦聲明變量，就必須立即初始化，不能留到以后賦值。解構(gòu)賦值允許按照一定模式，從數(shù)組和對象中提取值，對變量進行賦值，這被稱為解構(gòu)。對象的解構(gòu)賦值對象的屬性沒有次序，變量必須與屬性同名。

新增命令

1.let命令

ES6新增了let命令，用來聲明變量。它的用法類似于var，但是也存在新的特性。

 - **let所聲明的變量，只在let命令所在的代碼塊內(nèi)有效。適用于for循環(huán)**
 

            var a = 3;
            var a = 4;
            
            let b = 4;
            
            {
                var a = 5;
                let b = 5;    //作用域僅在代碼塊內(nèi)部
                let c = "this is inner c";
                var d = "this is inner d";
                console.log(b);    //b = 5
            }
          
            console.log(a);    //a = 5
            console.log(b);    //b = 4
            console.log(d);    //this is inner d
            console.log(c);    //c is not defined

for循環(huán)

    按理說，在執(zhí)行完for循環(huán)后，應(yīng)該釋放變量的值，否則可能會對全局變量造成影響，因此，聲明為let，會更好。

            //使用var 聲明
            var result  = 0;
            for(var i = 0;i<100;i++){
                result += i;
            };
            console.log(result);    //5050
            console.log(i);    //101

            //使用let 聲明
            var result  = 0;
            for(let i = 0;i<100;i++){
                result += i;
            };
            console.log(result);    //5050
            console.log(i);    // i is not defined

 - **不存在變量提升**

            //先操作
            console.log("var變量提升",a);    //undefined
            console.log("let沒有變量提升",b);    //報錯：b is not defined
            //再聲明
            var a = 3;
            let b = 4;
           

 - **暫時性死區(qū)**

            var tmp = 123; 
            if (true) {
                tmp = "abc"; // ReferenceError 
                let tmp; 
            } 

 - **不允許重復(fù)聲明**
    ```
        var a = 3;
        var a = 4;
        
        let b = 4;
        let b = 5;     //TypeError:Duplicate declaration "b"
        console.log(a);//a = 4
        console.log(b);
    ```
    

2.const命令

基本用法：const聲明一個只讀常量。一旦聲明，常量的值就不能改變。類似于Java中的final關(guān)鍵字。

      const PI = 3.1415; PI = 3; // TypeError: Assignment to constant variable

const聲明的變量不得改變值，這意味著，const一旦聲明變量，就必須立即初始化，不能留到以后賦值。

      const foo; // SyntaxError: Missing initializer in const declaration

其余特點與let一樣，具有不能重復(fù)聲明，具有塊級作用域，暫時性死區(qū)。

解構(gòu)賦值

ES6 允許按照一定模式，從數(shù)組和對象中提取值，對變量進行賦值，這被稱為解構(gòu)（Destructuring）。例如：

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

本質(zhì)上，這種寫法屬于“模式匹配”，只要等號兩邊的模式相同，左邊的變量就會被賦予對應(yīng)的值。如果解構(gòu)不成功，變量的值就等于undefined。另一種情況是不完全解構(gòu)，即等號左邊的模式，只匹配一部分的等號右邊的數(shù)組。這種情況下，解構(gòu)依然可以成功。

1.對象的解構(gòu)賦值

a>對象的屬性沒有次序，變量必須與屬性同名。

在ES5中

var obj ={
    name = "tom,
    age = 12,
};
var name = obj.name;
var age = obj.age;

在ES6中

let {name:name,age:age} = obj;
let{name,age} = obj;
console.log(name,age);

b>如果變量名與屬性名不一致，必須寫成下面這樣。

    var { foo: baz } = { foo: "aaa", bar: "bbb" };     //baz = "aaa”

c>嵌套解構(gòu)

let obj = { p: [ "Hello", { y: "World" } ] }; 
let { p: [x, { y }] } = obj;     //x = "Hello”; y = "World”

d>默認值（默認值生效的條件是，對象的屬性值嚴格等于undefined）

var {x: y = 3} = {}; y // 3

2.數(shù)組的解構(gòu)賦值

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

a>不完全解構(gòu)

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

b>集合解構(gòu)

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

c>默認值（當(dāng)匹配值嚴格等于undefined時，默認值生效）

let [x, y = "b"] = ["a"];     // x="a", y="b’

d>默認值也可以為函數(shù)

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



let [a,b,...c] = ["terry","lerry","tom","jack"];
console.log(a);    //terry;
console.log(b);    //lerry;
console.log(c);    //["tom","jack"]

3.字符串的解構(gòu)賦值
a>解構(gòu)時，字符串被轉(zhuǎn)換成了一個類似數(shù)組的對象。

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

b>也可以對數(shù)組的屬性解構(gòu)

let {length : len} = ‘hello’;     //len = 5

c> 數(shù)值和布爾值解構(gòu)賦值

解構(gòu)時，如果等號右邊是數(shù)值和布爾值，則會先轉(zhuǎn)為對象
let {toString: s} = 123;     //s === Number.prototype.toString true
let {toString: s} = true;     //s === Boolean.prototype.toString true

4.函數(shù)參數(shù)的解構(gòu)賦值
基本語法：

function add([x, y]){ return x + y; } 
add([1, 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]
    

解構(gòu)賦值的常見用途

1.交換變量的值

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

2.從函數(shù)返回多個值

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

3.函數(shù)參數(shù)的定義

function f([x, y, z]) { ... } 
f([1, 2, 3]);

4.提取JSON數(shù)據(jù)

let jsonData = { id: 42, status: "OK", data: [867, 5309] }; 
let { id, status, data: number } = jsonData;

5.輸入模塊的指定方法

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

6.函數(shù)參數(shù)的默認值

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

7..指定參數(shù)的默認值，就避免了在函數(shù)體內(nèi)部再寫var foo = config.foo || "default foo";這樣的語句
遍歷map結(jié)構(gòu)

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

--------------------------------------------------------------------本次結(jié)束-------------------------