Symbol 是 ES6 新加入的数据类型，是一种原始数据类型。该类型的性质在于这个类型的值可以用来创建匿名的对象属性。该数据类型通常被用作一个对象属性的键值——当你想让它是私有的时候。对象的属性名现在可以有两种类型，一种是字符串，另一种就是 Symbol 类型。
Symbol 值通过Symbol函数生成，它是独一无二的，可以保证不会与其他属性名产生冲突。
let s1 = Symbol();
// Symbol 函数前不能使用 new 命令，否则会报错
// 因为生成的 Symbol 是一个原始类型的值，不是对象
let s2 = Symbol();
typeof s
// "symbol"
s1 === s2 // false
// Symbol 是独一无二的
复制代码打印 Symbol 类型都显示为 Symbol，这不好区分，这时就可以给它传递一个参数，来区分 Symbol。
const obj = {
toString() {
return 'abc';
}
};
const sym = Symbol(obj);
sym // Symbol(abc)
let s1 = Symbol('foo');
let s2 = Symbol('foo');
s1 === s2 // false
复制代码Symbol 值不能与其他类型的值进行运算
let sym = Symbol('My symbol');
"your symbol is " + sym
// TypeError: can't convert symbol to string
`your symbol is ${sym}`
// TypeError: can't convert symbol to string
复制代码Symbol 值可以显式转为字符串和布尔值，但是不能转为数值。
let sym = Symbol('My symbol');
String(sym) // 'Symbol(My symbol)'
sym.toString() // 'Symbol(My symbol)'
let sym = Symbol();
Boolean(sym) // true
!sym // false
Number(sym) // TypeError
sym + 2 // TypeError
复制代码作为属性名
Symbol 值可以作为属性名，一般用来实现私有属性。
let mySymbol = Symbol();
let s = Symbol();
// 第一种写法
let a = {};
a[mySymbol] = 'Hello!';
// 第二种写法
let a = {
[mySymbol]: 'Hello!',
[s] (arg) { }
};
// 第三种写法
let a = {};
Object.defineProperty(a, mySymbol, { value: 'Hello!' });
// 以上写法都得到同样结果
a[mySymbol] // "Hello!"
复制代码遍历属性名
Symbol 作为属性名，该属性不会出现在for...in、for...of循环中，也不会被Object.keys()、Object.getOwnPropertyNames()、JSON.stringify()返回。
但是，Object.getOwnPropertySymbols方法，可以获取指定对象的所有 Symbol 属性名，Reflect.ownKeys方法可以返回所有类型的键名，包括常规键名和 Symbol 键名。
const obj = {};
let a = Symbol('a');
let b = Symbol('b');
obj[a] = 'Hello';
obj[b] = 'World';
const objectSymbols = Object.getOwnPropertySymbols(obj);
objectSymbols
// [Symbol(a), Symbol(b)]
复制代码Symbol 的静态方法
Symbol 一共有两个静态方法Symbol.for(key)和Symbol.keyFor(sym)。
for
Symbol.for(key)方法会根据给定的键key，来从运行时的symbol注册表中找到对应的 symbol，如果找到了，则返回它，否则，新建一个与该键关联的symbol，并放入全局symbol 注册表中。
Symbol.for("foo"); // 创建一个 symbol 并放入 symbol 注册表中，键为 "foo"
Symbol.for("foo"); // 从 symbol 注册表中读取键为"foo"的 symbol
Symbol.for("bar") === Symbol.for("bar"); // true，证明了上面说的
Symbol("bar") === Symbol("bar"); // false，Symbol() 函数每次都会返回新的一个 symbol
var sym = Symbol.for("mario");
sym.toString();
// "Symbol(mario)"，mario 既是该 symbol 在 symbol 注册表中的键名，又是该 symbol 自身的描述字符串
复制代码keyFor
Symbol.keyFor(sym)方法用来获取symbol注册表中与某个symbol关联的键。
// 创建一个 symbol 并放入 Symbol 注册表，key 为 "foo"
var globalSym = Symbol.for("foo");
Symbol.keyFor(globalSym); // "foo"
// 创建一个 symbol，但不放入 symbol 注册表中
var localSym = Symbol();
Symbol.keyFor(localSym); // undefined，所以是找不到 key 的
// well-known symbol 们并不在 symbol 注册表中
Symbol.keyFor(Symbol.iterator) // undefined
let s1 = Symbol.for("foo");
Symbol.keyFor(s1) // "foo"
let s2 = Symbol("foo");
Symbol.keyFor(s2) // undefined
// Symbol()写法没有登记机制，所以每次调用都会返回一个不同的值
复制代码内置的 Symbol 值 （Well-known symbols）
ES6 提供了 12 个内置的 Symbol 值，指向语言内部使用的方法。
迭代 symbols
Symbol.iterator
指向该对象的默认遍历器方法。
Symbol.asyncIterator
指向该对象的默认异步遍历器方法。
正则表达式 symbols
Symbol.match
指向一个函数。String.prototype.match()方法执行时如果该属性存在，会调用此函数，返回该方法的返回值。
String.prototype.match(regexp)
// 等同于
regexp[Symbol.match](this)
class MyMatcher {
[Symbol.match](string) {
return 'hello world'.indexOf(string);
}
}
'e'.match(new MyMatcher()) // 1
"/bar/".startsWith(/bar/);
// Throws TypeError, 因为 /bar/ 是一个正则表达式
// 且 Symbol.match 没有修改。
var re = /foo/;
re[Symbol.match] = false;
"/foo/".startsWith(re); // true
"/baz/".endsWith(re); // false
// 如果将 Symbol.match 置为 false，
// 使用 match 属性的表达式检查会认为该对象不是正则表达式对象
复制代码Symbol.replace
指向一个方法，当该对象被String.prototype.replace方法调用时，会返回该方法的返回值。
String.prototype.replace(searchValue, replaceValue)
// 等同于
searchValue[Symbol.replace](this, replaceValue)
const x = {};
x[Symbol.replace] = (...s) => console.log(s);
'Hello'.replace(x, 'World') // ["Hello", "World"]
复制代码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
复制代码Symbol.split
指向一个方法，当该对象被String.prototype.split方法调用时，会返回该方法的返回值。
class MySplitter {
constructor(value) {
this.value = value;
}
[Symbol.split](string) {
let index = string.indexOf(this.value);
if (index === -1) {
return string;
}
return [
string.substr(0, index),
string.substr(index + this.value.length)
];
}
}
'foobar'.split(new MySplitter('foo'))
// ['', 'bar']
'foobar'.split(new MySplitter('bar'))
// ['foo', '']
'foobar'.split(new MySplitter('baz'))
// 'foobar'
复制代码其他 symbols
Symbol.hasInstance
指向一个内部方法。当其他对象使用instanceof运算符，判断是否为该对象的实例时，会调用这个方法。
class Even {
static [Symbol.hasInstance](obj) {
return Number(obj) % 2 === 0;
}
}
// 等同于
const Even = {
[Symbol.hasInstance](obj) {
return Number(obj) % 2 === 0;
}
};
1 instanceof Even // false
2 instanceof Even // true
12345 instanceof Even // false
复制代码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']
// ----------
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.unscopables
指向一个对象。该对象指定了使用with关键字时，哪些属性会被with环境排除。
Array.prototype[Symbol.unscopables]
// {
// copyWithin: true,
// entries: true,
// fill: true,
// find: true,
// findIndex: true,
// includes: true,
// keys: true
// }
// 数组有 7 个属性，会被with命令排除
复制代码Symbol.species
指向一个构造函数。创建衍生对象时，会使用该属性。
class MyArray extends Array {
}
const a = new MyArray(1, 2, 3);
const b = a.map(x => x);
const c = a.filter(x => x > 1);
b instanceof MyArray // true
c instanceof MyArray // true
// b 和 c 是 a 的衍生对象
// ---------
class MyArray extends Array {
static get [Symbol.species]() { return Array; }
}
const a = new MyArray();
const b = a.map(x => x);
b instanceof MyArray // false
b instanceof Array // true
复制代码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
指向一个方法。在该对象上面调用Object.prototype.toString方法时，如果这个属性存在，它的返回值会出现在toString方法返回的字符串之中，表示对象的类型。
这个属性可以用来定制[object Object]或[object Array]中object后面的那个字符串。
({[Symbol.toStringTag]: 'Foo'}.toString())
// "[object Foo]"
class Collection {
get [Symbol.toStringTag]() {
return 'xxx';
}
}
let x = new Collection();
Object.prototype.toString.call(x) // "[object xxx]"
复制代码ES6 内置对象属性值：
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'
Symbol 原型
Symbol 一共有 4 个原型方法。
Symbol.prototype.toSource()
返回代表该对象源码的字符串。该方法通常由JavaScript内部调用。
对于内建Symbol对象, toSource 返回以下字符串，表明源代码不可见：
`
function Symbol() {
[native code]
}
`
复制代码对于Symbol实例, toSource 返回代表源码的字符串。
"Symbol()"
复制代码Symbol.prototype.toString()
返回当前 symbol 对象的字符串表示。
Symbol.prototype.valueOf()
返回当前 symbol 对象所包含的 symbol 原始值。
Symbol.prototype[@@toPrimitive]
可将 Symbol 对象转换为原始值。返回该原始值为指定的 Symbol 对象。
Symbol()[Symbol.toPrimitive](hint);
一般不需要自己调用 JS 会自动地调用该方法。
Symbol 静态属性
除了prototype属性，Symbol 还有一个length属性，值为0。
697
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
