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
完美了