ASP源码
PHP源码
.NET源码
JSP源码
如何快速入门VUE3.0:进入学习
Symbol(符号)是 ES6 新增的数据类型。Symbol 是原始值(基础数据类型),且 Symbol 实例是唯一、不可变的。它的产生是因为要用来唯一的标记,进而用作非字符串形式的对象属性,是确保对象属性使用唯一标识符,不会发生属性冲突的危险。
符号需要使用 Symbol()函数初始化。因为符号本身是原始类型,所以 typeof 操作符对符号返回 symbol。
let sym = Symbol();
co***le.log(typeof sym); // symbol
Symbol()函数可以接收一个字符串参数用来描述,后,后续可以通过这个字符串来调试代码。但值得注意的是,多个 Symbol()函数即使接受的参数是一样的,他们的值也是不相等的。
let genericSymbol = Symbol(); let otherGenericSymbol = Symbol(); let fooSymbol = Symbol("foo"); let otherFooSymbol = Symbol("foo"); co***le.log(genericSymbol == otherGenericSymbol); // false co***le.log(fooSymbol == otherFooSymbol); // false
如果在代码中有多个地方需要使用同一个 Symbol 实例的时候,可以传入一个字符串,然后使用 Sy***l.for()方法来创建一个可以复用的 Symbol,类似于单例模式,在第一次使用 Sy***l.for()的时候,它会根据传入的参数会全局的去寻找是否使用 Sy***l.for()创建过同样的实例,如果有,则复用,如果没有,则新建
let fooGlobalSymbol = Sy***l.for("foo"); // 创建新符号 let otherFooGlobalSymbol = Sy***l.for("foo"); // 重用已有符号 co***le.log(fooGlobalSymbol === otherFooGlobalSymbol); // true
Sy***l.for()创建的实例和 Symbol()创建的实例区别: Symbol()创建的实例永远都是唯一的,不会因为你传入的参数相同而跟其他的实例相等,但是 Sy***l.for()创建的实例如果参数相同的话他们是会相等的,因为他们会公用同一个 Symbol 实例
let fooSymbol = Symbol("foo"); let otherFooSymbol = Symbol("foo"); co***le.log(fooSymbol == otherFooSymbol); // false let fooGlobalSymbol = Sy***l.for("foo"); // 创建新符号 let otherFooGlobalSymbol = Sy***l.for("foo"); // 重用已有符号 co***le.log(fooGlobalSymbol === otherFooGlobalSymbol); // true
对象中的属性一般都是字符串的形式,但其实也是可以使用 Symbol 实例来作为属性的,这样的好处就是你新增的属性不会覆盖掉以前的任何属性
let s1 = Symbol("foo"), s2 = Symbol("bar"), s3 = Symbol("baz"), s4 = Symbol("qux"); let o = { [s1]: "foo val", }; // 这样也可以:o[s1] = 'foo val'; co***le.log(o); // {Symbol(foo): foo val} Ob***t.defineProperty(o, s2, { value: "bar val" }); co***le.log(o); // {Symbol(foo): foo val, Symbol(bar): bar val} Ob***t.defineProperties(o, { [s3]: { value: "baz val" }, [s4]: { value: "qux val" }, }); co***le.log(o); // {Symbol(foo): foo val, Symbol(bar): bar val, // Symbol(baz): baz val, Symbol(qux): qux val}
注意: 创建 Symbol 实例作为对象属性的时候,如果改 symbol 一开始没有声明一个变量进行接收的话,后续就必须遍历对象的所有符号属性才能找到相应的属性键:
let o = { [Symbol("foo")]: "foo val", [Symbol("bar")]: "bar val", }; co***le.log(o); // {Symbol(foo): "foo val", Symbol(bar): "bar val"} let barSymbol = Ob***t.getOwnPropertySymbols(o).find(symbol => sy***l.toString().match(/bar/)); co***le.log(barSymbol); // Symbol(bar)
ES6 也引入了一批常用内置符号(well-known symbol),用于暴露语言内部行为,开发者可以直接访问、重写或模拟这些行为。如果对这些默认的属性进行了修改的话,是可以改变一些操作最后执行的结果的。比如 for-of 循环会在相关对象上使用 Sy***l.iterator 属性,那么就可以通过在自定义对象上重新定义 Sy***l.iterator 的值,来改变 for-of 在迭代该对象时的行为。
其实就是一个返回 Promise 的 Generator,一般配合 for await of 使用
根据 ECMAScript 规范,这个符号作为一个属性表示“一个方法,该方法返回对象默认的 AsyncIterator。 由 for-await-of 语句使用”。换句话说,这个符号表示实现异步迭代器 API 的函数。
这个属性定义在 Function 的原型上。都知道 instanceof 操作符可以用来确定一个对象实例是否属于某个构造函数。其原理就是 instanceof 操作符会使用 Sy***l.hasInstance 函数来确定关系
function Foo() {} let f = new Foo(); co***le.log(f instanceof Foo); // true class Bar {} let b = new Bar(); co***le.log(b instanceof Bar); // true
如果你重新定义一个函数的 Sy***l.hasInstance 属性,你就可以让 instanceof 方法返回一些意料之外的东西
class Bar {} class Baz extends Bar { static [Sy***l.hasInstance]() { return false; } } let b = new Baz(); co***le.log(Bar[Sy***l.hasInstance](b)); // true co***le.log(b instanceof Bar); // true co***le.log(Baz[Sy***l.hasInstance](b)); // false co***le.log(b instanceof Baz); // false
这个属性定义在 Array 的原型上
根据 ECMAScript 规范,这个符号作为一个属性表示“一个布尔值,如果是 true,则意味着对象应该用 Ar***.prototype.concat()打平其数组元素”。ES6 中的 Ar***.prototype.concat()方法会 根据接收到的对象类型选择如何将一个类数组(伪数组)对象拼接成数组实例。所以修改 Sy***l.isConcatSpreadable 的值可以修改这个行为。
false: 将一整个对象添加进数组true: 将一整个对打平添加进数组
let initial = ["foo"]; let array = ["bar"]; co***le.log(array[Sy***l.isConcatSpreadable]); // undefined co***le.log(in***al.concat(array)); // ['foo', 'bar'] array[Sy***l.isConcatSpreadable] = false; co***le.log(in***al.concat(array)); // ['foo', Array(1)] let arrayLikeObject = { length: 1, 0: "baz" }; co***le.log(arrayLikeObject[Sy***l.isConcatSpreadable]); // undefined co***le.log(in***al.concat(arrayLikeObject)); // ['foo', {...}] arrayLikeObject[Sy***l.isConcatSpreadable] = true; co***le.log(in***al.concat(arrayLikeObject)); // ['foo', 'baz'] let otherObject = new Set().add("qux"); co***le.log(otherObject[Sy***l.isConcatSpreadable]); // undefined co***le.log(in***al.concat(otherObject)); // ['foo', Set(1)] otherObject[Sy***l.isConcatSpreadable] = true; co***le.log(in***al.concat(otherObject)); // ['foo']
根据 ECMAScript 规范,这个符号作为一个属性表示“一个方法,该方法返回对象默认的迭代器。由 for-of 语句使用”
该属性会返回一个 Generator 函数,for of 就会依次的去调用 next()方法,这就是为什么 for of 可以使用在某些对象身上。
class Emitter { constructor(max) { this.max = max; this.idx = 0; } *[Sy***l.iterator]() { while (this.idx < this.max) { yield this.idx++; } } } function count() { let emitter = new Emitter(5); for (const x of emitter) { co***le.log(x); } } count(); // 0 // 1 // 2 // 3 // 4
根据 ECMAScript 规范,这个符号作为一个属性表示“一个正则表达式方法,该方法用正则表达式去匹配字符串。由 St***g.prototype.match()方法使用”。
St***g.prototype.match()方法会使用以 Sy***l.match 为键的函数来对正则表达式求值。所以更改一个正则表达式的 Sy***l.match 属性,可以让 St***g.prototype.match()得到你想要的值
co***le.log(Re***p.prototype[Sy***l.match]); // ƒ [Sy***l.match]() { [native code] } co***le.log("foobar".match(/bar/)); // ["bar", index: 3, input: "foobar", groups: undefined] class FooMatcher { static [Sy***l.match](target) { return ta***t.includes("foo"); } } co***le.log("foobar".match(FooMatcher)); // true co***le.log("barbaz".match(FooMatcher)); // false class StringMatcher { constructor(str) { this.str = str; } [Sy***l.match](target) { return ta***t.includes(this.str); } } co***le.log("foobar".match(new StringMatcher("foo"))); // true co***le.log("barbaz".match(new StringMatcher("qux"))); // false
这个符号作为一个属性表示“一个正则表达式方法,该方法返回字符串中 匹配正则表达式的索引。由 St***g.prototype.search()方法使用”
这个符号作为一个属性表示“一个函数值,该函数作为创建派生对象的构 造函数”。
这个符号作为一个属性表示“一个正则表达式方法,该方法在匹配正则表 达式的索引位置拆分字符串。由 St***g.prototype.split()方法使用”。
这个符号作为一个属性表示“一个方法,该方法将对象转换为相应的原始 值。由 ToPrimitive 抽象操作使用”
这个符号作为一个属性表示“一个字符串,该字符串用于创建对象的默认 字符串描述。由内置方法 Ob***t.prototype.toString()使用”
这个符号作为一个属性表示“一个对象,该对象所有的以及继承的属性, 都会从关联对象的 with 环境绑定中排除