一、Let和Const
let聲明變量，可變
const定義常量（實(shí)際指的是變量和的內(nèi)存地址），不可變
只能在其聲明或定義的代碼塊內(nèi)有效
注：若區(qū)塊中存在let或者const命令，則這個(gè)區(qū)塊對這些變量和常量在一開始就行成封閉作用域，只要在聲明之前使用就會(huì)報(bào)錯(cuò)（可能會(huì)出現(xiàn)暫時(shí)性死區(qū)）
不能重復(fù)聲明，否則報(bào)錯(cuò)
（一）塊級(jí)作用域
閉包：JS中的變量是沒有作用域時(shí)的一個(gè)臨時(shí)解決方案
塊級(jí)作用域可以任意嵌套
外層作用域不能訪問內(nèi)層作用域的變量
內(nèi)層作用域可以定義外層作用域的變量
函數(shù)中的塊級(jí)作用域
es6中在塊級(jí)作用域中可以聲明函數(shù)
函數(shù)聲明的語句和let的行為類似，在塊級(jí)作用域外不能訪問
函數(shù)聲明也會(huì)提到塊級(jí)作用域的頭部
（二）ES6聲明變量的6種方式
var
function
let
const
import
class
二、解構(gòu)賦值
按照一定模式從數(shù)組和對象中提取值，然后賦值給變量
如果解構(gòu)不成功，則變量的值為undefined
不完全解構(gòu)：等號(hào)左邊的模式值匹配一部分的等號(hào)右邊的數(shù)組，仍然可以解構(gòu)成功
解構(gòu)賦值允指定默認(rèn)值
默認(rèn)值可以引起解構(gòu)的其他變量，但是該變量必須已經(jīng)聲明
（一）對象的解構(gòu)賦值
數(shù)組的元素是按照次序排列的，變量的取值是按照他的位置決定的，而對象沒有次序，變量必須與屬性同名才能取到正確的值
對象的解構(gòu)也可以指定默認(rèn)值，默認(rèn)值生效的條件是，對象的屬性嚴(yán)格的等于undefined
如果解構(gòu)失敗，變量的值就等于undefined
如果解構(gòu)的模式是嵌套的對象，而且子對象所在的父屬性不存在，則會(huì)報(bào)錯(cuò)
不會(huì)復(fù)制繼承自原對象的屬性
（二）字符串的解構(gòu)賦值
字符串解構(gòu)賦值時(shí)字符串被轉(zhuǎn)換成了一個(gè)類似于數(shù)組的對象（類似于數(shù)組的對象還有一個(gè)length屬性，也可對其賦值）
（三）數(shù)值和布爾的解構(gòu)賦值
解構(gòu)賦值時(shí)，如果等號(hào)右邊是數(shù)值或者布爾值，則會(huì)先轉(zhuǎn)換成為對象，在進(jìn)行賦值
解構(gòu)的規(guī)則：只要等號(hào)的右邊不是對象或者數(shù)組，都會(huì)先將其轉(zhuǎn)換成對象（注：undefined和null無法轉(zhuǎn)換成對象，對其進(jìn)行賦值時(shí)都會(huì)報(bào)錯(cuò)）
（四）函數(shù)的解構(gòu)賦值
函數(shù)參數(shù)也可以進(jìn)行解構(gòu)，也可使用默認(rèn)值
（五）圓括號(hào)問題
變量聲明語句，模式不能使用圓括號(hào)（eg：函數(shù)的參數(shù)）
賦值語句的非模式部分可以使用圓括號(hào)
三、字符串的擴(kuò)展
JS允許使用\uxxxx的形式表示一個(gè)字符，xxxx：字符的Unicode碼點(diǎn)
在JS內(nèi)部，字符以UTF-16的格式存儲(chǔ)，每個(gè)字符固定為2個(gè)字節(jié)
codePointAt（）：能正確處理4個(gè)節(jié)點(diǎn)的字符，并返回一個(gè)字符的碼點(diǎn)
參數(shù)：字符在字符串中的位置
String.fromCharCode（）：可以識(shí)別大于0xFFFF的字符
參數(shù)：大于0xFFFF的字符
at（）：可以識(shí)別Unicode編號(hào)大于0xFFFF的字符，返回正確的字符
參數(shù)：
normalize（）：將字符的不同表示方法表示為同樣的形式
參數(shù)：可以接受一個(gè)參數(shù)來決定normalize的形式，有4個(gè)可選值
NFC（默認(rèn)參數(shù)）：標(biāo)準(zhǔn)等價(jià)合成，指視覺和語義上的等價(jià)
NFD：標(biāo)準(zhǔn)等價(jià)分解，在標(biāo)準(zhǔn)等價(jià)的前提下，返回合成字符分解出的多個(gè)簡單字符
NFKC：兼容等價(jià)合成，返回合成字符。兼容等價(jià) 指語義上等價(jià)，直覺上不等價(jià)
NFKD：兼容等價(jià)分解：在兼容等價(jià)的前提下，返回合成字符分解出的多個(gè)簡單字符
（一）除indexOf（）外來確定一個(gè)字符串中是否包含靈感字符串的3中方法
includes（）：返回布爾值，表是否找到了參數(shù)字符串
參數(shù)：要查找的字符串
starsWith（）：返回布爾值，表參數(shù)字符串是否在源字符串的頭部
參數(shù)：要查找的字符串
endsWith（）：返回布爾值，表參數(shù)字符串是否在源字符串的尾部
參數(shù)：要查找的字符串
其他一些方法
repeat（）：返回一個(gè)字符串，表示將原字符串重復(fù)n次
參數(shù)：次數(shù)n
注：
參數(shù)是小數(shù)，會(huì)被取整
參數(shù)是負(fù)數(shù)或者Infinity，會(huì)報(bào)錯(cuò)
參數(shù)在0-1之間，則等同于0
參數(shù)為NaN，則等同于0
padStar（）：頭部補(bǔ)全 而 padEnd（）：尾部補(bǔ)全
參數(shù)1：指定字符串的最小長度
參數(shù)2：用于補(bǔ)全的字符串
注：
若原字符串的長度等于或大于指定的最小長度，返回原字符串
若用于補(bǔ)全的字符串與原字符串之和超出了指定的最小長度，則會(huì)截去超出位數(shù)的補(bǔ)全字符串
如果省略了第二個(gè)參數(shù)，會(huì)用空格補(bǔ)全
（二）模板字符串
``
可當(dāng)做普通字符串使用
可定義多行字符串
可嵌套變量（需將變量寫在${}中）
可調(diào)用函數(shù)
可嵌套模板字符串
String.raw（）：充當(dāng)模板字符串的處理函數(shù)，返回一個(gè)反斜線都被轉(zhuǎn)義的字符串，對應(yīng)于替換變量后的模板字符串
也可當(dāng)正常的函數(shù)使用，第一個(gè)從參數(shù)應(yīng)該是一個(gè)具有raw屬性的對象（應(yīng)該是一個(gè)數(shù)組）
四、數(shù)值的擴(kuò)展
ES6 中八進(jìn)制要以前綴0o表示
（一）Number的擴(kuò)展
Number.isFinite（）：檢查一個(gè)數(shù)值是否為有限的
參數(shù)：要檢查的數(shù)值
Number.isNaN（）：用于檢查一個(gè)數(shù)值是否為NaN
參數(shù)：要檢查的數(shù)值
Number.isInteger（）：判斷一個(gè)數(shù)是否為整數(shù)
參數(shù)：要檢查的數(shù)值
Number.isSafeInteger（）：判斷一個(gè)數(shù)是否摟在這個(gè)范圍之內(nèi)，返回布爾值
參數(shù)：要檢查的數(shù)值
（二）Math對象的擴(kuò)展
Math.trunc（）：用于除去一個(gè)數(shù)的小數(shù)部分，返回整數(shù)部分
對于非數(shù)值，內(nèi)部將其先轉(zhuǎn)化為數(shù)值
對于空值和無法返回的值，返回NaN
參數(shù)：要檢查的數(shù)值
Math.sign（）：判斷一個(gè)數(shù)到底是正數(shù)，負(fù)數(shù)，還是0
參數(shù)有5中情況
參數(shù)為正數(shù)，返回+1
參數(shù)為負(fù)數(shù)，返回-1
參數(shù)為0，返回0
參數(shù)為-0，返回-0
其他值，返回NaN
注：對于非數(shù)值，會(huì)將其轉(zhuǎn)換為數(shù)值
Math.cbrt（）：用于計(jì)算一個(gè)數(shù)的立方根（對于非數(shù)值，此案轉(zhuǎn)換為數(shù)值）
Math.clz32（）：返回一個(gè)數(shù)的32位無符號(hào)整數(shù)形式有多少個(gè)前導(dǎo)0
參數(shù)：數(shù)值
對于小數(shù)，只考慮整數(shù)部分
對于空值和其他類型的值，先轉(zhuǎn)換成為數(shù)值，在計(jì)算
Math.imul（）：返回兩個(gè)數(shù)以32位帶符號(hào)正數(shù)形式相乘的結(jié)果，返回的也是一個(gè)32位的帶符號(hào)整數(shù)
Math.fround（）：返回一個(gè)數(shù)的單精度浮點(diǎn)數(shù)形式
Math.hypot（）：返回所有參數(shù)的平方和的平方根
若參數(shù)不是數(shù)值，會(huì)先轉(zhuǎn)換成數(shù)值，在計(jì)算、
只要有一個(gè)參數(shù)無法轉(zhuǎn)換為數(shù)值，就返回NaN
（1）對數(shù)
Math.expm1（x）：返回e的x次方-1
Math.log1p（x）：返回ln（1+x），如果x小于-1，返回NaN
Math.log10（x）：返回以10 為底x的對數(shù)，如果小于0，返回NaN
Math.log2（x）：返回以2 為底x的對數(shù)，如果小于0，返回NaN
（2）雙曲函數(shù)
Math.sinh（x）：返回x的雙曲正弦
Math.cosh（x）：返回x的雙曲余弦
Math.tanh（x）：返回x的雙曲正切
Math.asinh（x）：返回x的反雙曲正弦
Math.acosh（x）：返回x的反雙曲余弦
Math.atanh（x）：返回x的反雙曲正切
（3）Math.signbit（）
判斷一個(gè)數(shù)的正負(fù)
參數(shù)是NaN，返回false
參數(shù)是-0，返回true
參數(shù)是負(fù)值，返回true
其他情況，返回false
（三）integer數(shù)據(jù)類型
必須要以后綴n來表示
二進(jìn)制、八進(jìn)制、十六進(jìn)制都要以后綴n來表示
注：
幾乎所有的Number運(yùn)算都能用在integer中，除>>>和求證運(yùn)算符+
Integer類型與Number類型不能混合運(yùn)算，會(huì)報(bào)錯(cuò)
相等運(yùn)算符（==）會(huì)改變數(shù)據(jù)類型，不能混合使用
精確相等運(yùn)算符（===）不會(huì)改變數(shù)據(jù)類型，可以混合使用
五、函數(shù)的擴(kuò)展
ES6允許為函數(shù)設(shè)置默認(rèn)值，即直接寫在參數(shù)定義的后面
使用參數(shù)默認(rèn)值時(shí)，不能有同名的參數(shù)
注：參數(shù)默認(rèn)值不是傳值的，而是每次都重新計(jì)算默認(rèn)值表達(dá)式的值（參數(shù)默認(rèn)值是惰性求值）
通常情況下，定義了參數(shù)默認(rèn)值的參數(shù)是函數(shù)的尾參數(shù)
有參數(shù)的默認(rèn)值都是尾參數(shù)，除非顯示輸入undefined，如果傳入的是undefined，將觸發(fā)默認(rèn)值，null不行
設(shè)置了默認(rèn)值之后，或者默認(rèn)值不是尾參數(shù)，函數(shù)的length不在計(jì)入后面的參數(shù)（length屬性失真）
一旦設(shè)置了參數(shù)的默認(rèn)值，函數(shù)在進(jìn)行初始化的時(shí)候，參數(shù)會(huì)形成一個(gè)單獨(dú)的作用域，等到初始化結(jié)束的時(shí)候，這個(gè)作用域消失（不設(shè)置參數(shù)默認(rèn)值的時(shí)候不會(huì)出現(xiàn)）
利用參數(shù)默認(rèn)值可以指定某一個(gè)參數(shù)不得省略，若省略則報(bào)錯(cuò)
可以將參數(shù)默認(rèn)值設(shè)置為undefined，表示這個(gè)參可以省略
rest參數(shù)（形為“…變量名”），用于獲取函數(shù)多余的參數(shù)
函數(shù)的name屬性返回函數(shù)的函數(shù)名
箭頭函數(shù)
ES6簡明筆記中有
注：
箭頭函數(shù)可以嵌套箭頭函數(shù)
六、數(shù)組的擴(kuò)展
擴(kuò)展運(yùn)算符 （ . . . ）
主要用于函數(shù)調(diào)用
擴(kuò)展運(yùn)算符 后可以放表達(dá)式
如果擴(kuò)展運(yùn)算符后面是一個(gè)空數(shù)組，則不產(chǎn)生任何效果
可以合并數(shù)組
可以與結(jié)構(gòu)賦值結(jié)合起來生成數(shù)組
若擴(kuò)展運(yùn)算符用于數(shù)組，只能放在參數(shù)的最后一位，否則報(bào)錯(cuò)
可以將字符串轉(zhuǎn)為真正的數(shù)組
Array.from（）：將偽數(shù)組（兩類對象：類似于數(shù)組的對象）轉(zhuǎn)換為真正的數(shù)組
Array.of（一組值）：將一組數(shù)轉(zhuǎn)換為數(shù)組，若沒有參數(shù)，則返回空數(shù)組
copyWithin（）：在當(dāng)前數(shù)組內(nèi)部將指定位置的成員復(fù)制到其他地方，然后返回?cái)?shù)組（會(huì)修改數(shù)組）
接受3個(gè)參數(shù)
target（必選）：從該位置開始替換數(shù)據(jù)
start（可選）：從該位置開始讀取數(shù)據(jù)，默認(rèn)值為0，如果為負(fù)數(shù)，表示倒數(shù)
end（可選）：到該位置停止讀取數(shù)據(jù)，默認(rèn)等于數(shù)組長度，若為負(fù)，表示倒數(shù)
fill（）：用于填充數(shù)組
參數(shù)1（必填）：用于填充的給定值
參數(shù)2（可選）：填充的起始位置
參數(shù)3（可選）：填充的結(jié)束位置
entries（）、keys（）、value（）用于遍歷數(shù)組
entries（）：對鍵值對的遍歷
keys（）：對鍵名的遍歷
values（）：對鍵值的遍歷
includes（）：表示某個(gè)數(shù)組是否包含給定的值，返回一個(gè)布爾值
參數(shù)1：給定值
參數(shù)2：搜索的起始位置，默認(rèn)為0，若為負(fù)數(shù)，則表示倒數(shù)的位置，如果這時(shí)大于數(shù)組長度，則會(huì)重置為從0開始
數(shù)組的空位
數(shù)組的空位值數(shù)組的某一個(gè)位置沒有任何值（空值不是undefined）
Array.from（）會(huì)將數(shù)組的空位轉(zhuǎn)換成為undefined
擴(kuò)展運(yùn)算符也會(huì)將空位轉(zhuǎn)為undefined
copyWithin（）會(huì)將空位一起復(fù)制
fill（） 會(huì)將空位視為數(shù)組正常的位置
七、對象的擴(kuò)展
ES6允許直接寫入變量和函數(shù)作為對象的屬性和方法
在對象中可只寫屬性名，不寫屬性值
可直接用標(biāo)識(shí)符作為屬性名，也可將表達(dá)式放在方括號(hào)內(nèi)作為屬性名（字面量定義）
Object.is（）：比較兩個(gè)值是否嚴(yán)格相等，與嚴(yán)格相等運(yùn)算符（===）的行為基本一致（注：有兩個(gè)不同之處1：+0不等于 -0、2：NaN等于自身）
Object.assign（）：將源對象的所有可枚舉屬性復(fù)制到目標(biāo)對象
第一個(gè)參數(shù)是目標(biāo)對象，后面的參數(shù)是源對象
注：
只有一個(gè)參數(shù)，會(huì)返回改參數(shù)
若改參數(shù)不是對象，會(huì)先轉(zhuǎn)換為對象，然后返回
由于undefined和null無法轉(zhuǎn)換為對象，所以人工將它們作為參數(shù)就會(huì)報(bào)錯(cuò)
其他類似的值（數(shù)值、布爾）不在首參也不會(huì)報(bào)錯(cuò)，但是除了字符串會(huì)議數(shù)組的形式復(fù)制到目標(biāo)對象，其他值都不會(huì)產(chǎn)生效果
Object.assign（）是淺復(fù)制（即源對象的某個(gè)屬性的值是對象，name目標(biāo)對象復(fù)制得到的是這個(gè)對象的引用）
（一）對象的可枚舉性
for…in循環(huán)：只遍歷對象自身和繼承的可枚舉屬性
Object.keys（）：返回對象自身的所有可枚舉屬性的鍵名
JSON.Stringify（）：只串化對象自身的可枚舉屬性
Object.assign（）：將源對象的所有可枚舉屬性復(fù)制到目標(biāo)對象
注：所有class的原型的方法時(shí)不可枚舉的
（二）屬性的遍歷
for…in：循環(huán)遍歷對象自身和繼承的可枚舉屬性（不包含Symbol屬性）
Object.keys（obj）：返回一個(gè)數(shù)組，包含對象自身的（不含繼承的）所有可枚舉屬性（不包含symbol屬性）
Object.getOwnPropertyNames（obj）：返回一個(gè)數(shù)組，包含對象自身的所有屬性（不含Symbol，但是含有不可枚舉屬性）
Object.getOwnPropertySymbols（obj）：返回一個(gè)數(shù)組，包含對象自身的所有Symbol屬性
Reflect.ownKeys（obj）：返回一個(gè)數(shù)組，包含對象自身的所有屬性，不管屬性名是Symbol還是字符串，也不管是否可枚舉
以上5中均遵循屬性遍歷次序規(guī)則
首先遍歷所有屬性名為數(shù)值的屬性，按照數(shù)字排序
其次遍歷所有屬性名為字符串的屬性，按照生成時(shí)間排序
最后遍歷所有屬性名為Symbol的屬性，按照生成時(shí)間排序
（三）_ _ proto _ _屬性
用于讀取或者設(shè)置當(dāng)前對象的prototype屬性
缺點(diǎn)：兼容性和語義都不是很好
ES6使以下三種替換它
Object.setPrototypeOf（obj）：用來設(shè)置一個(gè)對象的prototype屬性，返回參數(shù)對象本身
參數(shù)：第一個(gè)參數(shù)若不是對象，則會(huì)自動(dòng)轉(zhuǎn)化為對象（undefined和null時(shí)會(huì)報(bào)錯(cuò)）
Object.getPrototypeOf（）：用于讀取一個(gè)對象的prototype屬性
參數(shù)：參數(shù)若不是對象，則會(huì)自動(dòng)轉(zhuǎn)化為對象（undefined和null時(shí)會(huì)報(bào)錯(cuò)）
Object.reate（）：生成對象
（四）對象的解構(gòu)賦值和擴(kuò)展運(yùn)算符混用
對象的解構(gòu)賦值會(huì)將所有的鍵值對都復(fù)制到新的對象上面
解構(gòu)賦值必須是最后一個(gè)參數(shù)，否則會(huì)報(bào)錯(cuò)
解構(gòu)賦值不會(huì)復(fù)制繼承自原型對象的屬性
擴(kuò)展運(yùn)算符可用于合并兩個(gè)對象
若自定義的屬性放在擴(kuò)展運(yùn)算符后面，則擴(kuò)展運(yùn)算符內(nèi)部有同名屬性會(huì)被覆蓋
若把自定義屬性放在擴(kuò)展運(yùn)算符前面，則變成了設(shè)置新對象的默認(rèn)屬性
若擴(kuò)展運(yùn)算符的參數(shù)是undefined或者null，則這兩個(gè)值會(huì)被忽略，不會(huì)報(bào)錯(cuò)
若擴(kuò)展運(yùn)算符的參數(shù)對象之中有取值函數(shù)get，則這個(gè)函數(shù)會(huì)被執(zhí)行
（四）Object.getOwnPropertyDescriptors（obj）
Object.getOwnPropertyDescriptor（obj）：用于返回某個(gè)對象屬性的描述對象
Object.getOwnPropertyDescriptors（obj）：返回指定對象所有自身屬性（非繼承屬性）的描述對象
主要是為了解決Object.assign（）無法正確復(fù)制get屬性和set屬性
（五）Null傳導(dǎo)運(yùn)算符
四中用法
obj?.prop ：讀取對象屬性
obj?.[expr]：讀取對象屬性
func.{…args}：函數(shù)或?qū)ο蠓椒ǖ恼{(diào)用
new C ?.{…args}：構(gòu)造函數(shù)的調(diào)用
八、Symbol
新的數(shù)據(jù)類型，表示獨(dú)一無二的值
通過symbol函數(shù)生成
let s=Symbol();
對象屬性名的兩種表示方法：1、原有字符串表示。2、Symbol表示
Symbol可接受一個(gè)字符串作為參數(shù)，表示對Symbol實(shí)例的描述，主要是為了在控制臺(tái)輸出，或者是轉(zhuǎn)為字符串時(shí)比較容易區(qū)分
如果Symbol的參數(shù)是一個(gè)對象，則會(huì)調(diào)用toString方法將其轉(zhuǎn)換成為字符串，然后生成一個(gè)Symbol值
Symbol值不能與其他類型的值進(jìn)行運(yùn)算，否則會(huì)報(bào)錯(cuò)
Symbol值可以顯式的轉(zhuǎn)為字符串
let sym=Symbol('My Symbol');
String(sym); //'Symbol(My Symbol)'
sym.toString(); //'Symbol(My Symbol)'
Symbol值也可以轉(zhuǎn)換成為布爾值，但是不能轉(zhuǎn)換為數(shù)值
let sym=Symbol();
Boolean(sym); //true
!sym; //false
Number(sym); //TypeError
Symbol值作為對象的屬性名時(shí)不能使用點(diǎn)運(yùn)算符，只能用方括號(hào)
在對象內(nèi)部使用Symbol值定義屬性時(shí)，也只能用方括號(hào)
let sym=Symbol();
let a={};
a.sym='Hello';
a[sym]; //undefined
s['sym']; //'Hello'
Symbol類型的值還可以定義一組常量，保證這些常量都是不相等的
（一）屬性名遍歷
Object.getOwnPropertySymbols（）：返回一個(gè)數(shù)組，成員是當(dāng)前對象的所有作用屬性名的Symbol值
Reflect.ownKeys（）：以數(shù)組的形式返回所有鍵名，包括常規(guī)鍵名和S也Symbol鍵名
以Symbol值作為屬性名的屬性不會(huì)被常規(guī)方法遍歷得到（可為對象定義一些非私有但又希望只用于內(nèi)部的方法）
Symbol.for（）：可重新使用同一個(gè)Symbol值
參數(shù)：一個(gè)字符串
作用：搜索有沒有以該參數(shù)作為名稱的Symbol值，若有則返回這個(gè)Symbol值，否則就新建并返回一個(gè)以該字符串為名稱的Symbol值
Symbol.for()與Symbol都可以生成新的Symbol
區(qū)別：前者會(huì)被登記在全局環(huán)境中供搜索，后者不會(huì)
Singleton模式：調(diào)用一個(gè)類，并且在任何時(shí)候都返回同一個(gè)實(shí)例
（二）內(nèi)置的Symbol值
對象的Symbol.hasInstance屬性指向一個(gè)內(nèi)部方法，對象使用instanceof運(yùn)算符是會(huì)調(diào)用這個(gè)方法，判斷該對象是否為某個(gè)構(gòu)造函數(shù)的實(shí)例
class Myclass{
? ? [Symbol.hanInstance](foo){
? ? ? ? return foo instanceof Array;
? ? }
}
[1,2,3] instanceof new Myclass; //true
對象的Symbo.isConcatSpreadable屬性等于一個(gè)布爾值，表示該對象在使用Array.prototype.concat（）時(shí)是否可以展開
let arr1=['c','d'];
['a','b'].concat(arr1,'e'); //['a','b','c','d','e']
arr1[Symvol.isConcatSpreadable] //undefined
let arr2=['c','d'];
arr2[Symbol.isConcatSpreadable]=false;
['a','b'].concat(arr2,'e'); //['a','b',['c','d'],'e']
數(shù)組的默認(rèn)行為是可以展開的，Symbol.isConcatSpreadable屬性等于undefined或者true，都可以
類似于數(shù)組的對象也可以展開，但它的Symbol.isConcatSpreadable屬性默認(rèn)為false，必須手動(dòng)打開、
let obj={length:2,0:'c',1:'d'};
['a','b'].concat(obj,'e'); //['a','b',obj,'e']
obj[Symbol,isConcatSpreadable]=true;
['a','b'].concat(obj,'e'); //['a','b','c','d','e']
對于一個(gè)類而言，Symbol.isConcatSpreadable屬性必須寫成實(shí)例的屬性
（1）Symbol.species
對象的Symbol.species屬性指向當(dāng)前對象的構(gòu)造函數(shù)，使用這個(gè)函數(shù)返回的函數(shù)來創(chuàng)造新的實(shí)例對象
定義Symbol.species屬性要用get讀取數(shù)據(jù)
class Array extends Array{
? ? //覆蓋父類Array的構(gòu)造函數(shù)
? ? static get [Symbol.species](){return Array;}
（2）Symbol.match
對象的Symbol.match屬性指向一個(gè)函數(shù)，當(dāng)執(zhí)行str.match（obj）時(shí)，如果該屬性存在，則會(huì)調(diào)用它的返回值
（3）Symbol.replace
對象的Symbol.replace屬性指向一個(gè)方法，當(dāng)對象被String.prototype.replace方法調(diào)用時(shí)會(huì)返回改方法的返回值
（4）Symbol.split
對象的Symbol.split屬性指向一個(gè)方法，當(dāng)對象被String.prototype.split方法調(diào)用時(shí)會(huì)返回改方法的返回值
（5）Symbol.iterator
對象的Symbol.iterator屬性指向該對象默認(rèn)的遍歷方法
（6）Symbol.toPrimitive
對象的Symbol.toPrimitive屬性指向一個(gè)方法，對象在轉(zhuǎn)化為原始數(shù)據(jù)類型時(shí)會(huì)調(diào)用這個(gè)方法，返回該對象的原始數(shù)據(jù)類型
參數(shù)：字符串，表示當(dāng)前運(yùn)算模式
Number：需要轉(zhuǎn)化為數(shù)值
String：需要轉(zhuǎn)化為字符串
Default：可轉(zhuǎn)化為數(shù)組，也可轉(zhuǎn)化為字符串
（7）Symbol.toStringTag
對象的Symbol.toStringTag屬性指向一個(gè)方法，在對象上調(diào)用Object.prototype.toString（）時(shí)，如果這個(gè)屬性存在，其返回值會(huì)出現(xiàn)在toString方法返回值的字符串中，表示對象的類型
（8）Symbol.unscopables
對象的Symbol.unscopables屬性指向一個(gè)對象，指定了使用with關(guān)鍵字時(shí)，那些屬性會(huì)被with環(huán)境排除
九、Set和Map
（一）Set
類似于數(shù)組，其成員唯一，不重復(fù)
Set本身是一個(gè)構(gòu)造函數(shù)，用于生產(chǎn)Set數(shù)據(jù)結(jié)構(gòu)
let s=new Set();
Set函數(shù)可以接受一個(gè)數(shù)組，作為參數(shù)，用于初始化
向Set加入值時(shí)不會(huì)發(fā)生數(shù)據(jù)轉(zhuǎn)換，即1和’1’為不同的值
在Set內(nèi)部，兩個(gè)NaN相等
（1）Set實(shí)例的屬性
Set.prototype.Constructor（）：構(gòu)造函數(shù)，就是Set（）
Set.prototype.size（）：返回Set實(shí)例成員總數(shù)
add（value）：添加值，返回Set本身
delete（value）：刪除值，返回一個(gè)布爾值，表刪除是否成功
has（value）：返回布爾值，表參數(shù)是否為Set成員
clear（）：清除所有成員，無返回值
（2）遍歷
keys（）：返回鍵名的遍歷器
values（）：返回鍵值的遍歷器
entries（）：返回鍵值對的遍歷器
forEach（function（）{}）：使用回調(diào)函數(shù)遍歷每個(gè)成員，無返回值（可加參2，表示綁定的this對象）
Set的遍歷順序就是插入順序
若想同步的改變原來的Set結(jié)構(gòu)，可利用原Set映射出一個(gè)新的結(jié)構(gòu)再復(fù)制給原Set結(jié)構(gòu)，或者使用Array.from（）
（二）WeaKSet
與Set類似，表不重復(fù)的集合
與Set的區(qū)別
WeakSet的成員只能是對象，不能是其他值
WeakSet中的對象都是弱引用，即垃圾回收機(jī)制不考慮WeakSet對該對象的引用
WeakSet的成員不能引用，因?yàn)槠潆S時(shí)可能消失
WeakSet本生是一個(gè)構(gòu)造函數(shù)，使用生成WeakSet數(shù)據(jù)結(jié)構(gòu)
let w = new WeakSet();
可接受一個(gè)數(shù)組或者類似于數(shù)組的對象作為參數(shù)來初始化
WeakSet的方法
WeakSet.prototype.add（value ）：添加新成員
WeakSet.prototype.delete（value）：刪除指定成員
WeakSet.prototype.has（value）：返回布爾值，表指定值是否在WeakSet實(shí)例中
WeakSet無size屬性，無法遍歷其成員
（三）Map
類似于對象，也是鍵值組合
其鍵的范圍不限于字符串，可為各種數(shù)據(jù)類型的值（包括對象）均可當(dāng)做鍵
使用Map（）構(gòu)造函數(shù)生成
let m = new Map();
Map可接受一個(gè)數(shù)組作為參數(shù)，其數(shù)組成員為一個(gè)個(gè)表示鍵值對的數(shù)組
若一個(gè)鍵多次賦值，則后面的覆蓋前面的值
若讀取一個(gè)未知的鍵，則返回undefined
Map的鍵實(shí)際上綁定的是地址值，只要地址不同，即視為兩個(gè)鍵（解決了同名屬性碰撞的問題）
（1）Map實(shí)例的屬性方法
1、size（）
返回Map結(jié)構(gòu)的成員總數(shù)
2、set（key，value）
設(shè)置key值所對應(yīng)的鍵，然后返回Map結(jié)構(gòu)
若key已經(jīng)有值，則賦值更新，否則新生成該鍵值
3、get（key）
獲取key對應(yīng)的值，若找不到key則返回undefined
4、has（key）
返回一個(gè)布爾值，表示ley是否在Map結(jié)構(gòu)中
5、delete（key）
刪除某個(gè)鍵，刪除成功則返回true，反之返回false
6、clear（）
清除所有成員，無返回值
（2）遍歷
keys（）：返回鍵名的遍歷器
values（）：返回鍵值的遍歷器
entries（）：返回鍵值對的遍歷器
forEach（function（）{}）：遍歷Map所有成員
Map的遍歷順序就是插入順序
（四）Map與其他數(shù)據(jù)類型的轉(zhuǎn)化
（1）Map轉(zhuǎn)數(shù)組
Map轉(zhuǎn)化為數(shù)組最快的方法時(shí)結(jié)合使用擴(kuò)展運(yùn)算符（ . . . ）
（2）數(shù)組轉(zhuǎn)Map
將數(shù)組傳入構(gòu)造函數(shù)即可
（3）Map轉(zhuǎn)對象
若Map所有鍵都是字符串，則可以轉(zhuǎn)為對象
function strMapToObj(strMap){
? ? let obj = Object.create(null);
? ? for (let [k,v] of strMap){
? ? ? ? obj[k]=v;
? ? }
? ? return obj;
}
（4）對象轉(zhuǎn)Map
function objToStrMap(obj){
? ? let strMap=new Map();
? ? for(let k of Object.keys(obj)){
? ? ? ? strMap.set(k.obj[k]);
? ? }
? ? return strMap;
}
（5）Map轉(zhuǎn)JSON
情況一：Map鍵名都是字符串，可以轉(zhuǎn)為對象JSON
function StrMapToJson(StrMap){
? ? reutrn JSON.stringify(strMapToObj(strMap));
}
情況二：Map鍵名中含有非字符串，轉(zhuǎn)為數(shù)組JSON
function mapToArrayJson(map){
? ? return JSON.stringify(...map);
}
（6）JSON轉(zhuǎn)Map
正常情況所有鍵名都是字符串
function jsonToStrMap(jsonStr){
? ? return objToStrMap(JSON.parse(jsonStr));
}
特殊情況：在整個(gè)JSON就是一個(gè)數(shù)組，且數(shù)組成員本身又是由一兩個(gè)成員的數(shù)組，此時(shí)應(yīng)該一一對應(yīng)的轉(zhuǎn)為Map（數(shù)組轉(zhuǎn)為JSON的逆操作）
function jsonToMap(jsonStr){
? ? return new Map(JSON.parse(jsonStr));
}
（五）WeakMap
與Map結(jié)構(gòu)類似，也用于生成鍵值對的集合
通過WeakMap函數(shù)生成
let wMap = new weakMap();
可使用set方法添加成員
可接受一個(gè)數(shù)組，作為構(gòu)造函數(shù)的參數(shù)
