變量聲明 和 數(shù)組對象解構(gòu)賦值,本編主要學(xué)習(xí) let const 使用語法，注意事項。以及數(shù)組和對象的解構(gòu)賦值。

let 聲明

作用：let作用主要是定義一個局部變量.

使用語法：
let hello = "hello word";

使用注意事項：

1. let 聲明的變量只在聲名的塊級內(nèi)有作用
2. let 變量必須先聲明后使用，否則會報錯
3. let 變量不能在一個作用域里多次聲明
4. let 在函數(shù)內(nèi)聲明時，盡量不與參數(shù)同名。

錯誤示例：

    //1.let是塊級作用域
    function f(input) {
        let a = 100;
        if (input) {
            let b = a + 1;  //運行正確
            return b;
        }
        return b;  //錯誤 , b沒有被定義
    }

    //2.let 變量必須先聲明后使用
    a++;
    let a;

    //3.不能在同一作用域重復(fù)定義
    let y = 2;
    let y = 3;  

    var x = 1;
    let x = 2; 

    //4.與參數(shù)重復(fù)的情況

    //錯誤：
    function funA(x) {
        let x = 100;  //報錯，x已經(jīng)在函數(shù)參數(shù)聲明了
    }

    //正確：
    function funB(codition,x) {
        if (codition) {
            let x = 100; //運行正確，x在一新的作用域中
            return x;
        }
        return x;
    }

const 聲明

作用：const作用主要是定義一個常量

使用語法：
const PI = 3.1415;

使用語法:
1.對常量直接賦值將會出錯
2.常量如果是對象，對象屬性是可以重新賦值的;
3.常量的作用域與let 相同; 只在聲明的塊級有用
4.常量不可重復(fù)定義

錯誤示例：

    //1.常量不可修改
    const PI = 3.1415;
    PI = 3;  //報錯，常量不可修改
    
    //2.對象常量不可直接修改，對象屬性可以更改
    const kitty = {
        name: "Aurora",
        numLives:9
    };

    //錯誤
    kitty = {
        name: "Danielle",
        numLives:9
    };

    //正確
    kitty.name = "Kitty";
    kitty.numLives--; 

    //3.常量作用域
    if (codition) {
        const  MAX = 5;
    }
    console.log(MAX) // MAX 在此處不可見

    //4.不能重復(fù)聲明
    var message = "Hello";
    let age = 25;

    //以下兩行都是錯誤
    const message = "Goodbye";
    const age = 26;

解構(gòu)賦值

作用：解構(gòu)賦值可將一個復(fù)雜類型的數(shù)據(jù)，如數(shù)組和對象，分解匹配賦值給多個獨立的變量。

使用語法：

• 數(shù)組解構(gòu)
  let [a,b,c] = [1,2,3];
• 對象解構(gòu)
  let {foo, bar} = {foo: "aaa",bar:"bbb"};

使用注意事項：
1.數(shù)組解構(gòu)按順序，對象解構(gòu)則無關(guān)順序據(jù)屬性名取值。
2.對于不成功的的解構(gòu)，最值會賦值undefined
3.對undefined 和 null 進行解構(gòu)會報錯
4.解構(gòu)賦值允許指定默認值
5.解構(gòu)賦值對于var let const 都是適用的

數(shù)組解構(gòu)使用示例：

    //解構(gòu)數(shù)組
    var [first,second] = [1,2];
    first; //1
    second; //2

    //解構(gòu)多維數(shù)組
    var [foo,[[bar],baz]] = [1,[[2],3]];
    foo;  //1
    bar;  //2
    baz;  //3

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

    //解構(gòu)...數(shù)組
    var [head,...tail] = [1,2,3,4];
    head; //1;
    tail  //[2,3,4];

    //解構(gòu)失敗賦值undefined
    var [foo] = [];
    var [foo] = 1;
    var [foo] = 'Hello';
    var [foo] = false;
    var [foo] = NaN;

    //以下兩行解構(gòu)會報錯
    const [foo] = undefined;
    const [foo] = null;

    //指定解構(gòu)的默認值
    var [foo = true] = [];
    foo; //true

對象解構(gòu)示例：

    //解構(gòu)對象
    let test = { x: 0, y: 10, width: 15, height: 20 };
    let { x, y, width, height } = test;
    console.log(x, y, width, height);  //輸出0,10,15,20

    //解構(gòu)對象按屬性名取值,無關(guān)順序
    let { foo, bar } = { foo: 'aaa', bar: 'bbb'};
    foo //'aaa';
    bar //'bbb';

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

    //屬性名不對,賦值為undefined
    let { baz , foo} = { foo: 'aaa', bar: 'bbb'};
    baz; //undefined  //解構(gòu)不成功
    foo; //'aaa'

    //重命名解構(gòu)屬性,重命名后原名稱不可取值。
    let { foo: baz } = { foo: 'aaa', bar: 'bbb'};
    baz; //'aaa';
    foo; // 出錯

    //解構(gòu)多維對象
    var o = {
        p: [
            "Hello",
            { y: "word" }
        ]
    };

    var { p: [x, { y }] } = o;
    x  //"Hello";
    y  //"word";

    //指定默認值
    var { x = 3 } = {};
    x //3

解構(gòu)賦值的具體使用點：

1. 交換變量值
2. 從函數(shù)返回多個值
3. 更方便的接收json類型參數(shù)對象
4. 更方便設(shè)置默認參數(shù)
5. 更方例的遍歷對象
6. 模塊加載更清晰

本文為我個人學(xué)習(xí)ECMA6的筆記，內(nèi)容及案例多為書本抄寫，未做代碼正確性測試，內(nèi)容僅供參考，不保證文中觀點的及代碼的正確性。