ES6学习笔记3---Symbol
ES6引入Symbol的原因:防止属性名的冲突(ES5的对象属性名都是字符串,容易造成属性名的冲突)。
ES6引入一种新的原始数据类型:Symbol,表示独一无二的值。它是javascript语言的第七种数据类型,前六种是:Undefined
、Null
、Boolean
、String
、Number
、Object
。
Symbol值是通过Symbol
函数生成的。
let s = Symbol();typeof s //"symbol"
注:Symbol函数前不能使用new命令,否则会报错。报错的原因就是:生成的Symbol是一个原始类型的值,而不是对象,所以不能添加属性。它是一种类似于字符串的数据类型。
Symbol
函数可以接受一个字符串作为参数,表示对Symbol实例的描述,主要是为了在控制台显示,或者转为字符串时,比较容易区分。
var s1 = Symbol('foo');var s2 = Symbol('bar');s1 // Symbol(foo)s2 // Symbol(bar)s1.toString() // "Symbol(foo)"s2.toString() // "Symbol(bar)"
注:Symbol函数的参数只是表示对当前Symbol值的描述,因此相同参数的Symbol函数的返回值是不相等的。
// 没有参数的情况var s1 = Symbol();var s2 = Symbol();s1 === s2 // false// 有参数的情况var s1 = Symbol("foo");var s2 = Symbol("foo");s1 === s2 // false
Symbol值不能与其他类型的值进行运算。
var sym = Symbol('My symbol');"your symbol is " + sym;// Error: Cannot convert a Symbol value to a string
但是Symbol值可以转为字符串。
var sym = Symbol('My symbol');String(sym) // 'Symbol(My symbol)'sym.toString() // 'Symbol(My symbol)'
2、作为属性名的Symbol
由于每一个Symbol值都是不相等的,这意味着Symbol值可以作为标识符,用于对象的属性名,就能保证不会出现同名的属性。这对于一个对象由多个模块构成的情况非常有用,能防止某一个键被不小心改写或覆盖。
var mySymbol = Symbol();// 第一种写法var a = {};a[mySymbol] = 'Hello!';// 第二种写法var a = { [mySymbol]: 'Hello!'};// 第三种写法var a = {};Object.defineProperty(a, mySymbol, { value: 'Hello!' });// 以上写法都得到同样结果a[mySymbol] // "Hello!"
Object.defineProperty
用来将对象的属性名指定为一个Symbol值。
注: Symbol值作为对象属性名时,不能用点运算符。
var mySymbol = Symbol();var a = {};a.mySymbol = 'Hello!';a[mySymbol] // undefineda['mySymbol'] // "Hello!"
上面代码中,因为点运算符后面总是字符串,所以不会读取mySymbol作为标识名所指代的那个值,导致a的属性名实际上是一个字符串,而不是一个Symbol值。
同理,在对象的内部,使用Symbol值定义属性时,Symbol值必须放在方括号之中。
let s = Symbol();let obj = { [s]: function (arg) { ... }};//等同于let obj = { [s](arg) { ... }};obj[s](123);
上面代码中,如果s不放在方括号中,该属性的键名就是字符串s,而不是s所代表的那个Symbol值。
Symbol类型还可以定义一组常量,使这组常量的值不想等。
var log = {};log.levels = { DEBUG: Symbol('debug'), INFO: Symbol('info'), WARN: Symbol('warn'),};console.log(log.levels.DEBUG, 'debug message');//Symbol(debug) 'debug message'console.log(log.levels.INFO, 'info message');//Symbol(info) 'info message'
需要注意的是:Symbol值作为属性名时,该属性还是公开属性,不是私有属性。
3、属性名的遍历
Symbol作为属性名,该属性不会出现在for...in
、for...of
循环中,也不会被Object.keys()
、Object.getOwnPropertyNames()
返回。但是,它也不是私有属性,有一个Object.getOwnPropertySymbols
方法,可以获取指定对象的所有Symbol属性名。
注:这里涉及到两个对象方法,它们的作用是:
Object.getOwnPropertyNames
:获取所有的属性名,不包括prototy中的属性,返回一个数组。
var o = Object.create({ "say": function () { alert(this.name); }, "name":"Byron"});Object.defineProperties(o, { 'age': { value: 24, writable: true, enumerable: true, configurable: true }, 'sex': { value: 'male', writable: false, enumerable: false, configurable: false }});console.log(o); //结果如下图console.log(Object.getOwnPropertyNames(o));//["age", "sex"]
上面代码console.log(o)的结果
从上面的例子中可以看到prototype中的name属性没有获取到。
Object.keys()
和getOwnPropertyNames
方法类似,但是获取所有的可枚举的属性,返回一个数组。
console.log(Object.keys(o)); //["age"]
Object.getOwnPropertySymbols
方法返回一个数组,成员是当前对象的所有用作属性名的Symbol值。
var obj = {};var foo = Symbol("foo");Object.defineProperty(obj, foo, { value: "foobar",});for (var i in obj) { console.log(i); // 无输出 //但是直接在最新版本的chrome里却是输出了{Symbol(foo): "foobar"}}Object.getOwnPropertyNames(obj)// []Object.getOwnPropertySymbols(obj)// [Symbol(foo)]
有一个新的APIReflect.ownKeys
方法可以返回所有类型的键名,包括常规的和Symbol。
let obj = { [Symbol('my_key')]: 1, enum: 2, nonEnum: 3};Reflect.ownKeys(obj)// [ 'enum', 'nonEnum', Symbol(my_key)]
由于以Symbol值作为名称的属性,不会被常规方法遍历得到。我们可以利用这个特性,为对象定义一些非私有的、但又希望只用于内部的方法。
var size = Symbol('size');class Collection { constructor() { this[size] = 0; } add(item) { this[this[size]] = item; this[size]++; } static sizeOf(instance) { return instance[size]; }}var x = new Collection();Collection.sizeOf(x) // 0x.add('foo');Collection.sizeOf(x) // 1Object.keys(x) // ['0']Object.getOwnPropertyNames(x) // ['0']Object.getOwnPropertySymbols(x) // [Symbol(size)]
上面代码中,对象x的size属性是一个Symbol值,所以Object.keys(x)
、Object.getOwnPropertyNames(x)
都无法获取它。这就造成了一种非私有的内部方法的效果。
4、Symbol.for(),Symbol.keyFor()Symbol.for
方法:接受一个字符串作为参数,并且创建的Symbol值是全局的,如果我们已经有一个Symbol值了,并且想重新使用,那么就可以利用这个方法来获取。
由于Symbol.for
创建的Symbol值是全局的,所以可以在不同的iframe和service worker中取到同一个值,例如:
iframe = document.createElement('iframe');iframe.src = String(window.location);document.body.appendChild(iframe);iframe.contentWindow.Symbol.for('foo') === Symbol.for('foo')// true
Symbol.for
的工作原理就是:搜索有没有以该参数作为名称的Symbol值,如果有,就返回这个Symbol值,否则就新建并返回一个以该字符串为名称的Symbol值。
var s1 = Symbol.for('foo');var s2 = Symbol.for('foo');s1 === s2 // true
下面我们来对比一下:Symbol.for()
与 Symbol()
:
相同点:都会生成新的Symbol。
区别:
Item | 全局搜索 | 每次调用返回一个新的Symbol值 |
---|---|---|
Symbol.for() | 是 | 会先检测给定的key是否存在,如果不存在则创建新的Symbol值 |
Symbol() | 否 | 是 |
Symbol.for("bar") === Symbol.for("bar")// trueSymbol("bar") === Symbol("bar")// false
Symbol.keyFor
方法:返回一个已登记的Symbol值的key。
var s1 = Symbol.for("foo");Symbol.keyFor(s1) // "foo"var s2 = Symbol("foo");Symbol.keyFor(s2) // undefined
5、内置的Symbol值
除了自定义的Symbol值外,ES6还提供了11个内置的Symbol值,它们都是对象的属性,指向语言内部使用的方法。
(1)、Symbol.hasInstance
该对象使用instanceof
运算符时,会调用这个方法,判断该对象是否为某个构造函数的实例。
比如:foo instanceof Foo
在语言内部,实际调用的是Foo[Symbol.hasInstance](foo)
。
class MyClass { [Symbol.hasInstance](foo) { return foo instanceof Array; } //对这一段代码不是很理解}var o = new MyClass();o instanceof Array // falseo instanceof MyClass // true
instanceof
运算符可以用来判断某个构造函数的prototype
属性是否存在另外一个要检测对象的原型链上。用法:
object instanceof constructor
参数:object
:要检测的对象constructor
:某个构造函数function C(){} //定义构造函数function D(){}var o = new C();o instanceof C; //true,因为:Object.getPrototypeOf(o) === C.prototypeo instanceof D; // false,因为D.prototype不在o的原型链上o instanceof Object; // true,因为Object.prototype.isPrototypeOf(o)返回trueC.prototype instanceof Object // true,同上C.prototype = {};var o2 = new C();o2 instanceof C; // trueo instanceof C; // false,C.prototype指向了一个空对象,这个空对象不在o的原型链上.D.prototype = new C();var o3 = new D();o3 instanceof D; // trueo3 instanceof C; // true
(2)、Symbol.isConcatSpreadable
对象的Symbol.isConcatSpreadable
属性等于一个布尔值,表示该对象使用Array.prototype.concat()
时,属性值为true即为可以展开,false则不允许展开。
let arr1 = ['c', 'd'];['a', 'b'].concat(arr1, 'e') // ['a', 'b', 'c', 'd', 'e']let arr2 = ['c', 'd'];arr2[Symbol.isConcatSpreadable] = false;['a', 'b'].concat(arr2, 'e') // ['a', 'b', ['c','d'], 'e'] 我执行的结果表示这个属性没有起作用
类似数组的对象,它的Symbol.isConcatSpreadable
属性默认为false,必须手动打开。
let obj = {length: 2, 0: 'c', 1: 'd'};['a', 'b'].concat(obj, 'e') // ['a', 'b', obj, 'e']obj[Symbol.isConcatSpreadable] = true;['a', 'b'].concat(obj, 'e') // ['a', 'b', 'c', 'd', 'e'] 我执行的结果依旧表示这个属性没有起作用,请大神赐教。
对于一个类来说,Symbol.isConcatSpreadable
属性必须写成一个返回布尔值的方法。
class A1 extends Array { [Symbol.isConcatSpreadable]() { return true; }}class A2 extends Array { [Symbol.isConcatSpreadable]() { return false; }}let a1 = new A1();a1[0] = 3;a1[1] = 4;let a2 = new A2();a2[0] = 5;a2[1] = 6;[1, 2].concat(a1).concat(a2)// [1, 2, 3, 4, [5, 6]]// 我的执行结果:[ 1, 2, A1 { '0': 3, '1': 4 }, A2 { '0': 5, '1': 6 } ]
(3)、Symbol.species
该对象作为构造函数创造实例时,会调用这个方法。即如果this.constructor[Symbol.species]
存在,就会使用这个属性作为构造函数,来创造新的实例对象。
(4)、Symbol.match
当执行str.match(myObject)
时,在一个类里如果该属性存在,则会调用以他命名的方法,返回该方法的返回值。
String.prototype.match(regexp)// 等同于regexp[Symbol.match](this)
class MyMatcher { [Symbol.match](string) { return 'hello world'.indexOf(string); }}'e'.match(new MyMatcher()) // 1
上面代码,'e'.match(new MyMatcher())
执行后,Symbol.match
方法被调用,所以会返回字母e的位置时1。
(5)、Symbol.replace
当该对象被String.prototype.replace
方法调用时,会返回该方法的返回值。
String.prototype.replace(searchValue, replaceValue)// 等同于searchValue[Symbol.replace](this, replaceValue)
class MyReplace{ constructor(val1,val2){ this.val1 = val1; this.val2 = val2; } [Symbol.replace](string){ return string.replace(new RegExp(this.val1),this.val2); }}'hello world'.replace(new MyReplace('world','jumei')); // hello jumei
(6)、Symbol.search
当该对象被String.prototype.search
方法调用时,会返回该方法的返回值。
String.prototype.search(regexp)// 等同于regexp[Symbol.search](this)
class MySearch { constructor(value) { this.value = value; } [Symbol.search](string) { return string.indexOf(this.value); }}'foobar'.search(new MySearch('foo')) // 0
(7)、Symbol.split
当该对象被String.prototype.split
方法调用时,会返回该方法的返回值。
String.prototype.split(separator, limit)// 等同于separator[Symbol.split](this, limit)
class MySplit{ constructor(val1,val2){ this.val1 = val1; this.val2 = val2; } [Symbol.split](string){ return string.split(this.val1,this.val2); }}'How are you ?'.split(new MySplit(" ",3));//[ 'How', 'are', 'you' ]
(8)、Symbol.iterator
对象的Symbol.iterator
属性,指向该对象的默认遍历器方法,即该对象进行for...of
循环时,会调用这个方法,返回该对象的默认遍历器,详细介绍参见《Iterator和for...of循环》一章。
class Collection { *[Symbol.iterator]() { let i = 0; while(this[i] !== undefined) { yield this[i]; ++i; } }}let myCollection = new Collection();myCollection[0] = 1;myCollection[1] = 2;for(let value of myCollection) { console.log(value);}// 1// 2
(9)、Symbol.toPrimitive
该对象被转为原始类型的值时,会调用这个方法,返回该对象对应的原始类型值。
JavaScript中的原始类型包括数字,字符串和布尔值。
Symbol.toPrimitive
被调用时,会接受一个字符串参数,表示当前运算的模式,一共有三种模式。
Number:该场合需要转成数值
String:该场合需要转成字符串
Default:该场合可以转成数值,也可以转成字符串
let obj = { [Symbol.toPrimitive](hint) { switch (hint) { case 'number': return 123; case 'string': return 'str'; case 'default': return 'default'; default: throw new Error(); } }};2 * obj // 246 我的执行结果:NaN3 + obj // '3default' 我的执行结果:3[object Object]obj === 'default' // true 我的执行结果:falseString(obj) // 'str' 我的执行结果:[object Object]
看来这个属性现在或许还不支持吧,才造成我的运行结果是这样的。
(10)、Symbol.toStringTag
在该对象上面调用Object.prototype.toString
方法时,如果这个属性存在,它的返回值会出现在toString
方法返回的字符串之中,表示对象的类型。
也就是说,这个属性可以用来定制[object Object]
或[object Array]
中object后面的那个字符串。
({[Symbol.toStringTag]: 'Foo'}.toString())// "[object Foo]"//等同于class Collection { get [Symbol.toStringTag]() { return 'Foo'; }}var x = new Collection();Object.prototype.toString.call(x) // "[object Foo]"
ES6新增内置对象的Symbol.toStringTag
属性值如下。
JSON[Symbol.toStringTag]:'JSON'
Math[Symbol.toStringTag]:'Math'
Module对象M[Symbol.toStringTag]:'Module'
ArrayBuffer.prototype[Symbol.toStringTag]:'ArrayBuffer'
DataView.prototype[Symbol.toStringTag]:'DataView'
Map.prototype[Symbol.toStringTag]:'Map'
Promise.prototype[Symbol.toStringTag]:'Promise'
Set.prototype[Symbol.toStringTag]:'Set'
%TypedArray%.prototype[Symbol.toStringTag]:'Uint8Array'等
WeakMap.prototype[Symbol.toStringTag]:'WeakMap'
WeakSet.prototype[Symbol.toStringTag]:'WeakSet'
%MapIteratorPrototype%[Symbol.toStringTag]:'Map Iterator'
%SetIteratorPrototype%[Symbol.toStringTag]:'Set Iterator'
%StringIteratorPrototype%[Symbol.toStringTag]:'String Iterator'
Symbol.prototype[Symbol.toStringTag]:'Symbol'
Generator.prototype[Symbol.toStringTag]:'Generator'
GeneratorFunction.prototype[Symbol.toStringTag]:'GeneratorFunction'
(11)、Symbol.unscopables
该对象指定了使用with
关键字时,哪些属性会被with
环境排除。
Array.prototype[Symbol.unscopables]// {// copyWithin: true,// entries: true,// fill: true,// find: true,// findIndex: true,// keys: true// }Object.keys(Array.prototype[Symbol.unscopables])// ['copyWithin', 'entries', 'fill', 'find', 'findIndex', 'keys']
上面代码说明,数组有6个属性,会被with
命令排除。
// 没有unscopables时class MyClass { foo() { return 1; }}var foo = function () { return 2; };with (MyClass.prototype) { foo(); // 1}// 有unscopables时class MyClass { foo() { return 1; } get [Symbol.unscopables]() { return { foo: true }; }}var foo = function () { return 2; };with (MyClass.prototype) { foo(); // 2}