ES6 新增基本数据类型Symbol

　　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

　　这种唯一性带来了一个好处，就是当我们想给一个对象添加新属性的时候，使用Symbol()函数返回的值作为属性名，完全不用担心会覆盖掉以前的属性，所以Symbol最常用的一个地方就是作为对象的属性名使用，避免了属性名的冲突。

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方法

let uint8 = {

    [Symbol.hasInstance](x) {

        return Number.isInteger(x) && x >= 0 && x <= 255;

    }

};

128 instanceof uint8 // => true

　　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