摘要：它是語言的第七種數(shù)據(jù)類型前六種是布爾值字符串?dāng)?shù)值對象。為了防止沖突這就是引入的原因。指向了這個內(nèi)部方法調(diào)用了返回對象的屬性等于一個布爾值，表示該對象使用時，是否可以展開。數(shù)組的默認(rèn)行為是可以展開返回對象的屬性，指向當(dāng)前對象的構(gòu)造函數(shù)。

基本抄了一次內(nèi)容,有很多只是知道其然并不知其所以然,不過也算是加深了一次印象,另外每段代碼我都有手動執(zhí)行過.

ES6引入了一種新的原始數(shù)據(jù)類型Symbol，表示獨一無二的值。

它是JavaScript語言的第七種數(shù)據(jù)類型,前六種是：Undefined、Null、布爾值（Boolean）、字符串（String）、數(shù)值（Number）、對象（Object）。
ES5的對象屬性名都是字符串，這容易造成屬性名的沖突。比如，你使用了一個他人提供的對象，但又想為這個對象添加新的方法（mixin模式），新方法的名字就有可能與現(xiàn)有方法產(chǎn)生沖突。為了防止沖突,這就是ES6引入Symbol的原因。

Symbol值通過Symbol函數(shù)生成。這就是說，對象的屬性名現(xiàn)在可以有兩種類型，一種是原來就有的字符串，另一種就是新增的Symbol類型。凡是屬性名屬于Symbol類型，就都是獨一無二的，可以保證不會與其他屬性名產(chǎn)生沖突。

let s = Symbol();
typeof s
// "symbol"

Symbol函數(shù)可以接受一個字符串作為參數(shù)，表示對Symbol實例的描述，主要是為了在控制臺顯示，或者轉(zhuǎn)為字符串時，比較容易區(qū)分。

var s1 = Symbol("foo");
var s2 = Symbol("bar");

s1 // Symbol(foo)
s2 // Symbol(bar)

s1.toString() // "Symbol(foo)"
s2.toString() // "Symbol(bar)"

Symbol值不能與其他類型的值進(jìn)行運(yùn)算(可以轉(zhuǎn)為布爾值,但不能運(yùn)算)

Symbol值作為對象屬性名時，不能用點運(yùn)算符。

var mySymbol = Symbol();

// 第一種寫法
var a = {};
a[mySymbol] = "Hello!";

// 第二種寫法
var a = {
//在對象內(nèi)部必須要使用方括號包裹Symbol屬性
  [mySymbol]: "Hello!"
};

// 第三種寫法
var a = {};
//Object.defineProperty(obj, prop(需定義或修改的屬性的名字), descriptor(將被定義或修改的屬性的描述符))
Object.defineProperty(a, mySymbol, { value: "Hello!" });

// 以上寫法都得到同樣結(jié)果
a[mySymbol] // "Hello!"

增強(qiáng)對象寫法

let s = Symbol();

let obj = {//跟下面一樣
  [s]: function (arg) { ... }//用方括號
};

obj[s](123);
//--------------------------
let obj = {
  //這是增強(qiáng)對象寫法
  [s](arg) { ... }
};

主要是為了保證常量不會相同

log.levels = {
  DEBUG: Symbol("debug"),//這里就是
  INFO: Symbol("info"),
  WARN: Symbol("warn")
};
log(log.levels.DEBUG, "debug message");
log(log.levels.INFO, "info message");

//--------------------------
const COLOR_RED    = Symbol(); //比較巧妙的設(shè)置為一個唯一的常量
const COLOR_GREEN  = Symbol();

function getComplement(color) {
  switch (color) {
    case COLOR_RED:
      return COLOR_GREEN;
    case COLOR_GREEN:
      return COLOR_RED;
    default:
      throw new Error("Undefined color");
    }
}

魔術(shù)字符串指的是，在代碼之中多次出現(xiàn)、與代碼形成強(qiáng)耦合的某一個具體的字符串或者數(shù)值。風(fēng)格良好的代碼，應(yīng)該盡量消除魔術(shù)字符串，該由含義清晰的變量代替。

function getArea(shape, options) {
  var area = 0;

  switch (shape) {
    case "Triangle": // 魔術(shù)字符串
      area = .5 * options.width * options.height;
      break;
    /* ... more code ... */
  }

  return area;
}

getArea("Triangle", { width: 100, height: 100 }); // 魔術(shù)字符串

改成這樣

var shapeType = {
  triangle: "Triangle"http://這樣消除了強(qiáng)耦合
};
//更直接的方式使用Symbol保持唯一
const shapeType = {
  triangle: Symbol()
};
//-------------------------
function getArea(shape, options) {
  var area = 0;
  switch (shape) {
    case shapeType.triangle:
      area = .5 * options.width * options.height;
      break;
  }
  return area;
}

getArea(shapeType.triangle, { width: 100, height: 100 });

Symbol 作為屬性名，該屬性不會出現(xiàn)在for...in、for...of循環(huán)中，也不會被Object.keys()、Object.getOwnPropertyNames()、JSON.stringify()返回。但是，它也不是私有屬性，有一個Object.getOwnPropertySymbols方法，可以獲取指定對象的所有 Symbol 屬性名。

Object.getOwnPropertySymbols方法返回一個數(shù)組，成員是當(dāng)前對象的所有用作屬性名的 Symbol 值。

var obj = {};
var a = Symbol("a");
var b = Symbol("b");

obj[a] = "Hello";
obj[b] = "World";

var objectSymbols = Object.getOwnPropertySymbols(obj);

console.log(objectSymbols)
// 返回[Symbol(a), Symbol(b)]

for (var i in obj) {//并不能使用這個方法獲取Symbol
    console.log(i); // 無輸出
}

console.log(Object.getOwnPropertyNames(obj))//并不能使用這個方法獲取Symbol
// 返回[]

Reflect.ownKeys方法可以返回所有類型的鍵名，包括常規(guī)鍵名和 Symbol 鍵名。

let obj = {
    [Symbol("my_key")]: 1,
    enum: 2,
    nonEnum: 3
};

console.log(Reflect.ownKeys(obj))
// 返回 ["enum", "nonEnum", Symbol(my_key)]

Symbol.for方法,它接受一個字符串作為參數(shù)，然后搜索有沒有以該參數(shù)作為名稱的Symbol值。如果有，就返回這個Symbol值，否則就新建并返回一個以該字符串為名稱的Symbol值。

var s1 = Symbol.for("foo");
var s2 = Symbol.for("foo");

console.log(s1 === s2) // true


console.log(Symbol.for("bar") === Symbol.for("bar"))
// true

console.log(Symbol("bar") === Symbol("bar"))
// false

Symbol.for()與Symbol()這兩種寫法，都會生成新的Symbol。它們的區(qū)別是，前者會被登記在全局環(huán)境中供搜索，后者不會。Symbol.for()不會每次調(diào)用就返回一個新的 Symbol 類型的值，而是會先檢查給定的key是否已經(jīng)存在，如果不存在才會新建一個值。

Singleton模式指的是調(diào)用一個類，任何時候返回的都是同一個實例。

對于Node來說，模塊文件可以看成是一個類。怎么保證每次執(zhí)行這個模塊文件，返回的都是同一個實例呢？

把實例放到頂層對象global

// mod.js
function A() {
    this.foo = "hello";
}

if (!global._foo) {
    global._foo = new A();
}

module.exports = global._foo;

變量a任何時候加載的都是A的同一個實例。

var a = require("./mod.js");
console.log(a.foo);

但是，這里有一個問題，全局變量global._foo是可寫的，任何文件都可以修改。

var a = require("./mod.js");
global._foo = 123;//修改了全局變量global._foo

上面的代碼，會使得別的腳本加載mod.js都失真。

為了防止這種情況出現(xiàn)，我們就可以使用Symbol。

// mod.js
const FOO_KEY = Symbol.for("foo"); //Symbol.for生成是為了有些時候可以重新使用這個Symbol值

function A() {
  this.foo = "hello";
}

if (!global[FOO_KEY]) {
  global[FOO_KEY] = new A();
}

module.exports = global[FOO_KEY];

上面代碼中，可以保證global[FOO_KEY]不會被無意間覆蓋，但還是可以被改寫。

var a = require("./mod.js");
global[Symbol.for("foo")] = 123;

如果鍵名使用Symbol方法生成，那么外部將無法引用這個值，當(dāng)然也就無法改寫。

// mod.js
const FOO_KEY = Symbol("foo");//保證每次都是唯一,因為Symbol生成

// 后面代碼相同 ……

上面代碼將導(dǎo)致其他腳本都無法引用FOO_KEY。但這樣也有一個問題，就是如果多次執(zhí)行這個腳本，每次得到的FOO_KEY都是不一樣的。雖然Node會將腳本的執(zhí)行結(jié)果緩存，一般情況下，不會多次執(zhí)行同一個腳本，但是用戶可以手動清除緩存，所以也不是完全可靠。

對象的Symbol.hasInstance屬性，指向一個內(nèi)部方法。當(dāng)其他對象使用instanceof運(yùn)算符，判斷是否為該對象的實例時，會調(diào)用這個方法。比如，foo instanceof Foo在語言內(nèi)部，實際調(diào)用的是Foo[Symbol.hasInstance](foo)。

class MyClass {
    [Symbol.hasInstance](foo) {//instanceof指向了這個內(nèi)部方法
        return foo instanceof Array;
    }
}
//調(diào)用了instanceof
console.log([1, 2, 3] instanceof new MyClass()) //返回 true

對象的Symbol.isConcatSpreadable屬性等于一個布爾值，表示該對象使用Array.prototype.concat()時，是否可以展開。

數(shù)組的默認(rèn)行為是可以展開

let arr1 = ["c", "d"];
console.log(["a", "b"].concat(arr1, "e")) // ["a", "b", "c", "d", "e"]
console.log(arr1[Symbol.isConcatSpreadable]) // undefined

let arr2 = ["c", "d"];
arr2[Symbol.isConcatSpreadable] = false;
console.log(arr2[Symbol.isConcatSpreadable]);//返回false
console.log(["a", "b"].concat(arr2, "e")) // ["a", "b", ["c","d"], "e"]

對象的Symbol.species屬性，指向當(dāng)前對象的構(gòu)造函數(shù)。創(chuàng)造實例時，默認(rèn)會調(diào)用這個方法，即使用這個屬性返回的函數(shù)當(dāng)作構(gòu)造函數(shù)，來創(chuàng)造新的實例對象。

class MyArray extends Array {
    // 覆蓋父類 Array 的構(gòu)造函數(shù)
    //所以他是由當(dāng)前類MyArray創(chuàng)建的
    static get [Symbol.species]() { return this; }//靜態(tài)方法并且要用get來獲取Symbol.species屬性
}
var a = new MyArray(1,2,3);
var mapped = a.map(x => x * x);

//雖然是由MyArray來創(chuàng)建的,但是因為他也是集成自Array,所以都是true
console.log(mapped instanceof MyArray) // true
console.log(mapped instanceof Array) // true

//如果改成了返回Array的話,那么結(jié)果的是Array為true
 static get [Symbol.species]() { return Array; }

對象的Symbol.match屬性，指向一個函數(shù)。當(dāng)執(zhí)行str.match(myObject)時，如果該屬性存在，會調(diào)用它，返回該方法的返回值。

String.prototype.match(regexp)
// 等同于
regexp[Symbol.match](this)

class MyMatcher {
  [Symbol.match](string) {
    return "hello world".indexOf(string);
  }
}

"e".match(new MyMatcher()) // 1(從0開始計算第一位,1是第二位)

對象的Symbol.replace屬性，指向一個方法，當(dāng)該對象被String.prototype.replace方法調(diào)用時，會返回該方法的返回值。

String.prototype.replace(searchValue, replaceValue)
// 等同于
searchValue[Symbol.replace](this, replaceValue)
下面是一個例子。

const obj = {};
obj[Symbol.replace] = (...s) => console.log(s);

"Hello".replace(obj, "World") // ["Hello", "World"]

Symbol.replace方法會收到兩個參數(shù)，第一個參數(shù)是replace方法正在作用的對象，上面例子是Hello，第二個參數(shù)是替換后的值，上面例子是World。

對象的Symbol.search屬性，指向一個方法，當(dāng)該對象被String.prototype.search方法調(diào)用時，會返回該方法的返回值。

String.prototype.search(regexp)
// 等同于
regexp[Symbol.search](this)

class MySearch {
    constructor(value) {
        this.value = value;
    }
    [Symbol.search](string) {
        return string.indexOf(this.value);
    }
}
console.log("foobar".search(new MySearch("foo"))) // 0

對象的Symbol.split屬性，指向一個方法，當(dāng)該對象被String.prototype.split方法調(diào)用時，會返回該方法的返回值。

String.prototype.split(separator, limit)
// 等同于
separator[Symbol.split](this, limit)

class MySplitter {
    constructor(value) {
        this.value = value;
    }
    [Symbol.split](string) {
        var index = string.indexOf(this.value);
        if (index === -1) {
            return string;
        }
        return [
            string.substr(0, index),
            string.substr(index + this.value.length)
        ];
    }
}

console.log("foobar".split(new MySplitter("foo")))
// ["", "bar"]

console.log("foobar".split(new MySplitter("bar")))
// ["foo", ""]

console.log("foobar".split(new MySplitter("baz")))
// "foobar"

上面方法使用Symbol.split方法，重新定義了字符串對象的split方法的行為

對象的Symbol.iterator屬性，指向該對象的默認(rèn)遍歷器方法。

var myIterable = {};
myIterable[Symbol.iterator] = function* () {
  yield 1;
  yield 2;
  yield 3;
};

[...myIterable] // [1, 2, 3]

對象進(jìn)行for...of循環(huán)時，會調(diào)用Symbol.iterator方法，返回該對象的默認(rèn)遍歷器，

對象的Symbol.toPrimitive屬性，指向一個方法。該對象被轉(zhuǎn)為原始類型的值時，會調(diào)用這個方法，返回該對象對應(yīng)的原始類型值。

Symbol.toPrimitive被調(diào)用時，會接受一個字符串參數(shù)，表示當(dāng)前運(yùn)算的模式，一共有三種模式。

Number：該場合需要轉(zhuǎn)成數(shù)值
String：該場合需要轉(zhuǎn)成字符串
Default：該場合可以轉(zhuǎn)成數(shù)值，也可以轉(zhuǎn)成字符串

let obj = {
    [Symbol.toPrimitive](hint) {
        switch (hint) {
            case "number":
                return 123;
            case "string":
                return "str";
            case "default":
                return "default";
            default:
                throw new Error();
        }
    }
};

console.log(2 * obj) // 246
console.log(3 + obj) // "3default"
console.log(obj == "default") // true
console.log(String(obj)) // "str"

對象的Symbol.toStringTag屬性，指向一個方法。在該對象上面調(diào)用Object.prototype.toString方法時，如果這個屬性存在，它的返回值會出現(xiàn)在toString方法返回的字符串之中，表示對象的類型。也就是說，這個屬性可以用來定制[object Object]或[object Array]中object后面的那個字符串。

// 例一
console.log(({[Symbol.toStringTag]: "Foo"}.toString()))
// "[object Foo]"

// 例二
class Collection {
    get [Symbol.toStringTag]() {
        return "xxx";
    }
}
var x = new Collection();
console.log(Object.prototype.toString.call(x)) // "[object xxx]"

ES6新增內(nèi)置對象的Symbol.toStringTag屬性值如下。

JSON[Symbol.toStringTag]："JSON"
Math[Symbol.toStringTag]："Math"
Module對象M[Symbol.toStringTag]："Module"
ArrayBuffer.prototype[Symbol.toStringTag]："ArrayBuffer"
DataView.prototype[Symbol.toStringTag]："DataView"
Map.prototype[Symbol.toStringTag]："Map"
Promise.prototype[Symbol.toStringTag]："Promise"
Set.prototype[Symbol.toStringTag]："Set"
%TypedArray%.prototype[Symbol.toStringTag]："Uint8Array"等
WeakMap.prototype[Symbol.toStringTag]："WeakMap"
WeakSet.prototype[Symbol.toStringTag]："WeakSet"
%MapIteratorPrototype%[Symbol.toStringTag]："Map Iterator"
%SetIteratorPrototype%[Symbol.toStringTag]："Set Iterator"
%StringIteratorPrototype%[Symbol.toStringTag]："String Iterator"
Symbol.prototype[Symbol.toStringTag]："Symbol"
Generator.prototype[Symbol.toStringTag]："Generator"
GeneratorFunction.prototype[Symbol.toStringTag]："GeneratorFunction"

參考引用:

Symbol