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

完美了