Symbol類型沒有字面量表現形式，要想獲得一個Symbol類型的值， 需要調用全局函數Symbol()
let firstSymbol = Symbol();
調用的時候，也可以給函數傳一個字符串參數，用來描述這個symbol
let secondSymbol = Symbol('second symbol');
參數也僅僅起描述作用，只有顯示或隱式調用toString() ，比如console.log( secondSymbol)時，
console.log(secondSymbol) //Symbol(second symbol)
它才會顯示出來，有利於debugger，知道操作的是哪一個symbol，僅此而已，沒有太大的實際意義。
Symbol類型的值，最大的特點是唯一性，調用Symbol() 函數返回的值是唯一的。我們可以無數次地調用Symbol() 函數，但每一次調用返回的值都不一樣。
let firstSymbol = Symbol(); let secondSymbol = Symbol(); console.log(firstSymbol == secondSymbol) // false
帶上參數(相同的參數)調用也是如此
let firstSymbol = Symbol('firstSymbol'); let secondSymbol = Symbol('firstSymbol'); console.log(firstSymbol == secondSymbol) // false
let firstSymbol = Symbol(); let person = { [firstSymbol]: 'symbolName' } let dog = {}; dog[firstSymbol] = "sybolName"
獲取對象上的symbol 屬性，Object.getOwnPropertySymbols(), 返回一個包含所有symbol 屬性的數組，對象以前的方法，比如Object.keys() 不起作用
let firstSymbol = Symbol("firstSymbol"); let object = { [firstSymbol]: "12345" }; let symbols = Object.getOwnPropertySymbols(object); console.log(symbols.length); // 1 console.log(symbols[0]); // "Symbol(firstSymbol)" console.log(object[symbols[0]]); // "12345"
但是有時候，你不想要這種唯一性， 可能所有的對象都共用一個symbol 屬性， 這怎么辦？ 在一個文件js中，很好處理，所有的對象都使用這一個symbol 變量就可以了，但跨文件就不好處理了，尤其是提倡模塊化的今天，每一個文件都是一個模塊，都有自己的私有作用域。在這種情況下，就要使用共享symbol 了，創建symbol 變量的時候，使用Symbol.for() 方法，參數是一個字符串， 可以理解為共享標識key,
let uid = Symbol.for('uid');
當我們使用Symbol.for() 創建symbol 的時候，js 引擎會到全局symbol 注冊中心去查找這個symbol, 查找的依據是唯一的標識key(在這里是‘’uid‘’)，如果找到了，就直接返回找到的這個symbol，如果沒有找到，就創建一個新的symbol並返回，同時使用唯一的標識key把這個symbol注冊到全局注冊中心。這樣，以后再使用這個key 創建 symbol, 就會獲取到同一個symbol, 這就共享了。key值和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值看作一個類字符串，和字符串的使用方式一致，字符串能用的地方，symbol 基本都能用。需要注意一點，Symbol函數調用的時候，前面不要加new.
Symbol 實際的意義，還在於擴展了js語言，就是暴露js的一些內部方法(Exposing Internal Operations), 內部方法就是我們調用JS的API 時，內部是怎么實現的。為此， JS定義了一些有名的symbol (well-known symbols)， 這些symbols 都是增加到Symbol 對象上。
1， Symbol.hasInstance
instanceOf 方法，它右側只能是一個函數，實際上就是調用函數的Symbol.hasInstance 方法。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方法，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了。其實有了Symbol.hasInstance, instanceOf 的右側可以是任何對象，只要它定義了Symbol.hasInstance方法
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}$/。 string.method(pattern, arg) 就變成了pattern[symbol](string, arg)
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
當我們判斷一個值是什么類型的時候，可能用到過Object.prototype.toString().call()
Object.prototype.toString.call([]) // => "[object Array]"
但當使用這個方法來判斷自定義對象的時候，就不用那么好用了
function Person() { this.name = "sam"; } console.log(Object.prototype.toString(new Person())); //'[object Object]'
返回'[object Object]' , 可不可以返回Person 類型，這就是Sybmol.toStirngTag 的來源。在ES6中，Object.prototype.toString()會查找調用對象上的Sybmol.toStirngTag 方法，如果有，就使用這個方法的返回值
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
6, Symbol.species
ES6 提供了class和extends，可以很輕松地創建一個內置類型的子類，比如數組
class EZArray extends Array { get first() { return this[0]; } get last() { return this[this.length - 1]; } } let e = new EZArray(1, 2, 3); let f = e.map(x => x * x); e.last // => 3 f.last // => 9
數組的map(), concat() 等方法，也會返回一個數組，這就引發了一個問題，這個數組到底是子類型EZArray ，還是父類型Array？ES6規定返回的是子類型。它是怎么決定的呢？Array() 構造函數有一個Symbol.species方法，子類extends Array() 的時候，子類的構造函數也會繼承這個方法，當調用map方法返回數組的時候，也會調用這個方法。Symbol.species 方法呢，是只讀的，單純地返回this. 所以e.map 的時候，調用的是子類身上的Symbol.species, 返回的是子類。如果不想使用默認方式，想讓map 方法返回的是父類，就要定義Symbol.species 方法
class EZArray extends Array { static get [Symbol.species]() { return Array; } get first() { return this[0]; } get last() { return this[this.length-1]; } } let e = new EZArray(1,2,3); let f = e.map(x => x - 1); e.last // => 3 f.last // => undefined