js中模拟实现私有属性

今天在看《你不知道的js》这本书时,无意看到Object还有个方法叫做 getOwnPropertySymbols() ,用来获取对象的Symbol属性。记得之前看过一些文章说,可以使用Symbol来实现私有属性,如果能直接使用 getOwnPropertySymbols() 方法获取Symbol属性,那还是私有属性么?

今天复习整理一下关于js中创建私有属性的一些问题。

由于js并不是Java那种类式面向对象,因此即使es6添加了class支持,js根上还是基于原型的面向对象,不支持什么私有,公有属性的。

要想实现私有属性,基于现有的js,途径只有一个: 闭包。

至于什么是闭包,网上一大把,有兴趣也可以看看我之前整理的文章

使用原始的闭包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
const User = (function () {
return class User{
constructor(name) {
this.getName = function () {
return name;
}
this.setName = function (name) {
this.getName = function () {
return name;
}
}
}
};
})();

这种方式的确可以实现私有的属性,而且如果有子类继承,也可以如下写法:

1
2
3
4
5
6
7
8
9
10
const Boy = (function () {
return class Boy extends User{
constructor(name){
super(name);
this.getGender = function () {
return 'boy';
}
}
}
})();

但问题也有:

  • 代码组织混乱。由于对构造器函数形成一个闭包,因此所有的setter,getter函数都写在了构造器内。可以从上面的User的写法中看出,setter函数中,还要再定义一遍getter,这中混乱,不是一般能忍受的。如果业务逻辑中还有其他的更多操作,那么混乱程度一下子就上来了。
  • 闭包的内存开销不容小觑。

针对上面的问题,我们可不可以将name单独拿出来放到单独一个地方存储,优化一下代码的组织呢?比如下面这个:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
const User = (function () {
let privateName = null;
return class User{
constructor(name) {
privateName = name;
}
getName(){
return privateName;
}
setName(name) {
privateName = name;
}
};
})();

上面这个例子,貌似是可以的,这样代码也清晰了,也能实现私有属性。

但是,仔细分析一下,真的可以么?

如此的话,是不是所有的实例对象都共享一个 privateName 属性?后面的实例会覆盖前面实例的值。看下面:

1
2
3
4
5
6
const u1 = new User('coolcao');
const u2 = new User('lili');
console.log(u2.getName());
console.log(u1.getName());
// lili
// lili

针对上面的问题,我们使用一个 privateName 保存私有属性,会被覆盖,那么我们如果使用一个数组,保存多个,然后针对每个实例,生成一个唯一的存取标识呢?

基于散列实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const User = (function () {
const privateData = {};
let i = 0;
return class User {
constructor(name){
this['_id'] = i ++;
privateData[this['_id']] = {name: name};
}
getName() {
return privateData[this['_id']].name;
}
setName(name) {
privateData[this['_id']].name = name;
}
};
})();

我们使用 privateData 这个对象来保存所有实例的私有属性,针对每个实例,使用一个id进行标识,每实例化一个实例,该id会自动加1。然后将该id作为键值,将私有属性存入 privateData 对象。
嗯,这样看上去比直接在构造器中使用闭包要清晰多了,而且实例与实例之间也不冲突。

在es6之前,这可能是最合适的方案。虽然也会存在问题:

每个实例对象都会引用 privateData ,因此,还是由于闭包的问题,如果实例太多的话,内存是个问题。

WeakMap实现

幸好 es6 来了,带来了一个叫做 WeakMap 的东西,具体这东西是啥呢?可以看看阮老师的教程

简单说来,WeakMap键名所引用的对象都是弱引用,即垃圾回收机制不将该引用考虑在内。因此,只要所引用的对象的其他引用都被清除,垃圾回收机制就会释放该对象所占用的内存。也就是说,一旦不再需要,WeakMap 里面的键名对象和所对应的键值对会自动消失,不用手动删除引用。

好了,那么上面的这个强引用关系,我们可以使用 WeakMap 弱引用来代替:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
const User = (function () {
const privateData = new WeakMap();
class User {
constructor(name) {
privateData.set(this,{name:name});
}
getName() {
return privateData.get(this).name;
}
setName(name) {
privateData.get(this).name = name;
}
}
})();

如此的代码,干净清爽了许多,而且由于WeakMap是弱引用,如果没有其他引用和该键引用同一个对象,这个对象将会被当作垃圾回收掉。解决了内存泄露的问题。

好了,js模拟闭包,就这几个方式了,从这几个例子来看,都使用了自执行函数(IIFE),因此都会形成闭包。这也是我最开始说的,要想在js实现私有属性,只能使用闭包。

Symbol的问题

话说回来我当初的疑问,ES6的Symbol实现的私有属性有啥问题呢?

看下面例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
const User = (function () {
const NAME = Symbol('User#Name');
return class User{
constructor(name){
this[NAME] = name;
}
getName(){
return this[NAME];
}
setName(name) {
this[NAME] = name;
}
}
})();

NAME是个Symbol,从外部并不能拿到NAME确切的值,好像是有点私有属性的意思。但是 有一个 Object.getOwnPropertySymbols() 方法可以拿到对象所有的Symbol属性,虽然我不知道具体存了个啥,但是能拿到这个标识,就可以修改属性值了:

1
2
3
4
5
6
const smbs = Object.getOwnPropertySymbols(user);
for(let s of smbs) {
user[s] = 'good';
}
console.log(user.getName());
// good

因此,严格意义上说,Symbol其实并不能实现私有属性。

不过倒是可以将上面第二种基于散列的方式改为Symbol的方式:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const User = (function () {
const privateData = {};
return class User {
constructor(name){
this._name = Symbol('name');
privateData[this._name] = {name: name};
}
getName() {
return privateData[this._name].name;
}
setName(name) {
privateData[this._name].name = name;
}
};
})();

这样对外暴露的只是 _name 的这个符号,外部还是无法直接访问每个实例的 privateData 中的值。但这个其实和第二种是一样的,闭包引起的问题还是无法解决。

展望未来

js的私有属性,目前处于 stage2 阶段,目前还未最终确定,不过我们可以先看一下模样:

1
2
3
4
5
6
7
8
9
10
11
12
13
class Point {
#x;
#y;
constructor(x, y) {
this.#x = x;
this.#y = y;
}
equals(point) {
return this.#x === point.#x && this.#y === point.#y;
}
}

语法如上,使用 # 定义私有属性,在类的内部可以直接 使用 this.#x 的形式引用。
目前使用#进行定义和访问私有属性,未来会不会使用 public,private等关键字不得而知。

目前使用#,可能的原因是,js没有静态类型系统。

参考

坚持原创技术分享,您的支持将鼓励我继续创作!