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]: ""
};
let symbols = Object.getOwnPropertySymbols(object);
console.log(symbols.length); //
console.log(symbols[]); // "Symbol(uid)"
console.log(object[symbols[]]); // "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 = [, ];
let arr2 = arr1.concat([, ]);
console.log(arr2) // [1, 2, 3, 4]

　　但是当一个数组去concat 一个字符串的时候，它直接把字符串作为一个整体放到了数组的后面

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

　　有没有看到区别？ 数组的话，concat 方法对数组进行了分割（spread）, 而对于字符串，则没有， 为什么呢? js 就是这么规定的，数组能自动分割成一个一个元素，而其他类型不能。这也是Symbol.isConcatSpreadable 出现的原因， 它作为对象的属性进行使用，如果值是true 就表示，如果被concat 的话，这个对象可以像数组一样，被分割, false 则表示不能进行分割了。当然这个对象也有一定的要求，它有一个length 属性，且属性是数值类型， 也就是我们所说的类数组 对象。 被分割，就是表示这个对象的属性值可以一个一个取出来。

let arr1 = [, ];
let obj = {
    : ,
    : ,
    length: ,
    [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 ===  ? [value.substring(, )]: null;
    },
    [Symbol.replace]: function(value, replacement) {
        return value.length ===  ? replacement + value.substring() : value;
    },
    [Symbol.search]: function(value) {
        return value.length ===  ?   : -
    },
    [Symbol.split]: function(value) {
        return value.length ===  ? ["", ""] : [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, ) // 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();
console.log(freezing + "!"); // + 操作符调用的是"default", "32 degrees!"
console.log(freezing / ); //
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

　　完美了