es6进修笔记-Symbol_v1.0
基础抄了一次内容,有许多只是晓得其然并不知其所以然,不过也算是加深了一次印象,别的每段代码我都有手动实行过.
ES6引入了一种新的原始数据范例Symbol，示意举世无双的值。
它是JavaScript言语的第七种数据范例,前六种是：Undefined、Null、布尔值（Boolean）、字符串（String）、数值（Number）、对象（Object）。
ES5的对象属性名都是字符串，这轻易构成属性名的争执。比方，你运用了一个别人供应的对象，但又想为这个对象增加新的要领（mixin形式），新要领的名字就有可能与现有要领发生争执。为了防备争执,这就是ES6引入Symbol的缘由。
Symbol值经由过程Symbol函数天生。这就是说，对象的属性名如今能够有两种范例，一种是本来就有的字符串，另一种就是新增的Symbol范例。通常属性名属于Symbol范例，就都是举世无双的，能够保证不会与其他属性名发生争执。
let s = Symbol();
typeof s
// "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 mySymbol = Symbol();
// 第一种写法
var a = {};
a[mySymbol] = 'Hello!';
// 第二种写法
var a = {
//在对象内部必须要运用方括号包裹Symbol属性
[mySymbol]: 'Hello!'
};
// 第三种写法
var a = {};
//Object.defineProperty(obj, prop(需定义或修正的属性的名字), descriptor(将被定义或修正的属性的形貌符))
Object.defineProperty(a, mySymbol, { value: 'Hello!' });
// 以上写法都获得一样效果
a[mySymbol] // "Hello!"加强对象写法
let s = Symbol();
let obj = {//跟下面一样
[s]: function (arg) { ... }//用方括号
};
obj[s](123);
//--------------------------
let obj = {
//这是加强对象写法
[s](arg) { ... }
};跟常量合营运用
重要是为了保证常量不会雷同
log.levels = {
DEBUG: Symbol('debug'),//这里就是
INFO: Symbol('info'),
WARN: Symbol('warn')
};
log(log.levels.DEBUG, 'debug message');
log(log.levels.INFO, 'info message');
//--------------------------
const COLOR_RED = Symbol(); //比较奇妙的设置为一个唯一的常量
const COLOR_GREEN = Symbol();
function getComplement(color) {
switch (color) {
case COLOR_RED:
return COLOR_GREEN;
case COLOR_GREEN:
return COLOR_RED;
default:
throw new Error('Undefined color');
}
}
实例：消弭把戏字符串
把戏字符串指的是，在代码当中屡次涌现、与代码构成强耦合的某一个详细的字符串或许数值。作风优越的代码，应当只管消弭把戏字符串，该由寄义清楚的变量替代。
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'//如许消弭了强耦合
};
//更直接的体式格局运用Symbol坚持唯一
const shapeType = {
triangle: Symbol()
};
//-------------------------
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 });属性名的遍历
Symbol 作为属性名，该属性不会出如今for…in、for…of轮回中，也不会被Object.keys()、Object.getOwnPropertyNames()、JSON.stringify()返回。然则，它也不是私有属性，有一个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);
console.log(objectSymbols)
// 返回[Symbol(a), Symbol(b)]
for (var i in obj) {//并不能运用这个要领猎取Symbol
console.log(i); // 无输出
}
console.log(Object.getOwnPropertyNames(obj))//并不能运用这个要领猎取Symbol
// 返回[]Reflect.ownKeys
Reflect.ownKeys要领能够返回一切范例的键名，包含通例键名和 Symbol 键名。
let obj = {
[Symbol('my_key')]: 1,
enum: 2,
nonEnum: 3
};
console.log(Reflect.ownKeys(obj))
// 返回 ["enum", "nonEnum", Symbol(my_key)]Symbol.for()
Symbol.for要领,它接收一个字符串作为参数，然后搜刮有无以该参数作为称号的Symbol值。假如有，就返回这个Symbol值，不然就新建并返回一个以该字符串为称号的Symbol值。
var s1 = Symbol.for('foo');
var s2 = Symbol.for('foo');
console.log(s1 === s2) // true
console.log(Symbol.for("bar") === Symbol.for("bar"))
// true
console.log(Symbol("bar") === Symbol("bar"))
// falseSymbol.for()与Symbol()这两种写法，都邑天生新的Symbol。它们的区别是，前者会被登记在全局环境中供搜刮，后者不会。Symbol.for()不会每次挪用就返回一个新的 Symbol 范例的值，而是会先搜检给定的key是不是已存在，假如不存在才会新建一个值。
实例：模块的 Singleton 形式
Singleton形式指的是挪用一个类，任何时刻返回的都是同一个实例。
关于Node来讲，模块文件能够看成是一个类。怎样保证每次实行这个模块文件，返回的都是同一个实例呢？
把实例放到顶层对象global
// mod.js
function A() {
this.foo = 'hello';
}
if (!global._foo) {
global._foo = new A();
}
module.exports = global._foo;变量a任何时刻加载的都是A的同一个实例。
var a = require('./mod.js');
console.log(a.foo);然则，这里有一个题目，全局变量global._foo是可写的，任何文件都能够修正。
var a = require('./mod.js');
global._foo = 123;//修正了全局变量global._foo上面的代码，会使得别的剧本加载mod.js都失真。
为了防备这类状况涌现，我们就能够运用Symbol。
// mod.js
const FOO_KEY = Symbol.for('foo'); //Symbol.for天生是为了有些时刻能够从新运用这个Symbol值
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要领天生，那末外部将没法援用这个值，固然也就没法改写。
// mod.js
const FOO_KEY = Symbol('foo');//保证每次都是唯一,由于Symbol天生
// 背面代码雷同 ……上面代码将致使其他剧本都没法援用FOO_KEY。但如许也有一个题目，就是假如屡次实行这个剧本，每次获得的FOO_KEY都是不一样的。虽然Node会将剧本的实行效果缓存，平常状况下，不会屡次实行同一个剧本，然则用户能够手动消灭缓存，所以也不是完整牢靠。
内置的Symbol值
Symbol.hasInstance
对象的Symbol.hasInstance属性，指向一个内部要领。当其他对象运用instanceof运算符，推断是不是为该对象的实例时，会挪用这个要领。比方，foo instanceof Foo在言语内部，现实挪用的是Foo[Symbol.hasInstance](foo)。
class MyClass {
[Symbol.hasInstance](foo) {//instanceof指向了这个内部要领
return foo instanceof Array;
}
}
//挪用了instanceof
console.log([1, 2, 3] instanceof new MyClass()) //返回 trueSymbol.isConcatSpreadable
对象的Symbol.isConcatSpreadable属性即是一个布尔值，示意该对象运用Array.prototype.concat()时，是不是能够睁开。
数组的默许行动是能够睁开
let arr1 = ['c', 'd'];
console.log(['a', 'b'].concat(arr1, 'e')) // ['a', 'b', 'c', 'd', 'e']
console.log(arr1[Symbol.isConcatSpreadable]) // undefined
let arr2 = ['c', 'd'];
arr2[Symbol.isConcatSpreadable] = false;
console.log(arr2[Symbol.isConcatSpreadable]);//返回false
console.log(['a', 'b'].concat(arr2, 'e')) // ['a', 'b', ['c','d'], 'e']Symbol.species
对象的Symbol.species属性，指向当前对象的组织函数。制造实例时，默许会挪用这个要领，即运用这个属性返回的函数看成组织函数，来制造新的实例对象。
class MyArray extends Array {
// 掩盖父类 Array 的组织函数
//所以他是由当前类MyArray建立的
static get [Symbol.species]() { return this; }//静态要领而且要用get来猎取Symbol.species属性
}
var a = new MyArray(1,2,3);
var mapped = a.map(x => x * x);
//虽然是由MyArray来建立的,然则由于他也是集成自Array,所以都是true
console.log(mapped instanceof MyArray) // true
console.log(mapped instanceof Array) // true
//假如改成了返回Array的话,那末效果的是Array为true
static get [Symbol.species]() { return Array; }Symbol.match
对象的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(从0最先盘算第一位,1是第二位)Symbol.replace
对象的Symbol.replace属性，指向一个要领，当该对象被String.prototype.replace要领挪用时，会返回该要领的返回值。
String.prototype.replace(searchValue, replaceValue)
// 等同于
searchValue[Symbol.replace](this, replaceValue)
下面是一个例子。const obj = {};
obj[Symbol.replace] = (...s) => console.log(s);
'Hello'.replace(obj, 'World') // ["Hello", "World"]Symbol.replace要领会收到两个参数，第一个参数是replace要领正在作用的对象，上面例子是Hello，第二个参数是替代后的值，上面例子是World。
Symbol.search
对象的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);
}
}
console.log('foobar'.search(new MySearch('foo'))) // 0Symbol.split
对象的Symbol.split属性，指向一个要领，当该对象被String.prototype.split要领挪用时，会返回该要领的返回值。
String.prototype.split(separator, limit)
// 等同于
separator[Symbol.split](this, limit)class MySplitter {
constructor(value) {
this.value = value;
}
[Symbol.split](string) {
var index = string.indexOf(this.value);
if (index === -1) {
return string;
}
return [
string.substr(0, index),
string.substr(index + this.value.length)
];
}
}
console.log('foobar'.split(new MySplitter('foo')))
// ['', 'bar']
console.log('foobar'.split(new MySplitter('bar')))
// ['foo', '']
console.log('foobar'.split(new MySplitter('baz')))
// 'foobar'上面要领运用Symbol.split要领，从新定义了字符串对象的split要领的行动
Symbol.iterator
对象的Symbol.iterator属性，指向该对象的默许遍历器要领。
var myIterable = {};
myIterable[Symbol.iterator] = function* () {
yield 1;
yield 2;
yield 3;
};
[...myIterable] // [1, 2, 3]对象举行for…of轮回时，会挪用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();
}
}
};
console.log(2 * obj) // 246
console.log(3 + obj) // '3default'
console.log(obj == 'default') // true
console.log(String(obj)) // 'str'Symbol.toStringTag
对象的Symbol.toStringTag属性，指向一个要领。在该对象上面挪用Object.prototype.toString要领时，假如这个属性存在，它的返回值会出如今toString要领返回的字符串当中，示意对象的范例。也就是说，这个属性能够用来定制[object Object]或[object Array]中object背面的谁人字符串。
// 例一
console.log(({[Symbol.toStringTag]: 'Foo'}.toString()))
// "[object Foo]"
// 例二
class Collection {
get [Symbol.toStringTag]() {
return 'xxx';
}
}
var x = new Collection();
console.log(Object.prototype.toString.call(x)) // "[object xxx]"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'参考援用:
