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

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

ES6新增塊級作用域的概念（一個大括號括起來的部分就是一個塊作用域）

let與const用于在塊級作用域中聲明變量，該變量僅在當前塊級作用域有效

ES6強制啟用嚴格模式，變量未聲明不允許使用

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

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

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

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

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

// 完全解構(gòu)
//本質(zhì)上這種寫法屬于‘模式匹配‘，只要等號兩邊的模式相同，左邊的變量就會被賦予對應(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
//如果等號的右邊不是數(shù)組，或者說不是可遍歷的結(jié)構(gòu)，那么將會報錯
let [a] = 1;    // 這里會報錯：Uncaught TypeError: 1 is not iterable

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

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

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

let [x,y = "b"] = ["a",null];
console.log(y); //null
// 如果一個數(shù)組成員是null,默認值就不會生效，因為null不嚴格等于undefined

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

// 變量名與屬性名一致的情況下
let {foo,bar} = {foo : "aaa",bar : "bbb"}
console.log(foo); //aaa
console.log(bar); //bbb
// 實際上 對象的解構(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

對象的解構(gòu)賦值的內(nèi)部機制，是先找到同名屬性，然后再賦值給對應(yīng)的變量，真正被賦值的是后者，而不是前者，第一個foo/bar 是匹配的模式，對應(yīng)的foo/bar屬性值才是變量，真正被賦值的是屬性值（也就是第二個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ù)組的對象都有一個length屬性，還可以對這個屬性解構(gòu)賦值

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

let {prop : x } = undefined;
console.log(x);
//報錯：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òu)，得到變量x、y的值，如果解構(gòu)失敗，x和y 等于默認值
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ù)指定默認值，而不是為變量x和y指定默認值，
// 所以與前一種寫法的結(jié)果不太一樣，undefined 就會觸發(fā)函數(shù)的默認值

改變變量的值

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

從方法返回多個值

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ù)的默認值

輸入模塊的指定用法

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

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

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

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

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

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