ES6 Symbol

1. 概述

如果有一种机制，能够保证每个属性的名字都是独一无二的就好了，这样就能从根本上防止属性冲突。

Symbol值通过Symbol函数生成。因此，对象的属性可以有两种类型：①. 一种是原来就有的字符串；②. 一种是新增的Symbol类型。

Symbol函数前不能使用new命令，否则会报错。也就是说，由于Symbol值不是对象，所以不能添加属性。

Symbol函数可以接受一个字符串作为参数，表示对Symbol实例的描述。

注意：Symbol函数的参数只表示对当前Symbol值的描述，因此相同参数的Symbol函数的返回值是不相等的。、

//无参数的情况
var s1 = Symbol()
var s2 = Symbol()

s1 === s2 //false

//有参数的情况
var s1 = Symbol('foo')
var s2 = Symbol('foo')
s1 === s2 //false

2. 作为属性名的Symbol

由于每一个Symbol值都是不相等的，这意味着Symbol值可以作为标识符用于对象的属性名，保证不会出现同名的属性。这对于一个对象由多个模块构成的情况非常有用，能防止某一个键被不小心改写或覆盖。

var mySymbol = Symbol()

//第一种写法
var a = {}
a[mySymbol] = 'Hello!'

//第二种写法
var a = {
    [mySymbol]: 'Hello!'
}

//第三种写法
var a = {}
Object.defineProperty(a, mySymbol, {value: 'Hello!'})

上面的代码通过方括号结构和Object.defineProperty将对象的属性名指定为一个Symbol值。



注意，Symbol值作为对象属性名时不能使用点运算符。
var mySymbol = Symbol()
var a = {}

a.mySymbol = 'Hello!'
a[mySymbol] //undefined
a['mySymbol'] //'Hello!'

3. 属性名的遍历

Symbol作为属性名，该属性不会出现在for...in，for...of循环中，也不会被Object.keys()，Object.getOwnPropertyNames()返回。但它不是私有属性，有一个Object.getOwnPropertySymbols方法可以获取指定对象的所有Symbol属性名。

Object.getOwnPropertySymbols方法返回一个数组，成员是当前对象的所有用作属性名的Symbol值。

var obj = {}

var a = Symbol('a')
var b = Symbol('b')

obj[a] = 'Hello'
obj[b] = 'World'


var objectSymbols = Object.getOwnPropertySymbols(obj)
objectSymbols //[Symbol(a), Symbol(b)]

另外有一个API-Reflect.ownKeys方法可以返回所有类型的键名，包括常规键名和Symbol键名。

let obj = {
    [Symbol('my_key')]: 1,
    enum: 2,
    nonEnum: 3
}


Reflect.ownKeys(obj) //['enum', 'nonEnum', Symbol(my_key)]

4. 内置的Symbol值

除了定义自己使用的Symbol值，ES6还提供了11个内置的Symbol值，指向语言内部使用的方法。

4.1 Symbol.hasInstance

对象的Symbol.hasInstance属性指向一个内部方法，对象使用instanceof运算符时会调用这个方法，判断该对象是否为某个构造函数的实例。比如，foo instanceof Foo在语言内部实际调用的是Foo[Symbol.hasInstance](foo)。

class MyClass {
    [Symbol.hasInstance](foo) {
        return foo instanceof Array
    }
}


[1, 2, 3] instanceof new MyClass() //true

上面的代码中，MyClass是一个类，new MyClass()会返回一个实例。该实例的Symbol.hasInstance方法会在进行instanceof运算的时自动调用，判断左侧的运算子是否为Array的实例。

4.2 Symbol.isConcatSpreadable

对象的Symbol.isConcatSpreadable属性等于一个布尔值，表示该对象使用Array.prototype.concat()时是否可以展开。

对象的Symbol.isConcatSpreadable属性等于一个布尔值，表示该对象使用Array.prototype.concat()是否可以展开。

let arr1 = ['c', 'd']
['a', 'b'].concat(arr1, 'e') //['a', 'b', 'c', 'd', 'e']
arr1[Symbol.isConcatSpreadable] //undefined

let arr2 = ['c', 'd']
arr2[Symbol.isConcatSpreadable] = false
['a', 'b'].concat(arr2, 'e') //['a', 'b', ['c', 'd'] , 'e']

上面的代码说明，数组的默认行为是可以展开的。Symbol.isConcatSpreadable属性等于true或undefined，都有这个效果。

类似数组的对象也可以展开，但它的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']

4.3 Symbol.species

对象的Symbol.species属性指向当前对象的构造函数。创造实例时默认会调用这个方法，即使用这个属性返回的函数当作构造函数来创造新的实例对象。

默认的Symbol.species属性等同于下面的写法：

static get [Symbol.species]() {
    return this
}

4.4 Symbol.match

对象的Symbol.match属性指向一个函数，当执行str.match(myObject)时，如果该属性存在时，会调用它返回该方法的返回值。

class MyMatcher {
    [Symbol.match](string) {
        return 'hello world'.indexOf(string)
    }
}

'e'.match(new MyMatcher()) //1