摘要：通常，它做為一個(gè)偏功能性的標(biāo)記來表示，在全劇中它是唯一的。并且使用來生成，會在存入當(dāng)前全局上下文中一個(gè)結(jié)構(gòu)中，我們稱它為顧名思義，它是全局的，所以使用時(shí)我們需要謹(jǐn)慎，尤其是在大型項(xiàng)目中。

ES6中基礎(chǔ)類型增加到了7種，比上一個(gè)版本多了一個(gè)Symbol，貌似出現(xiàn)了很長時(shí)間，但卻因沒有使用場景，一直當(dāng)作一個(gè)概念層來理解它，我想，用它的最好的方式，還是要主動的去深入了解它吧，所以我從基礎(chǔ)部分和總結(jié)的實(shí)用場景來分析這個(gè)特性。已經(jīng)了解使用方法或者時(shí)間緊迫者可以從實(shí)用場景一節(jié)開始閱讀

首先，它給我的第一感覺就是ES6做出了很多釋放語言特性方面的改變，它能讓我們更加了解語言內(nèi)部機(jī)制，Symbol以對象的鍵值定義，比如

 let key = Symbol("test");  
 let obj = {};
 obj[key] = "alone";
 obj[key];  // "alone"

Symbol正如其名，表示一個(gè)唯一的標(biāo)示，以屬性的方式存在于對象當(dāng)中，它接收一個(gè)參數(shù)，沒有實(shí)質(zhì)的作用，只是為了做一個(gè)描述。以上我們通過直接量的方式來定義它，并且取值時(shí)，也需要使用key進(jìn)行讀取，如果出現(xiàn)跨作用域的情況，是不是就不能獲取了？

function sent(key){
    accept({[key]:"2018"})
}
function accept(obj) {
   obj[???] //我怎么拌？
}

以上兩個(gè)作用域中，如果不把key傳遞過來，是無法讀取的，一個(gè)屬性還好，但是如果多了，那么靠參數(shù)傳遞key是不現(xiàn)實(shí)的. 在這種情況下，我們可以使用 Symbol.for 來為它再添加一個(gè)標(biāo)示，它接受一個(gè)參數(shù)String{key}。通常，它做為一個(gè)偏功能性的標(biāo)記來表示，在全劇中它是唯一的。

function sent(key){
    return accept({[key]:"2018"},key)
}
function accept(obj,key) {
   console.log(Symbol.keyFor(key))  //CURRENT_YEAR
   return obj[Symbol.for(Symbol.keyFor(key))] //CURRENT_YEAR
}
sent(Symbol.for("CURRENT_YEAR"))

并且使用 Symbol.for 來生成，會在存入當(dāng)前全局上下文中一個(gè)結(jié)構(gòu)中，我們稱它為GlobalSymbolRegistry , 顧名思義，它是全局的，所以使用key時(shí)我們需要謹(jǐn)慎，尤其是在大型項(xiàng)目中。

需要還注意以下幾點(diǎn):

讀取它需要使用 getOwnPropertySymbols 方法，具體請參看MDN

Symbol() !== Symbol() but Symbol.for("t") === Symbol.for("t")

GlobalSymbolRegistry對象存在于當(dāng)前窗口進(jìn)程中，直到關(guān)閉窗口,才清除掉

目前的瀏覽器版本中把Symbol打印出來是字符串的格式，并沒有顯示具體的對象結(jié)構(gòu)，我們可以直接打印 Symbol，來查看對應(yīng)的prototype屬性以及內(nèi)部方法，所以 Symbol().__proto__ === Symbol.prototype

在使用 Symbol 做key值時(shí)，它經(jīng)歷了以下步驟

如果指向?qū)ο笫菦]有定義的則拋出類型錯誤

如果描述符為undefined則為""

把描述符轉(zhuǎn)換為String格式

生成唯一的key，并返回

最后一步，把這個(gè)key賦給對象，并以Symbol(des)的方式顯示，其內(nèi)部還是以key為準(zhǔn)，所以 Symbol() !== Symbol() ，即便他們看起來都是 字符串的"Symbol()"

所以這樣寫也是可以的，但是貌似沒有什么意義

var n = 1;
var key = Symbol("numer")
n[key] = ‘Symbol Number’

n[key]的時(shí)候把n隱式轉(zhuǎn)換成封裝對象，并為他添加Symbol，但并沒有辦法去通過封裝對象回訪這個(gè)Symbol

除了單純的用key以外，在Symbol類下還有一些有意思的方法，following :

為指向?qū)ο筇砑?iterator 接口，比如使用數(shù)組解構(gòu)或者使用for of，它接受一個(gè)generator函數(shù)

class IteratorExec {
    constructor(){ this.count = 1 }
    *[Symbol.iterator] = function* (){
        yield this.count++;
        yield this.count++;
        yield this.count++;
    }
 }
let obj = new IteratorExec()
[...obj] //[1,2,3]

通過添加iterator使用數(shù)據(jù)解構(gòu)，還可以使用for of

 let values = [];
 for (let value of obj) { values.push(value) }
 values;  //[1,2,3]

注：ES6中Map,Set,數(shù)組和添加了Iterator接口的對象，擁有Iterator接口.

這不是ES6中的特性，貌似放到了ES7中，可以提前意淫一下如下代碼:

for await (const line of readLines(filePath)) {
  console.log(line);
}

在對對象類型進(jìn)行轉(zhuǎn)換時(shí)，會進(jìn)行一次 toPrimitive,利用這個(gè)Symbol可以改變目標(biāo)對象的轉(zhuǎn)換規(guī)則，改變了以前的 "[object Object]"的固定形式

let obj = {
    [Symbol.toPrimitive](hint){
      switch(hint){
          case "number": return 5;
          case "string": return "string";
          case "default": return "default"    
      }
    }
}
obj+11 // "default11"
obj*2 // 10

這里需要注意+ Number操作是不屬于 "number" 的，其他正常，這樣就可以定義轉(zhuǎn)對象類型的轉(zhuǎn)換規(guī)則了。

在javascript一切皆為對象，而在每個(gè)對象中，都會有一個(gè)內(nèi)部屬性[[Class]]表示其對象類型，這在Symbol.toStringTag，中是可以修改的，也就是說 "[object Object]" 后邊的字符串是可自定義的

 let obj = {
    [Symbol.toStringTag]:"custom"
}
Object.prototype.toString(obj); // [object Object]
obj.toString();  //[object custom]

通常我們使用Object.prototype.toString讀取對象屬性，正是因?yàn)橄蚝蠹嫒?，?guī)范在對象自身的toString上實(shí)現(xiàn)了這種特性，而老式方法依舊使用。但是我們可以使用以下方式:

obj = {
    [Symbol.toStringTag]:"custom"
    get [Symbol.toStringTag](){
        return "custom"
    }
}
Object.prototype.toString.call(obj)

我們把obj傳入執(zhí)行toString,可以達(dá)到這種效果，可以預(yù)想es6中，Object.toString是受到上下文的影響的. 顯然，我們上面的兩個(gè)例子都是獲取的Object.prototype.toString 兩者有很大區(qū)別，只有它才能準(zhǔn)確轉(zhuǎn)換，如果你的toString不全等于它，那是無法轉(zhuǎn)換的，比如

 var n = new Number();
 n[Symbol.toStringTag] = 123;
 n.toString();  // “0” 

太幼稚了，太無聊了?，Number私有的toString是直接把[[PrimitiveValue]]轉(zhuǎn)換成了字符串，這里大家要千萬留心，不要誤認(rèn)為所有的對象添加了Symbol.toStringTag都可以改變，如果當(dāng)前對象不是純對象，那么你可以為此對象添加一個(gè) getter 返回對應(yīng)的類型，這樣外部在使用Object...call的時(shí)，會獲取自定的類型。所以，這需要外部配合使用，你添加getter，人家不call你也是沒辦法的。

另外Symbol暴露了幾種為原生對象定義了一些類型，比如

Math.toString();  //[object Math]

其他類型有 JSON, Promise, Map, TypedArray, DataView, ArrayBuffer, Genterator等等

const object1 = {
  property1: 42
};

object1[Symbol.unscopables] = {
  property1: true
};

with (object1) {
  console.log(property1);
}

這個(gè)功能我感覺可用性為0，基本不用，with就是據(jù)對禁止的.

對于 instance運(yùn)算符，為此操作添加一個(gè)鉤子，第一參數(shù)是instance的左值，我們可以返回true|false來定義運(yùn)算符的返回值

var obj1 = {
    [Symbol.hasInstance](instance){
        return Array.isArray(Array)
    }
}
class Array1 {
  static [Symbol.hasInstance](instance) {
    return Array.isArray(instance);
  }
}
[] instance obj1  //true
console.log([] instanceof Array1);  //true

表示[].concat是否可以展開，默認(rèn)是true.

let arr = [1,2];
arr.concat([3,4],5)  //[1,2,3,4,5]

arr[Symbol.isConcatSpreadable] = false;
arr.concat([3,4],5)  //[[1,2],3,4,5]

// 也可以把[3,4]提出來處理
let arr2 = [3,4]
arr2[Symbol.isConcatSpreadable] = false;
arr.concat(arr2,5); //[[1,2],[3,4],5]

只有在數(shù)組中這個(gè)symbol屬性為false，concat操作時(shí)，就不會去解構(gòu)。那么是不是意味著屬性設(shè)置為ture，沒有意義了？對于數(shù)組來說是的，因?yàn)樗J(rèn)就是true，可是對于類數(shù)組對象，它還有一個(gè)小功能:

// (續(xù))
arr.concat({length:2,0:3,1:4,[Symbol.isConcatSpreadable]:true}) //[1,2,3,4]

一些字符串的操作方法，一起都說了，大概都一個(gè)意思，就是接受一個(gè)對象，然后實(shí)現(xiàn)一個(gè)鉤子處理的函數(shù)，并返回其處理結(jié)果，它們都是可以接收正則的方法，在ES6之前，如果我們需要對字符串有比較復(fù)雜的操作基本上都是在方法外部的，必

class MyMatch {
    [Symbol.match](string){return string.indexOf("world") }
}

"hello world".match(new MyMatch()); //6

class MyReplace{
  [Symbol.replace](string) {
     return "def"
  }
}

"abcdef".replace(new MyReplace(),"xxx"); //"abcxxx"

class mySplit {
    [Symbol.split](val){
        return val.split("-");
    }
}

"123-123-123".split(new mySplit());  //["123","123","123"]

class MySearch {
    constructor(value) {
        this.value = value;
    }
    [Symbol.search](string) {
        return string.indexOf(this.value);
    }
}
var fooSearch = "foobar".search(new MySearch("foo"));  //0
var barSearch = "foobar".search(new MySearch("bar"));  //3
var bazSearch = "foobar".search(new MySearch("baz"));  //-1

可以通過Symbol實(shí)現(xiàn)以上的功能性方法，比如添加 Iterator 接口，讓對象隊(duì)友接口特性，實(shí)際開發(fā)中，我估計(jì)很少會用到，倒是覺得 sanycIterator 是未來的前景，目前還在草案階段

對于Symbol做為鍵值的作用，很尷尬，實(shí)際開發(fā)中，這個(gè)我也沒使用過，目前為止，只需要記住它有unique性，比如我們想要在一個(gè)對象中添加兩個(gè)一樣的key名，這種需求很不常見，

var firstPerson = Symbol("peter");
var secondPerson = Symbol("peter");
var persons = {[firstPerson]:"first", [secondPerson]:"pan"};

Symbol更多的是在使用和語言本身層面暴露更多的使用方式和特性(on Object type)，是的，它只以key的方式存在Object當(dāng)中，在一切皆為對象中，它為 Next ECMScript Standard 提供了更多的可能性擴(kuò)展性，這也是ES6中做的最大改變方面之一，雖不常用但我們還是要總結(jié)學(xué)習(xí)一下，以便在極端情況下應(yīng)變自如，如果有什么文章中沒有涉及到的點(diǎn)，歡迎補(bǔ)充! 注: 尤其是使用場景方面