1. 概述
- ES6引入了一种新的原始数据类型Symbol，表示独一无二的值。它是JavaScript语言的第七种数据类型，前六种是undefined，Null，布尔值（Boolean），字符串（String），数值（Number），对象（Object）。
- Symbol值通过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函数返回值不相等。
- Symbol值不能与其他类型的值进行运算，会报错。
- Symbol值可以显式转为字符串。也可以转为布尔值，但是不能转为数值。
var sym = Symbol('Me');
"you" + sym //TypeError
String(sym) //'Symbol(Me)'
sym.toString //'Symbol(Me)'
var s = Symbol();
Boolean(s) //true
!s //false
2. 作为属性名的Symbol
- Symbol值可以作为标识符，用于对象的属性名，可以保证不出现同名属性。
var s = Symbol();
//第一种写法
var a = {};
a[s] = 'Hello';
//第二种写法
var a = {
[s]: 'Hello'
}
//第三种写法
var a = {};
Object.defindProperty(a,s,{value:'Hello'});
//以上结果相同
a[s] //"Hello"
注意：
Symbol值作为对象属性名时，不能用点运算符。
对象内部，使用Symbol值定义属性时，Symbol值必须放在方括号之中。
- Symbol类型还可以用于定义一组常量，保证这组常量的值都是不相等的。
- Symbol值作为属性名时，该属性是公开属性，不是私有属性。
3. 实例：消除魔术字符串
魔术字符串指在代码中多次出现、与代码形成强耦合的某一个具体的字符串或者数值。
function getArea(shape, options) {
var area = 0;
switch (shape) {
case 'Triangle': // 魔术字符串
area = .5 * options.width * options.height;
break; /* ... more code ... */
}
return area;
}
getArea('Triangle', { width: 100, height: 100 }); // 魔术字符串
- 常用的消除方法，就是把它写成一个变量
var shapeType = {
triangle: 'Triangle'
};
function getArea(shape, options) {
var area = 0;
switch (shape) {
case shapeType.triangle:
area = .5 * options.width * options.height;
break;
}
return area;
}
getArea(shapeType.triangle, { width: 100, height: 100 });
shapeType.triangle等于哪个值并不重要，只要确保不会跟其他shapeType属性的值冲突即可。因此，这里适合改用Symbol值。
const shapeType = {
triangle: Symbol()
};
4. 属性名的遍历
- 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)]
使用Object.getOwnPropertyNames方法得不到Symbol属性名，需要使用Object.getOwnPropertySymbols方法。
Reflect.ownKeys方法可以返回所有类型的键名，包括常规键名和Symbol键名。
let obj = {
[Symbol('my_key')]: 1,
enum: 2,
nonEnum: 3
};
Reflect.ownKeys(obj)
// [Symbol(my_key), 'enum', 'nonEnum']
5. Symbol.for()，Symbol.keyFor()
- Symbol.for方法接受一个字符串作为参数，然后搜索有没有以该参数作为名称的Symbol值。如果有，就返回这个Symbol值，否则就新建并返回一个以该字符串为名称的Symbol值。
var s1 = Symbol.for('foo');
var s2 = Symbol.for('foo');
s1 === s2 // true
Symbol.for('foo') ===Symbol.for('foo'); //false
- Symbol.keyFor方法返回一个已登记的Symbol类型值的key。
var s1 = Symbol.for("foo");
Symbol.keyFor(s1) // "foo"
var s2 = Symbol("foo");//未登记
Symbol.keyFor(s2) // undefined
注意：Symbol.fo为Symbol值登记的名字，是全局环境的，可以在不同的iframe或service worker中取到同一个值。
6. 模块的Singleton模式
- Singleton模式指的是调用一个类，任何时候返回的都是同一个实例。
- 把实例放到顶层对象global。
// mod.js
function A() {
this.foo = 'hello';
}
if (!global._foo) {
global._foo = new A();
}
module.exports = global._foo;
然后加载上面的mod.js
var a = require('./mod.js');
console.log(a.foo);
上面代码中，变量a任何时候加载的都是A的同一个实例。
但时全局变量global._foo是可写的，任何文件都可以修改。
var a = require('./mod.js');
global._foo = 123;
上面的代码会使别的脚本加载mod.js都失真。
为防止这种情况，使用Symbol
// mod.js
const FOO_KEY = Symbol.for('foo');
function A() {
this.foo = 'hello';
}
if (!global[FOO_KEY]) {
global[FOO_KEY] = new A();
}
module.exports = global[FOO_KEY];
上面代码中，可以保证global[FOO_KEY]
不会被无意间覆盖，但还是可以被改写。
var a = require('./mod.js');
global[Symbol.for('foo')] = 123;
如果键名使用Symbol方法生成，那么外部将无法引用这个值，当然也就无法改写。
javascript
// mod.js
const FOO_KEY = Symbol('foo');
// 后面代码相同 ……
上面代码将导致其他脚本都无法引用FOO_KEY
。但这样也有一个问题，就是如果多次执行这个脚本，每次得到的FOO_KEY都是不一样的。虽然Node会将脚本的执行结果缓存，一般情况下，不会多次执行同一个脚本，但是用户可以手动清除缓存，所以也不是完全可靠。
以上？？？
7. 内置的Symbol值
ES6提供11个内置的Symbol值，指向语言内部使用的方法。
- Symbol.hasInstance
- 对象的Symbol.hasInstance
属性，指向一个内部方法。当其他对象使用instanceof运算符，判断是否为该对象的实例时，会调用这个方法。比如，foo instanceof Foo
在语言内部，实际调用的是Foo[Symbol.hasInstance](foo)。 - Symbol.isConcatSpreadable
- 对象的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.species
- 对象的Symbol.species属性，指向一个方法。该对象作为构造函数创造实例时，会调用这个方法。即如果this.constructor[Symbol.species]
存在，就会使用这个属性作为构造函数，来创造新的实例对象。 - Symbol.match
- 对象的Symbol.match属性，指向一个函数。当执行str.match(myObject)时，如果该属性存在，会调用它，返回该方法的返回值。
- Symbol.replace
- 对象的Symbol.replace属性，指向一个方法，当该对象被String.prototype.replace方法调用时，会返回该方法的返回值
String.prototype.replace(searchValue, replaceValue)
// 等同于
searchValue[Symbol.replace](this, replaceValue)
- Symbol.search
- 对象的Symbol.search属性，指向一个方法，当该对象被String.prototype.search方法调用时，会返回该方法的返回值。
- Symbol.split
- 对象的Symbol.split属性，指向一个方法，当该对象被String.prototype.split方法调用时，会返回该方法的返回值。
String.prototype.split(separator, limit)
// 等同于
separator[Symbol.split](this, limit)
- Symbol.iterator
- 对象的Symbol.iterator属性，指向该对象的默认遍历器方法。
- Symbol.toPrimitive
- 对象的Symbol.toPrimitive属性，指向一个方法。该对象被转为原始类型的值时，会调用这个方法，返回该对象对应的原始类型值。
- 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
3 + obj // '3default'
obj == 'default' // true
String(obj) // 'str'
- Symbol.toStringTag
- 对象的Symbol.toStringTag属性，指向一个方法。在该对象上面调用Object.prototype.toString
方法时，如果这个属性存在，它的返回值会出现在toString方法返回的字符串之中，表示对象的类型。也就是说，这个属性可以用来定制[object Object]或[object Array]中object后面的那个字符串。 - Symbol.unscopables
- 对象的Symbol.unscopables属性，指向一个对象。该对象指定了使用with关键字时，哪些属性会被with环境排除。
