Symbol 的作用
Symbols 的出现是为了什么呢?
- 翻译自 medium
- Symbols 是 JavaScript 最新推出的一种基本类型,它被当做对象属性时特别有用,但是有什么是它能做而 String 不能做的呢?
- 在我们开始探索 Symbols 功能之前,我们先来看一下被很多开发者忽略 JavaScript 的特性。
背景:
- JavaScript 有两种值类型,一种是 基本类型 (primitives),一种是 对象类型 (objects,包含 function 类型),基本类型包括数字 number (包含 integer,float,Infinity,NaN),布尔值 boolean,字符串 string,undefined,null,尽管
typeof null === 'object'
,null 仍然是一个基本类型。 - 基本类型的值是不可变的,当然了,存放基本类型值得变量是可以被重新分配的,例如当你写
let x = 1; x++
,变量 x 就被重新分配值了,但是你并没有改变原来的1. - 一些语言,例如 c 语言有引用传递和值传递的概念,JavaScript 也有类似的概念,尽管它传递的数据类型需要推断。当你给一个 function 传值的时候,重新分配值并不会修改该方法调用时的参数值。然而,假如你修改一个非基本类型的值,修改值也会影响原来的值。
- 考虑下下面的例子:
function primitiveMutator(val) { val = val + 1; } let x = 1; primitiveMutator(x); console.log(x); // 1 function objectMutator(val) { val.prop = val.prop + 1; } let obj = { prop: 1 }; objectMutator(obj); console.log(obj.prop); // 2
- 基本类型一样的值永远相等(除了奇怪的 NaN ),看看这里:
const first = "abc" + "def"; const second = "ab" + "cd" + "ef"; console.log(first === second); // true
- 然而,非基本类型的值即使内容一样,但也不相等,看看这里:
const obj1 = { name: "Intrinsic" }; const obj2 = { name: "Intrinsic" }; console.log(obj1 === obj2); // false // Though, their .name properties ARE primitives: console.log(obj1.name === obj2.name); // true
- 对象扮演了一个 JavaScript 语言的基本角色,它们被到处使用,它们常被用在键值对的存储。然而这样使用有一个很大的限制:在 symbols 诞生之前,对象的键只能是字符串。假如我们试着使用一个非字符串当做对象的键,就会被转换为字符串,如下所示:
const obj = {}; obj.foo = 'foo'; obj['bar'] = 'bar'; obj[2] = 2; obj[{}] = 'someobj'; console.log(obj); // { '2': 2, foo: 'foo', bar: 'bar', '[object Object]': 'someobj' }注意:稍微离一下题,Map 数据结构被创建的目的就是为了应对存储键值对中,键不是字符串的情况。
symbols 是什么?
- 现在我们知道了什么是基本类型,终于准备好如何定义什么是 symbols 了。symbols 是一种无法被重建的基本类型。这时 symbols 有点类似与对象创建的实例互相不相等的情况,但同时 symbols 又是一种无法被改变的基本类型数据。这里有一个例子:
const s1 = Symbol(); const s2 = Symbol(); console.log(s1 === s2); // false
- 当你初始化一个带有一个接收可选字符串参数的 symbols 时,我们可以来 debug 看下,除此之外看看它会否影响自身。
const s1 = Symbol('debug'); const str = 'debug'; const s2 = Symbol('xxyy'); console.log(s1 === str); // false console.log(s1 === s2); // false console.log(s1); // Symbol(debug)
symbols 作为对象的属性
- symbols 有另一个很重要的用途,就是用作对象的 key。这儿有一个 symbols 作为对象 key 使用的例子:
const obj = {}; const sym = Symbol(); obj[sym] = 'foo'; obj.bar = 'bar'; console.log(obj); // { bar: 'bar' } console.log(sym in obj); // true console.log(obj[sym]); // foo console.log(Object.keys(obj)); // ['bar']
- 我们注意到使用 Object.keys() 并没有返回 symbols,这是为了向后兼容性的考虑。老代码不兼容 symbols,因此古老的 Object.keys() 不应该返回 symbols。
- 看第一眼,我们可能会觉得 symbols 这个特性很适合作为对象的私有属性,许多其他语言都要类似的类的隐藏属性,这一直被认为是 JavaScript 的一大短板。不幸的是,还是有可能通过 symbols 来取到对象的值,甚至都不用试着获取对象属性就可以得到对象 key,例如,通过 Reflect.ownKeys() 方法就可以获取所有的 key,包括 字符串和 symbols,如下所示:
function tryToAddPrivate(o) { o[Symbol('Pseudo Private')] = 42; } const obj = { prop: 'hello' }; tryToAddPrivate(obj); console.log(Reflect.ownKeys(obj)); // [ 'prop', Symbol(Pseudo Private) ] console.log(obj[Reflect.ownKeys(obj)[1]]); // 42注意:现在已经有一个旨在解决 JavaScript 私有属性的提案,叫做 Private Fields,尽管这并不会使所有的对象受益,它仍然对对象的实例有用,Private Fields 在 Chrome 74版本可用。
阻止对象属性名冲突
- symbols 可能对对象的私有属性没有直接好处,但是它有另外一个用途,它在不知道对象原有属性名的情况下,扩展对象属性很有用。
- 考虑一下当两个不同的库要读取对象的一些原始属性时,或许它们都想要类似的标识符。如果只是简单的使用字符串 id 作为 key,这将会有很大的风险,因为它们的 key 完全有可能相同。
function lib1tag(obj) { obj.id = 42; } function lib2tag(obj) { obj.id = 369; }
- 通过使用 symbols,不同的库在初始化的时候生成其所需的 symbols,然后就可以在对象上任意赋值。
const library1property = Symbol('lib1'); function lib1tag(obj) { obj[library1property] = 42; } const library2property = Symbol('lib2'); function lib2tag(obj) { obj[library2property] = 369; }
- 这方面 symbols 的确对 JavaScript 有用。然后你或许会奇怪,不同的库进行初始化的时候为什么不使用随机字符串,或者使用命名空间呢?
const library1property = uuid(); // random approach function lib1tag(obj) { obj[library1property] = 42; } const library2property = 'LIB2-NAMESPACE-id'; // namespaced approach function lib2tag(obj) { obj[library2property] = 369; }
- 你是对的,这种方法确实类似于 symbols 的这一作用,除非两个库使用相同的属性名,那就会有被覆写的风险。
- 机敏的读者已经发现这两种方案的效果并不完全相同。我们独有的属性名仍然有一个缺点:它们的 key 很容易被找到,尤其是当代码进行递归或者系列化对象,考虑如下的例子:
const library2property = 'LIB2-NAMESPACE-id'; // namespaced function lib2tag(obj) { obj[library2property] = 369; } const user = { name: 'Thomas Hunter II', age: 32 }; lib2tag(user); JSON.stringify(user); // '{"name":"Thomas Hunter II","age":32,"LIB2-NAMESPACE-id":369}'
- 假如我们使用 symbols 作为属性名,json 的输出将不会包含 symbols,这是为什么呢?因为 JavaScript 支持 symbols,并不意味着 json 规范也会跟着修改。json 只允许字符串作为 key,JavaScript 并没有试图让 json 输出 symbols。
- 我们可以简单的通过 Object.defineProperty() 来调整对象字符串输出的 json。
const library2property = uuid(); // namespaced approach function lib2tag(obj) { Object.defineProperty(obj, library2property, { enumerable: false, value: 369 }); } const user = { name: 'Thomas Hunter II', age: 32 }; lib2tag(user); // '{"name":"Thomas Hunter II", "age":32,"f468c902-26ed-4b2e-81d6-5775ae7eec5d":369}' console.log(JSON.stringify(user)); console.log(user[library2property]); // 369
- 类似于 symbols,对象通过设置 enumerable 标识符来隐藏字符串 key,它们都会被 Object.keys() 隐藏掉,而且都会被 Reflect.ownKeys() 展示出来,如下所示:
const obj = {}; obj[Symbol()] = 1; Object.defineProperty(obj, 'foo', { enumberable: false, value: 2 }); console.log(Object.keys(obj)); // [] console.log(Reflect.ownKeys(obj)); // [ 'foo', Symbol() ] console.log(JSON.stringify(obj)); // {}
- 在这一点上,我们相当于重建了 symbols,我们的隐藏字符串和 symbols 都被序列化器隐藏了,属性也都可以通过 Reflect.ownKeys() 来获取,因此他们并不算私有属性。假设我们使用命名空间、随机字符串等字符串作为对象的属性名,我们就可以避免多个库重名的风险。
- 但是仍然有一点细微的不同,字符串是不可变的,而 symbols 可以保证永远唯一,因此仍然有可能会有人生成重名的字符串。从数学意义上 symbols 提供了一个字符串没有的优点。
- 在 Node.js 里面,当检测一个对象(例如使用 console.log()),假如对象上的一个方法叫做 inspect,当记录对象时,该方法会被调用并输出。你可以想象,这种行为并不是每个人都会这样做,被用户创建的 inspect 方法经常会导致命名冲突,现在 require('util').inspect.custom 提供的 symbol 可以被用在函数上。inspect 方法在 Node.js v10 被放弃,在 v11 版直接被忽略。现在没人可以忽然就改变 inspect 方法的行为了。
模拟私有属性
- 这里有一个在对象上模拟私有属性的有趣的尝试。使用了另一个 JavaScript 的新特性:proxy。proxy 会包住一个对象,然后我们就可以跟这个对象进行各种各样的交互。
- proxy 提供了很多种拦截对象行为的方式。这里我们感兴趣的是读取对象属性的行为。我并不会完整的解释 proxy 是如何工作的,所以如果你想要了解的更多,可以查看我们的另一篇文章:JavaScript Object Property Descriptors, Proxies, and Preventing Extension
- 我们可以使用代理来展示对象上可用的属性。这里我们先创建一个 proxy 来隐藏两个属性,一个是字符串 _favColor,另一个是 symbol 叫 favBook。
let proxy; { const favBook = Symbol('fav book'); const obj = { name: 'Thomas Hunter II', age: 32, _favColor: 'blue', [favBook]: 'Metro 2033', [Symbol('visible')]: 'foo' }; const handler = { ownKeys: (target) => { const reportedKeys = []; const actualKeys = Reflect.ownKeys(target); for (const key of actualKeys) { if (key === favBook || key === '_favColor') { continue; } reportedKeys.push(key); } return reportedKeys; } }; proxy = new Proxy(obj, handler); } console.log(Object.keys(proxy)); // [ 'name', 'age' ] console.log(Reflect.ownKeys(proxy)); // [ 'name', 'age', Symbol(visible) ] console.log(Object.getOwnPropertyNames(proxy)); // [ 'name', 'age' ] console.log(Object.getOwnPropertySymbols(proxy)); // [Symbol(visible)] console.log(proxy._favColor); // 'blue'
- 发现 _favColor 属性很简单,只需要阅读源码即可,另外,动态的 key 可以通过暴力破解方式获得(例如前面的 uuid 例子)。但是对 symbol 属性,如果你没有直接的引用,是无法访问到
Metro 2033
这个值的。 - Node.js 备注:有一个特性可以破解私有属性,这个特性不是 JavaScript 的语言特性,也不存在与其他场景,例如 web 浏览器。当使用 proxy 时,你可以获取到对象隐藏的属性。这里有一个破解上面私有属性的例子:
const [originalObject] = process .binding('util') .getProxyDetails(proxy); const allKeys = Reflect.ownKeys(originalObject); console.log(allKeys[3]); // Symbol(fav book)
- 我们现在要么修改全局的 Reflect 对象,要么修改 util 的方法绑定,来组织他们被某个 Node.js 实例访问。但这是一个无底洞,如果你有兴趣深挖,可以看这篇文章:Protecting your JavaScript APIs
相关推荐
nmgxzm00 2020-11-10
ifconfig 2020-10-14
hhanbj 2020-11-17
zfszhangyuan 2020-11-16
古叶峰 2020-11-16
一个智障 2020-11-15
jipengx 2020-11-12
81427005 2020-11-11
xixixi 2020-11-11
游走的豚鼠君 2020-11-10
苗疆三刀的随手记 2020-11-10
Web卓不凡 2020-11-03
小飞侠V 2020-11-02
帕尼尼 2020-10-30
爱读书的旅行者 2020-10-26
帕尼尼 2020-10-23
杏仁技术站 2020-10-23
淼寒儿 2020-10-22