ES6 新增基本數據類型Symbol

　　ES6 增長了一個新的基本數據類型 symbol. 不過，和其餘基本數據類型相比，它有點不同凡響，由於它沒有字面量的表現形式，並且建立的方式也有點奇怪，只能經過調用全局函數Symbol()來完成。

let firstSymbol = Symbol();

　　 這裏注意一點，Symbol函數調用的時候，前面不要加new. 建立了一個symbol, 它有什麼做用呢？ 能夠把它看做一個類字符串，和字符串的使用方式一致，字符串能用的地方，symbol 基本都能用，最經常使用的地方就是做爲對象的屬性名使用，由於，symbol建立的原由是一項對象的私有屬性的提議，落實到規範中，私有屬性去除掉了，對象的屬性保留下來了

let firstSymbol = Symbol();

let person = {
    [firstSymbol]: 'symbolName'
}

let dog = {};
dog[firstSymbol] = "sybolName"

　　你可能會問，字符串都能解決的事情，爲何要建立symbol 呢？ 由於symbol 是惟一的，它和任何其餘symbol 都不相等，避免了屬性名的衝突。

let firstSymbol = Symbol();
let secondSymbol = Symbol();
console.log(firstSymbol == secondSymbol) // false

　　這麼調用Symbol() 函數也有問題，就是程序出問題， 進行debugger 的時候，不是很容易找到哪一個symbol  出現的問題，因此Symbol  函數能夠接受一個字符串， 對這個symbol 進行描述。

let firstSymbol = Symbol('first symbol');
let secondSymbol = Symbol('second symbol');
console.log(secondSymbol) //Symbol(second symbol)

　　symbol的描述存在於每個symbol 的內部屬性 [[Description]] 中，外部是沒法獲取的，不過，能夠經過顯示或隱式調用toString() 方法來獲取， console.log 就是經過隱式調用toString 方法來獲取描述的。

　　可是有時候，你不想要這種惟一性， 可能全部的對象都共用一個symbol 屬性， 這怎麼辦？ 在一個文件js中，很好處理，全部的對象都使用這一個symbol  變量就能夠了，但跨文件就很差處理了，尤爲是提倡模塊化的今天，每個文件都是一個模塊，都有本身的私有做用域。在這種狀況下，就要使用共享symbol 了，建立symbol 變量的時候，使用Symbol.for() 方法，參數是一個字符串， 能夠理解爲共享標識key, 

let uid = Symbol.for('uid');

 　　當咱們使用Symbol.for() 建立symbol 的時候，js 引擎就會向全局symbol 註冊中心去查找這個symbol, 查找的依據是惟一的標識key（在這裏是‘’uid‘’）， 若是找到了，就直接返回，若是沒有找到，就建立一個新的symbol，並使用惟一的標識key註冊到全局註冊中心，而後返回它， 這樣，咱們之後再使用這個key 建立 symbol, 就會獲取到同一個symbol, 這就共享了。舉個例子驗證一下

let uid1 = Symbol.for('uid');
let uid2 = Symbol.for('uid');

console.log(uid1 === uid2); // true

　　還有一個Symbol.keyFor() 方法，能夠獲取到一個symbol 在全局註冊中心中註冊的惟一標識key。

let uid1 = Symbol.for('uid');
let symbolKey = Symbol.keyFor(uid1);
console.log(symbolKey)  // 'uid'

 　　若是一個對象中有多個symbol 屬性，是否是能夠一次性地獲取到？ 你可能想到了Object.keys() 方法，可是它對symbol 不起做用，爲了獲取到symbol 屬性，js 專門定義了一個方法，Object.getOwnPropertySymbols(), 它返回一個包含全部symbol 屬性地數組。

let uid = Symbol.for("uid");
let object = {
    [uid]: "12345"
};
let symbols = Object.getOwnPropertySymbols(object);
console.log(symbols.length); // 1
console.log(symbols[0]); // "Symbol(uid)"
console.log(object[symbols[0]]); // "12345"

　　固然，若是僅僅是爲了給對象簡單地添加屬性，就增長一個symbol 類型和Symbol() 函數，那就有點大才小用了。添加Symbol 還要一個很大的做用，就是暴露js的一些內部方法(Exposing Internal Operations), 爲此， js 定義了一些有名的symbol (well-known symbols)， 這些symbols 都是增長到Symbol 對象上。

　　1， Symbol.hasInstance

　　 每個函數都有一個Symbol.hasInstance方法，主要是判斷一個對象是否是一個函數的實例，就是日常咱們使用的instanceOf 方法. obj instanceOf Array， 實際上就是調用Array 函數上面的Symbol.hasInstance 方法，Array[Symbol.hasInstance](obj),  能夠發現，Symbol.hasInstance 方法 接受一個參數就是咱們要檢查的對象，而後返回true or false, 來表示檢查的對象是否是函數的實例， true 就表示是，false 表示不是。寫一個簡單的例子體驗一下

　　首先必須有一個函數， 那就聲明一個函數Person

function Person(name) {
    this.name = name;
}

　　它 有一個方法Symbol.hasInstance，函數怎麼會有方法呢？在js 中，函數就是一個對象，對象怎麼加方法，函數就怎麼加方法。對象添加方法，一個是. 號，一個是[]. 對於Symbol.hasInstance 來講它只能用[] ， Person[Symbol.hasInstance]， 它是一個函數，接受一個參數，而後返回true or false

Person[Symbol.hasInstance] = function(value) {
    return false;
}

　　如今使用instanceOf 方法驗證一下

console.log(new Person('sam') instanceof Person);

 　　你會發現，返回true, 可是 咱們明明返回的是false， 是哪一個地方出問題了?  這是由於每個函數都有一個默認的Symbol.hasInstance, 它位於函數的原型鏈Function.prototype 上， 咱們在Person 函數上定義Symbol.hasInstance方法是至關於遮蔽原型鏈上的方法，可是在原型鏈上定義的Symbol.hasInstance 方法，它是不可配置，不可改寫，不可迭代的。正是因爲不可改寫，像Person[Symbol.hasInstance] 普通賦值的方式沒法真正實現賦值，靜默失敗。那怎麼才能遮蔽原型鏈上Symbol.hasInstance 方法， 使用Object.defineProperty 方式進行賦值

Object.defineProperty(Person, Symbol.hasInstance, {
    value: function(value) {
        return false;
    }
})

　　這時候 console.log 就返回false了。

　　2， Symbol.isConcatSpreadable

　　看字面意思是，concat 的時候是否可以spreadable. 這個Symbol 來自於數組的concat 方法，當一個數組去concat 另一個數組的時候，它會把另一個數組的元素一個一個都取出來，添加到第一個數組的後面，

let arr1 = [1, 2];
let arr2 = arr1.concat([3, 4]);
console.log(arr2) // [1, 2, 3, 4]

　　可是當一個數組去concat 一個字符串的時候，它直接把字符串做爲一個總體放到了數組的後面

let arr1 = [1, 2];
let arr2 = arr1.concat("string");
console.log(arr2) // [1, 2, 'string']

　　有沒有看到區別？ 數組的話，concat 方法對數組進行了分割（spread）, 而對於字符串，則沒有， 爲何呢? js 就是這麼規定的，數組能自動分割成一個一個元素，而其餘類型不能。這也是Symbol.isConcatSpreadable 出現的緣由， 它做爲對象的屬性進行使用，若是值是true 就表示，若是被concat 的話，這個對象能夠像數組同樣，被分割, false 則表示不能進行分割了。固然這個對象也有必定的要求，它有一個length 屬性，且屬性是數值類型， 也就是咱們所說的類數組 對象。 被分割，就是表示這個對象的屬性值能夠一個一個取出來。

let arr1 = [1, 2];
let obj = {
    0: 3,
    1: 4,
    length: 2,
    [Symbol.isConcatSpreadable]: true
}
console.log(arr1.concat(obj)) // [1, 2, 3, 4]

 　　3, Symbol.match, Symbol.search, Symbol.replace, Sybmol.split

　　　字符串有四個方法，match, search, replace, split, 能夠接受正則表達式，而後對匹配的字符進行操做，如今咱們可使用對象對正則表達式進行模擬，也就是說，字符串的這四個方法在調用時，能夠接受一個對象。怎麼用對象來模擬正則表達式呢，就是Symol 屬性了。很顯然，這四個屬性必須是一個函數，要否則，他們沒有辦法對字符串進行操做，函數呢確定有一個參數，就是調用方法的字符串，函數中只有獲取到字符串，才能對這個字符串進行修改。

　　Symbol.match 屬性就是模擬的 match 方法， 接受一個 參數，匹配成功返回匹配的數組，匹配失敗返回null

　　Symbol.search屬性模擬的就是search, 也是接受一個參數，查找到就返回索引，找不到，就返回-1

　　Symbol.replace 屬性要接受兩個參數，一個是操做的字符串，一個是替換的字符串, 返回替換後字符串

　　Symbol.split  屬性接受一個參數， 返回一個分割後的數組

let obj = {
    [Symbol.match]: function(value) {
        console.log(value);
        return value.length === 10 ? [value.substring(0, 10)]: null;
    },
    [Symbol.replace]: function(value, replacement) {
        return value.length === 10 ? replacement + value.substring(2) : value;
    },
    [Symbol.search]: function(value) {
        return value.length === 10 ?  0 : -1
    },
    [Symbol.split]: function(value) {
        return value.length === 10 ? ["", ""] : [value]
    }
}

　　能夠聲明字符串來調用match, search, split 和replace 方法，它們接受的參數就是obj 對象，調用mactch 方法時，就是調用的obj 對象上的Symbol.match 方法， 相對應的, search 方法就是調用Symbol.search 方法，split， replace 對應地就是Symbol.split 和Symbol.replace.

let message1 = "Hello world"; // 11 個字符
let message2 = "Hello John"; // 10 個字符
message1.match(obj); // null
message2.match(obj); ["hello json"]

message1.replace(obj, 2) // replace 接受兩個參數，第二個是replacement 

　　其實看一下obj 對象，它實際上就是模擬的正則表達式/^.{10}$/

　　4 Symbol.toPrimitive

　　toPrimitive 就是轉化成原始類型。在Js 中，引用類型object 是能夠轉化成原始類型的， 不是調用valueOf()， 就是調用toString() 方法，但具體返回什麼值，咱們就沒法控制了，是js 內部幫咱們作的。如今好了，有了Symbol.toPrimitive， 咱們就能夠規定當引用類型轉化爲基本類型的時候，它返回的是什麼數據。Symbol.toPrimitive 它是一個函數，定義在對象的原型上，其次它要接受一個參數，hint,  有三個取值，「number「, 「string「, 「default「,  "number" 就表示要轉化成數字，咱們就要返回數字，「string「 表示轉化成字符串，就要返回字符串，"default" 有點奇怪，返回字符串或數字均可以。不過，這裏要注意是hint 不是咱們本身傳遞過去的，而是js 內部根據某些操做符來判斷是哪一個hint , 傳遞到 Symbol.toPrimitive 函數中的。好比除法，確定是數字才能相除，js 內部把hint 置爲了"number", 你可能很好奇，何時觸發hint 爲"default" 呢？ 有三種狀況： ==操做符， +操做符， 給Date() 函數一個傳參

　　Symbol.toPrimitive 定義到對象原型上的，因此咱們要使用函數的構造方式調用的方法或使用ES6 中的類建立對象

function Temperature(degrees) {
    this.degrees = degrees;
}
Temperature.prototype[Symbol.toPrimitive] = function (hint) {
    switch (hint) {
        case "string":
            return this.degrees + "\u00b0";
        case "number":
            return this.degrees;
        case "default":
            return this.degrees + " degrees";
    }
}

var freezing = new Temperature(32);
console.log(freezing + "!"); // + 操做符調用的是"default", "32 degrees!"
console.log(freezing / 2); // 16
console.log(String(freezing)); // "32°"

 　　5, Symbol.toStringTag

　　  當一個值的type 爲object 的時候，它內部有一個[[class]] 屬性，表示這個值是什麼類型。怎麼獲取到這個[[class]] 呢，借用Object.prototype.toString(). 

let obj = {
    name: 'sam'
}
console.log(Object.prototype.toString(obj)) // '[object Object]'

　　obj內部的class 爲"Object", 沒有問題。可是當咱們使用構造函數的方式建立對象，它仍是返回'[object Object]' ，就感受有點彆扭，以下所示

function Person() {
    this.name = "sam";
}

console.log(Object.prototype.toString(new Person()));

　　可不可返回Person 類型，這就是Sybmol.toStirngTag 的來源，咱們能夠把它定義在構造函數的原型上，值字符串，就是定義生成對象的內部[[class]]

function Person() {
    this.name = "sam";
}

Person.prototype[Symbol.toStringTag] = "Person";
console.log(Object.prototype.toString(new Person())); '[object Person]'

　　能夠看到返回了''[object Person]', 可是如今你再調用一下toString()  方法， 它也是返回'[object Person] '有點 不太好，不過咱們能夠從新定義toString() 方法　

function Person() {
    this.name = "sam";
}

Person.prototype[Symbol.toStringTag] = "Person";
Person.prototype.toString = function() {
    return this.name;
}
console.log(Object.prototype.toString(new Person())); '[object Person]'
console.log(new Person().toString()) // sam

　　完美了