摘要：學(xué)習(xí)筆記在學(xué)習(xí)的過程中做的一些記錄，用于未來的快速回憶。數(shù)組成員為時(shí)，默認(rèn)值仍會(huì)生效因?yàn)樵趦?nèi)部使用嚴(yán)格相等運(yùn)算符，判斷一個(gè)位置是否有值，所以當(dāng)一個(gè)數(shù)組成員嚴(yán)格等于默認(rèn)值才會(huì)生效。

在學(xué)習(xí)ES6的過程中做的一些記錄，用于未來的快速回憶。

ES6新增塊級(jí)作用域的概念（一個(gè)大括號(hào)括起來的部分就是一個(gè)塊作用域）

let與const用于在塊級(jí)作用域中聲明變量，該變量僅在當(dāng)前塊級(jí)作用域有效

ES6強(qiáng)制啟用嚴(yán)格模式，變量未聲明不允許使用

let關(guān)鍵詞用于聲明變量

const關(guān)鍵詞用于聲明常量，聲明時(shí)必須賦值

let&const關(guān)鍵詞不能在同一個(gè)塊級(jí)作用域內(nèi)重復(fù)聲明一個(gè)變量

const定義的基本類型常量不能被修改，但是引用類型常量內(nèi)部的值能被修改，只要不改變常量的引用即可

ES6允許按照一定模式，從數(shù)組和對(duì)象中提取值，對(duì)變量進(jìn)行賦值。

// 完全解構(gòu)
//本質(zhì)上這種寫法屬于‘模式匹配‘，只要等號(hào)兩邊的模式相同，左邊的變量就會(huì)被賦予對(duì)應(yīng)的值
let [a,b,c] = [1,2,3];        // a=1,b=2,c=3
let [a,[b]] = [1, [2]];        // a=1,b=[2]
let [,,a] = [1,2,3];        // a=3
let [d,...rest] = [1,2,3,4,5,6];    // d=1,rest=[2,3,4,5,6]
// 解構(gòu)不成功
// 如果解構(gòu)不成功，變量的值就等于undefined
let [x,y] = ["xy"]    //x="xy",y=undefined
// 不完全解構(gòu)
let [i,j] = [1,2,3];    // i=1,j=2
//如果等號(hào)的右邊不是數(shù)組，或者說不是可遍歷的結(jié)構(gòu)，那么將會(huì)報(bào)錯(cuò)
let [a] = 1;    // 這里會(huì)報(bào)錯(cuò)：Uncaught TypeError: 1 is not iterable

解構(gòu)賦值允許有默認(rèn)值。

let [x,y="b"] = ["a"];
console.log(y); //b

let [x,y = "b"] = ["a",undefined];
console.log(y); //b 
// 數(shù)組成員為undefined時(shí)，默認(rèn)值仍會(huì)生效
// 因?yàn)樵贓S6內(nèi)部使用嚴(yán)格相等運(yùn)算符‘===‘，判斷一個(gè)位置是否有值，
// 所以當(dāng)一個(gè)數(shù)組成員嚴(yán)格等于undefined,默認(rèn)值才會(huì)生效。

let [x,y = "b"] = ["a",null];
console.log(y); //null
// 如果一個(gè)數(shù)組成員是null,默認(rèn)值就不會(huì)生效，因?yàn)閚ull不嚴(yán)格等于undefined

對(duì)象的解構(gòu)與數(shù)組有一個(gè)重要的不同，數(shù)組的元素是按次序排列的，變量的取值由它的位置決定；而對(duì)象的屬性沒有次序，變量必須與屬性同名，才能取到正確的值。

// 變量名與屬性名一致的情況下
let {foo,bar} = {foo : "aaa",bar : "bbb"}
console.log(foo); //aaa
console.log(bar); //bbb
// 實(shí)際上 對(duì)象的解構(gòu)賦值是以這樣的形式簡寫的
let {foo : foo ,bar : bar} = {foo : "aaa",bar : "bbb"}
// 變量名與屬性名不一致的情況下，必須這樣寫
let {a : name, b : age} = {a : "zhangsan", b : 33};
console.log(name); //zhangsan
console.log(age);  //33

對(duì)象的解構(gòu)賦值的內(nèi)部機(jī)制，是先找到同名屬性，然后再賦值給對(duì)應(yīng)的變量，真正被賦值的是后者，而不是前者，第一個(gè)foo/bar 是匹配的模式，對(duì)應(yīng)的foo/bar屬性值才是變量，真正被賦值的是屬性值（也就是第二個(gè)foo/bar)。

const [a,b,c,d,e] = "hello";
console.log(a); //h
console.log(b); //e
console.log(c); //l
console.log(d); //l
console.log(e); //o

let { length : len} = "yahooa";
console.log(len); 
//類似數(shù)組的對(duì)象都有一個(gè)length屬性，還可以對(duì)這個(gè)屬性解構(gòu)賦值

解構(gòu)賦值時(shí)，如果等號(hào)右邊是數(shù)值和布爾值，則會(huì)先轉(zhuǎn)為對(duì)象，但是等號(hào)右邊為undefined 和 null時(shí)無法轉(zhuǎn)為對(duì)象，所以對(duì)他們進(jìn)行解構(gòu)賦值時(shí)，都會(huì)報(bào)錯(cuò)。

let {prop : x } = undefined;
console.log(x);
//報(bào)錯(cuò)：Uncaught TypeError: Cannot destructure property `prop` of "undefined" or "null"

function move({x = 0,y = 0} = { }){
    return [x,y];
 }
console.log(move({x : 3,y : 4})); //[3,4]
console.log(move({x : 3})); //[3,0]
console.log(move({})); //[0,0]
console.log(move()); //[0,0]
// move()的參數(shù)是一個(gè)對(duì)象，通過對(duì)這個(gè)對(duì)象進(jìn)行解構(gòu)，得到變量x、y的值，如果解構(gòu)失敗，x和y 等于默認(rèn)值
function move2({x,y} = {x : 1, y : 2 }){
    return [x,y];
}
console.log(move2({x : 6,y : 8})); //[6,8]
console.log(move2({})); //[undefined,undefined]
console.log(move2()); //[1,2]
// move2() 是為函數(shù)move的參數(shù)指定默認(rèn)值，而不是為變量x和y指定默認(rèn)值，
// 所以與前一種寫法的結(jié)果不太一樣，undefined 就會(huì)觸發(fā)函數(shù)的默認(rèn)值

改變變量的值

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

從方法返回多個(gè)值

function example(){
  return {
      foo : "a",
      bar : "b"
  }
} 
let {foo,bar} = example();    // foo="a",bar="b"
function example222(){
  return [1,2,3,4,5];
} 
let [a,,...b] = example222();    // a=1, b=[3,4,5]

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

//參數(shù)是一組有次序的值
function example([x,y,z]){
    return x + y + z;
}
example([1,2,3])
console.log(example([1,2,3])); //6
//參數(shù)是一組無次序的值
function f({x,y,z}){
    return x + y + z;
}
f({x : "a", z : "b", y : "c" });
console.log(f({x : "a", z : "b", y : "c" })); //acb

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

函數(shù)參數(shù)的默認(rèn)值

輸入模塊的指定用法

// ES5 的方式
let reg = new RegExp("xyz", "i");
let reg2 = new RegExp(/xyz/i);
reg.test("xyz123");        // true
reg.test("xyz123");        // true
// ES6 方式的變化，可以有第二個(gè)參數(shù)用作修飾符
// 這種方式，第二個(gè)參數(shù)的修飾符會(huì)覆蓋第一個(gè)正則表達(dá)式的修飾符
let reg3 = new RegExp(/xyz/ig, "i")
reg3.flags        // i

// u -> unicode，用于處理unicode編碼的正則匹配
// unicode中4個(gè)字節(jié) = 一個(gè)字母
/^uD83D/.test("uD83DuDC2A");         // true uD83DuDC2A 被當(dāng)做兩個(gè)字母來處理
/^uD83D/u.test("uD83DuDC2A");    // false，uD83DuDC2A 被當(dāng)作一個(gè)字母來處理
// 正則中，大括號(hào)里面若是unicode編碼，需添加u修飾符才能被識(shí)別
/u{61}/.test("a");        // false
/u{61}/u.test("a");    // true
// 用"."操作符識(shí)別大于兩個(gè)字節(jié)的字符需要加上u修飾符
// "."操作符不能處理換行符/回車符/行分隔符/段分隔符
/^.$/.test("吉")；    // false
/^.$/u.test("吉")；    // true
/吉{2}/.test("吉吉");    // false
/吉{2}/u.test("吉吉");    // true
// 凡是超過兩個(gè)字節(jié)的匹配都需要添加 u 修飾符

let s = "bbb_bb_b";
let a1 = /b+/g;
let a2 = /b+/y;
a1.exec(s);        // g修飾符全局匹配，不強(qiáng)調(diào)從下一個(gè)字符開始匹配，只要接下來的字符能匹配成功就ok
a2.exec(s);        // y修飾符全局匹配，必須緊跟著下一個(gè)字符開始匹配
// sticky屬性用于判斷是否開啟了y修飾符
a1.sticky;        // false
a2.sticky;        // true

未實(shí)現(xiàn)，僅作為提案

// "."操作符不能處理換行符/回車符/行分隔符/段分隔符
// 但添加 s 修飾符就可以

console.log(`u0061`);            // a
console.log(`u20887`);            // []7，會(huì)將20087拆成2008 / 7
console.log(`u{20887}`);        //