ES6 之 let / const

本博文配合 阮一峰 《ES6 標準入門（第3版）》一書進行簡要概述 ES6 中的 let 與 const。

歷史遺留問題

由於 JS ES3語法中的 var 提升變量、沒有塊級作用域，因而搞出來了一大波的 "副產品"，匿名立即執行函數、閉包，都是 ES3 JS 遺留下來的產物。
所以學過 C 和 Python 再來看 JS ，會感覺很奇怪。
因為 ES6 之前，沒有塊級作用域，只有通過立即執行函數+閉包的方式造一個局部函數作用域。

let

let的出現解決了 JS 曾經沒有塊級作用域的問題，即終於在 JS 中出現了正常思維邏輯的語法糖... 即 {} 劃分作用域，要想使用變量，必須let

{
  let a = 1
  console.log(a)
}
如果在 {}外使用變量，就會報錯，因為let在{}中聲明的是局部變量，僅供這個塊級作用域使用。

{
  let a = 1
}
console.log(a)  //報錯

const

用法和let幾乎一致，唯一不同的是const只要一次賦值的機會。

{
  let a = 1
  console.log(a)  //1
  a = 2
  console.log(a)  //2
}

{
  const a = 1
  console.log(a)  //1
  a = 2
  console.log(a)  //報錯
}

2. 模板字符串
//es5
$(‘#mark‘).append(
    ‘出售中 <span>‘ + obj.num + ‘</span> ‘ +
    ‘剩下的, ‘ + ‘<span>‘ + obj.showNum + ‘</span> 賣完了!‘);
//es6
//在es6中，內容模板，可以定義在 `` 包起來的字符串中，其中的內容會保持原有格式
//另外可以在字符串中直接使用模板語言進行變量填充，優雅而簡潔
$(‘#mark‘).append(`
  出售 <span>${obj.num}</span> 剩下 <span>${obj.showNum}</span>`);

3. 字符串遍歷輸出, 補全
for (let item of ‘str‘) {
    console.log(item);
}
//s
//t
//r

4. 數組擴展
let a = [1, 2];
let b = [2， 3];
let c = [...a, ...b]; //[1, 2, 2, 3] 所有內容合並，但並不會去除重復

.keys() - 獲得數組中所有元素的鍵名（ 實際上就是下標索引號）
    .values() - 獲得數組中所有元素的數據
    .entries() - 獲得數組中所有數據的鍵名和數據
for (let i of[‘x‘, ‘y‘].keys()) {
    console.log(i); //0 1
}

for (let elem of[‘x‘, ‘y‘].values()) {
    console.log(elem); //x y
}

for (let [index, elem] of[‘x‘, ‘y‘].entries()) {
    console.log(index, elem); // 0 "x"    1 "y"
}

5. 對象擴展
//直接使用變量/常量的名稱個為對象屬性的名稱
let a = ‘abc‘;
let b = { a }; //{a: ‘abc‘}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
判斷對象是否為數組
if (Object.isArray(obj)) {}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
對象內容合並
Object.keys() - 獲得對象中所有的鍵名， 以數組的形式返回
var obj = { a: 1, b: 2 };
var names = Object.keys(obj); //[‘a‘, ‘b‘]
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
Object.values() - 獲得對象中所有的值內容， 以數組的形式返回
var obj = { a: 1, b: 2 };
var values = Object.values(obj); //[1, 2]
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
Object.entries() - 獲得對象中所有的成員數據， 以數組的形式返回， 成員的內容也是數組形式
var obj = { a: 1, b: 2 };
var values = Object.entries(obj); //[[‘a‘,1], [‘b‘,2]]
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
解構賦值
let [a, …b] = [1, 2, 3];
//這裏 b 的值為[2，3]，這樣可以快速使用剩余的數據賦值給變量，
let [a, b, c] = [1, 2, 3];
//定義了三個變量，並對應賦了值；如果值的個數與變量名個數不匹配，沒有對應上的變量值為 undefinedlet obj = {a: 1, b: 2};
let { a, b } = obj; //a=1,b=2
使用變量的方式進行結構賦值， 需要嚴格匹配名稱， 數組的模式是嚴格匹配下標
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
6. 模塊化
//app.js
let act = { a: 1, b: 2, c: 3 };
export default act;

//index.js
import act from ‘app.js‘; //假設 app.js 與index.js 同在一個目錄中
console.log(act.a); //1

//--------------------------------------------------------------------分割
//ES6字符串擴展方法,三個方法都支持第二個參數，表示開始搜索的位置;
let str = ‘Hello world!‘;
console.log(str.includes(‘o‘)) // true ----表示是否找到了參數字符串;類似ES5 indexOf()
console.log(str.startsWith(‘Hello‘)) // true ----表示參數字符串是否在原字符串的頭部;
console.log(str.endsWith(‘!‘)) // true ----表示參數字符串是否在原字符串的尾部;
    //ES6字符串擴展方法----模板字符串
let hello = ‘你好‘;
let str1 = `${hello}，這節課學習字符串模板`;
console.log(str1); //你好，這節課學習字符串模板,省去拼接的煩惱；
alert `123`
    // 等同於
alert(123)
    //ES6解構賦值
let res = {
    id: 1,
    status: "OK",
    list: [{
        name: ‘bob‘,
        age: 20
    }]
}
let {
    id,
    status,
    list
} = res;
console.log(id, status, list);
// 1, "OK", [{name: ‘bob‘,age: 20}]
//const 聲明常量 === var a = 1, b = 2, c = 3;or const a = 1;const b = 2;const c = 3;
const [a, b, c] = [1, 2, 3];
console.log(a, ‘aaaaa‘); //1 "aaaaa"
console.log(b, ‘bbbbb‘); //2 "bbbbb"
console.log(c, ‘ccccc‘); //3 "ccccc"
//使用擴展運算符（...）拷貝數組
let test = [1, 2, 3, 4, 5]
let [...test1] = test
test[2] = 5
console.log(test, ‘原數組‘) //[1, 2, 5, 4, 5] "原數組"
console.log(test1, ‘深拷貝的數組‘) //[1, 2, 3, 4, 5] "深拷貝的數組"
    //不要在模塊輸入中使用通配符。因為這樣可以確保你的模塊之中，有一個默認輸出（export default）。
    // bad
    //import * as myObject from ‘./importModule‘;
    // good
    //import myObject from ‘./importModule‘;
    //reset參數---rest參數搭配的變量是一個數組，該變量將多余的參數放入數組中
function add(...values) {
    let sum = 0;
    for (var val of values) {
        sum += val;
    }
    return sum;
}
console.log(add(2, 5, 3)) // 10
    //箭頭函數
var sum = (num1, num2) => num1 + num2;
// 等同於
var sum = function(num1, num2) {
    return num1 + num2;
};
console.log(sum(1, 4), ‘求和‘) //5 "求和"
    //如果只有單個參數
var fun = age => age; //or var fun = (age) => age;
// 等同於
var fun = function(age) {
    return age;
};
console.log(fun(20), ‘箭頭函數單個參數‘) //20 "箭頭函數單個參數"
    //擴展運算符加箭頭函數
const sumList = (...num) => num;
console.log(sumList(1, 2, 3, 4, 5), ‘擴展運算符運用場景一‘) // [1, 2, 3, 4, 5] "擴展運算符運用場景一"
const getList = (name, ...obj) => [name, obj];
console.log(getList(1, 2, 3, 4, 5), ‘擴展運算符運用場景二‘) // [1,[2,3,4,5]] "擴展運算符運用場景二"
    //ES6數組擴展******將一個數組添加到另一個數組的尾部
    // ES5的 寫法
var test2 = [0, 1, 2];
var test3 = [3, 4, 5];
//console.log(test2.push(test3),‘push直接跟數組‘)// 4 "push直接跟數組" push方法的參數不能是數組;
Array.prototype.push.apply(test2, test3);
console.log(test2, ‘沒用...前‘) //[0, 1, 2, 3, 4, 5] "沒用...前"
    // ES6 的寫法
let test4 = [0, 1, 2];
let test5 = [3, 4, 5];
test4.push(...test5);
console.log(test4, ‘使用...後‘) //[0, 1, 2, 3, 4, 5] "使用...後"
    //ES6將類數組轉為數組的方法；dom類似除了document.getElementById()之外的找到的dom都為類數組;另外有length屬性的;
let toList = {
    ‘0‘: ‘bob‘,
    ‘1‘: ‘20‘,
    ‘2‘: ‘man‘,
    length: 3
};
// ES5的寫法
var newArr = [].slice.call(toList);
console.log(newArr, ‘[].slice.call的方法‘) //["bob", "20", "man"] "[].slice.call的方法"
    // ES6的寫法
let newArr1 = Array.from(toList);
console.log(newArr1, ‘Array.from方法‘) //["bob", "20", "man"] "Array.from方法"
    //find方法的回調函數可以接受三個參數，依次為當前的值、當前的位置和原數組;如果沒有符合條件的成員，則返回undefined。
let numList = [1, 5, 15, 20, 25];
let newNumList = numList.find((value, index, arr) => {
    return value > 20;
})
console.log(newNumList, ‘數組find方法‘) //25 "數組find方法"
    //findIndex方法的用法與find方法非常類似，返回第一個符合條件的數組成員的位置，如果所有成員都不符合條件，則返回-1。
let numLogs = [5, 10, 15, 20];
let newNumLogs = numLogs.findIndex((value, index, arr) => {
    return value > 10
})
console.log(newNumLogs, ‘數組findIndex方法‘) //2 "數組findIndex方法"
    //ES6數組的 includes()  第一個參數是否包含一個指定的值，第二個參數表示搜索的起始位置，默認為0;
    //如果第二個參數為負數，則表示倒數的位置，如果這時它大於數組長度（比如第二個參數為-4，但數組長度為3），則會重置為從0開始;
    //沒有該方法之前，我們通常使用數組的indexOf方法，檢查是否包含某個值;
console.log([1, 2, 3].includes(4), ‘includes一個參數‘) //false "includes一個參數"
console.log([1, 2, 3].includes(3, -1), ‘includes兩個參數‘) //true "includes兩個參數"
    //ES6對象的結構和擴展運算符的運用*****...擴展運算符 解構賦值必須是最後一個參數(數組和對象都是一樣) 解構賦值的拷貝是淺拷貝；
let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
console.log(x, ‘對象的第一個值‘); //1 "對象的第一個值"
console.log(y, ‘對象的第二個值‘); //2 "對象的第二個值"
console.log(z, ‘對象的第三個值‘); //{a: 3, b: 4} "對象的第三個值"
let obj = {
    name: ‘bob‘,
    age: 20
}
let obj1 = {
    sex: ‘sex‘,
    cash: 22
}
let newObj = {...obj, ...obj1 }; //等同於 let newObj = Object.assign({}, obj,obj1);
console.log(newObj, ‘擴展運算符合並對象‘) //{name: "bob", age: 20, sex: "sex", cash: 22} "擴展運算符合並對象"
    //ES6 async 函數   await 是順序執行的，Promise.all() 是並行的;
function fun1() {
    console.log(‘第一‘) //第一
}

function fun2() {
    console.log(‘第二‘) //第二
}

function fun3() {
    console.log(‘第三‘) //第三
}
async function testasync() {
    try {
        await fun1()
        await fun2()
        await fun3()
    } catch (error) {
        console.log(error)
    }
}
testasync();
//let [res1, res2, res3] = await Promise.all([fun1(), fun2(),fun3()])
//async 函數中 return 的結果將作為回調的參數;
async function testCallback() {
    return ‘this is a test async function‘
}
testCallback().then(
        userName => console.log(userName)
    )
    // this is a test async function

總結

let

• let的作用域在最近的{}之間
• 如果在定義變量 let a 之前使用變量 a，那麽報錯
• 如果重復定義let a，那麽報錯

const

• 包含let的前面三條
• 只有一次賦值機會，並且必須在聲明的時候立馬賦值

ES6 之 let / const