摘要：圓括號問題可以使用圓括號的情況只有一種賦值語句的非模式部分，可以使用圓括號。正確正確正確上面三行語句都可以正確執行，因為首先它們都是賦值語句，而不是聲明語句其次它們的圓括號都不屬于模式的一部分。

let 和 const 命令

概念：

暫時性死區（TDZ）

在作用域內，let變量已經存在；
并綁定該作用域：不受外界影響，外界也不可獲取
let作用域以代碼塊劃分，var作用域則只有全局和函數

在let聲明之前，不可獲取；（也就是TDZ）

在let聲明之后，才可獲取。

let變量不可重復聲明

let不允許在相同作用域內，重復聲明同一個變量。

tip:

TDZ也解釋了為什么let不存在變量提升。

ES6 規定暫時性死區和let、const語句不出現變量提升，主要是為了減少運行時錯誤，防止在變量聲明前就使用這個變量，從而導致意料之外的行為。這樣的錯誤在 ES5 是很常見的，現在有了這種規定，避免此類錯誤就很容易了。

ES5 只有全局作用域和函數作用域，沒有塊級作用域，這帶來很多不合理的場景，如：

內層變量可能會覆蓋外層變量。

用來計數的循環變量泄露為全局變量。

ES6 的塊級作用域（let實際上為 JavaScript 新增了塊級作用域），作用：

外層作用域無法讀取內層作用域的變量。

內層作用域可以定義外層作用域的同名變量。

使得獲得廣泛應用的立即執行函數表達式（IIFE）不再必要了。

根據ES6 在附錄 B里的規定，在瀏覽器的 ES6 環境中，塊級作用域內聲明的函數，行為類似于var聲明的變量。

const實際上保證的，并不是變量的值不得改動，而是變量指向的那個內存地址不得改動。

凍結對象：

const foo = Object.freeze({});

徹底凍結對象的函數：

var constantize = (obj) => {
       Object.freeze(obj);
    Object.keys(obj).forEach((key, i) => 
        if ( typeof obj[key] === "object" ) {
            constantize( obj[key] );
        }
    });
};

ES6 聲明變量的六種方法
ES5 只有兩種聲明變量的方法：var命令和function命令。ES6 除了添加let和const命令，后面章節還會提到，另外兩種聲明變量的方法：import命令和class命令。所以，ES6 一共有 6 種聲明變量的方法。

從 ES6 開始，全局變量將逐步與頂層對象的屬性脫鉤。

var a = 1;
// 如果在 Node 的 REPL 環境，可以寫成 global.a
// 或者采用通用方法，寫成 this.a
window.a // 1

let b = 1;
window.b // 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 // []

默認值

let [foo = true] = [];
foo // true

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

注意，ES6 內部使用嚴格相等運算符（===），判斷一個位置是否有值。所以，只有當一個數組成員嚴格等于undefined，默認值才會生效。

let [x = 1] = [undefined];
x // 1

let [x = 1] = [null];
x // null

默認值可以引用解構賦值的其他變量，但該變量必須已經聲明。

let [x = 1, y = x] = [];     // x=1; y=1
let [x = 1, y = x] = [2];    // x=2; y=2
let [x = 1, y = x] = [1, 2]; // x=1; y=2
let [x = y, y = 1] = [];     // ReferenceError: y is not defined

上面最后一個表達式之所以會報錯，是因為x用y做默認值時，y還沒有聲明。

命名與鍵名相同則簡寫：

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

命名與鍵名不同：

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

嵌套：

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

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

let obj = {};
let arr = [];

({ foo: obj.prop, bar: arr[0] } = { foo: 123, bar: true });

obj // {prop:123}
arr // [true]

默認值：

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

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

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

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

var { message: msg = "Something went wrong" } = {};
msg // "Something went wrong"

如果要將一個已經聲明的變量用于解構賦值，必須非常小心:

// 錯誤的寫法
let x;
{x} = {x: 1};
// SyntaxError: syntax error

上面代碼的寫法會報錯，因為 JavaScript 引擎會將{x}理解成一個代碼塊，從而發生語法錯誤。只有不將大括號寫在行首，避免 JavaScript 將其解釋為代碼塊，才能解決這個問題。

// 正確的寫法
let x;
({x} = {x: 1});

由于數組本質是特殊的對象，因此可以對數組進行對象屬性的解構。

let arr = [1, 2, 3];
let {0 : first, [arr.length - 1] : last} = arr;
first // 1
last // 3

字符串也可以解構賦值。這是因為此時，字符串被轉換成了一個類似數組的對象。

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

類似數組的對象都有一個length屬性，因此還可以對這個屬性解構賦值。

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

解構賦值時，如果等號右邊是數值和布爾值，則會先轉為對象。

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

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

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等于默認值。

注意，下面的寫法會得到不一樣的結果。
上面代碼是為函數move的參數指定默認值，而不是為變量x和y指定默認值，所以會得到與前一種寫法不同的結果。

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

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

可以使用圓括號的情況只有一種：賦值語句的非模式部分，可以使用圓括號。

[(b)] = [3]; // 正確
({ p: (d) } = {}); // 正確
[(parseInt.prop)] = [3]; // 正確

上面三行語句都可以正確執行，因為首先它們都是賦值語句，而不是聲明語句；其次它們的圓括號都不屬于模式的一部分。
第一行語句中，模式是取數組的第一個成員，跟圓括號無關；
第二行語句中，模式是p，而不是d；
第三行語句與第一行語句的性質一致。

（1）交換變量的值
（2）從函數返回多個值
（3）函數參數的定義
（4）提取 JSON 數據
（5）函數參數的默認值
（6）遍歷 Map 結構
（7）輸入模塊的指定方法

數組的拓展

用法簡單，寫ES6的時候留意下是否可以用之與簡化代碼即可，
注意點：
解構賦值的時候必須放在末尾，否則報錯（Rest element must be last element）。