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]: "12345"
};
let symbols = Object.getOwnPropertySymbols(object);
console.log(symbols.length); // 1
console.log(symbols[0]); // "Symbol(uid)"
console.log(object[symbols[0]]); // "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 = [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}$/

　　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

　　  当一个值的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

　　完美了