ES6 class 静态属性和私有方法

ES6中新增了class的定义方法,可以说是对JavaScript这门语言的极大丰富。虽然其本质上还是对象,但是对于语言的使用将变得更加明确。在以往的开发中使用function来定义一个类,而现在,直接用class来声明,将和其他语言没有太大差别。

class MyClass {
    constructor() {}
    set(key, value) {}
    get(key) {}
}

静态方法

而且,在ES6中新增了static关键字来修饰静态方法,例如:

class MyClass {
    constructor() {}
    set(key, value) {}
    get(key) {}
    static say(words) {
        alert(words)
    }
}

静态方法将不在实例化对象的方法中,因此里面不能有this,使用的时候必须直接MyClass.say(),实例化对象不拥有这个方法。静态方法将被共享,因此所用内存减少。

实际上,由于JavaScript的语言特性,static关键词修饰的方法相当于:

class MyClass {}
MyClass.say = function() {}

而正是由于这种特性,致使静态属性可以被动态修改,比如:

class MyClass {
    static say() { alert("yes") }
}
MyClass.say = function() { alert("no") }

但是其他语言中的private关键字却没有被ES6实现,因此,我们只能通过其他方式来实现它(虽然将来也是有可能实现的)。

静态属性

ES6中的static只能修饰class的方法,而不能修饰属性,所以在class中,属性只有两种方式:

var sex = 0
class MyClass {
    constructor({name, age}) {
        this.name = name
        this.age = age
    }
    get sex() {
        return sex
    }
    set sex(value) {
        sex = value
    }
}

上面有两种属性的配置方式,一种是在constructor中使用.操作符,另一种则是通过get, set来定义属性。如果只有get sex而没有set sex,那么sex属性是不能被修改的。但是问题是,这两种方法都不是定义一个静态属性,静态属性是不需要实例化的,也就是说可以直接MyClass.sex这样获取。目前已知可用的方式如下:

class MyClass {
    static get sex() {}
    static set sex() {}
}

也就是再get, set前面加static。这样就可以直接使用MyClass.sex的方法获取或动态设置其值,而无需实例化。不过在社区里面,有人提出直接给属性增加static关键字也被babel支持了:

class Test {
  static sAttributes = 'blah'
}

之所以是这种形式,是因为JSX已经支持。但就目前而言,ES标准并不支持这种形式的静态属性设定,所以,这段代码在浏览器中也无法执行。

私有属性

ES中还没有对private的实现方式,也就是说在class中还无法使用这个关键字来修饰私有属性或方法。那么怎么实现私有属性呢?首先,应该明确私有属性的特征:

  • class内部不同方法间可以使用,因此this要指向实例化对象(必须)
  • 不能被外部访问,因此实例化对象$person.name既不能获得值,也不能设定值(必须)
  • 不能被继承,因此extends后子类不具备该属性,但理论上可以重新手工添加(必须)
  • 约定为前面有下划线的this._name形式(备选)

网上有很多种实现形式,目前比较让人认可的,主要是weakmap和symbol两种:

const _name = new WeakMap()
class MyClass {
    constructor({name, age}) {
        _name.set(this, name)
    }
    say() {
        alert(_name.get(this))
    }
}

这种方法说实话,并不是理想的私有属性的方法,虽然利用weakmap可以将this作为键名,但是形式上不好看,还是希望有this._name的解决方案。

const _counter = Symbol('counter');
const _action = Symbol('action');

class Countdown {
    constructor(counter, action) {
        this[_counter] = counter;
        this[_action] = action;
    }
    dec() {
        if (this[_counter] < 1) return;
        this[_counter]--;
        if (this[_counter] === 0) {
            this[_action]();
        }
    }
}

使用symbol的好处就是让形式上更漂亮,虽然采用的是this[_name]而非this._name,但是这理解起来已经非常符合我们的习惯了。但是很明显,它有缺点,即我们可以通过Reflect.ownKeys()在外部获取这些键名,这并不能达到“外部不能访问”的目的。还有一个缺点,就是每多一个键名,就要在顶上新增一个const,使用起来也不够灵活,不过从代码明确性的角度看,这样做也有好处,就是不会忘记自己都定义过哪些私有属性。还有就是,这种方案无法满足“不能被继承”的需求,子类将继续拥有这些属性。

相比起来,weakmap的方案虽然形式上不容易接受,但起码在满足私有属性上面那几点特征上,是符合的。

const _name2 = new WeakMap()
class SubClass extends MyClass {
    showName() {
        alert(_name.get(this))
        alert(_name2.get(this))
    }
}

在MyClass的同一个js文件中,使用SubClass去继承MyClass,_name.get(this)可以获得父类中的值,所以子类中不能继续使用父类定义的weakmap实例。最好的办法,就是将不同的类写在不同的文件里,通过export/import导入父类后再继承。

后来我想,既然weakmap可以做到,为什么不可以用不同的对象实现呢?于是就想到下面的方法来实现:

var attributions = {}
export default class MyClass {
    get(key) {
        return attributions[this] && attributions[this][key]
    }
    set(key, value) {
        if(!attributions[this]) attributions[this] = {}
        attributions[this][key] = value
    }
}

这和很多库或类实现的一样,只不过我们用了一个类外部的变量attributions来作为私有属性的存储介质,而且每一个实例化对象都有自己的存储空间。通过getset方法来获取和设置私有属性,非常好的解决了上面的问题。而且这种方法,如果不看源码,基本在外部是获取不到任何私有属性的,它们也不会被子类继承,当然,get和set方法是可以被继承的。

私有方法

理论上讲,私有属性和私有方法的区别是,私有方法是函数。因此,只需要将上面的私有属性的存储值替换为函数即可。但是作为方法,内部的this必须指向其实例化对象,因此还是需要在稍作加工。

var _say = new WeakMap()
class MyClass {
    constructor({name, age}) {
        this.name = name
        _say.set(this, () => {
            alert(this.name)
        })
    }
}

由于使用了箭头函数,函数体内的this和外部的this是同一个,因此不会发生this指向偏移的问题。

既然私有属性可以使用set, get来实现,为何私有方法不也用它来实现呢?其实,完全没有必要这样去做,就像在class外部加一个attributions一样,我们也可以在class外部创建函数,这些函数只有在同一个文档中可见,因此对外部也是私有的,外部程序无法获取。

var factories = {
    a: function(options) { // 这里一定要用function,而不能用箭头函数,因为使用箭头函数将不能使用bind
        this.render()
    },
}

export default class MyClass {
    render() {}
    call(fun) {
        if(!factories[fun]) return
        return factories[fun].bind(this)
    }
    test() {
        this.call('a')('options') // 使用call来调用私有方法,第一个括号填写函数名,第二个括号填写该函数的参数
    }
}

如果你不想用两个括号那么麻烦,要么不允许传入参数,要么可以用apply代替:

export default class MyClass {
    render() {}
    call(fun, ...args) {
        if(!factories[fun]) return
        return factories[fun].apply(this, args)
    }
    test() {
        this.call('a', options) // 使用call来调用私有方法,第一个括号填写函数名,第二个括号填写该函数的参数
    }
}

如果你还想省事,甚至可以不用把函数都包含在factories里面,直接定义函数,在类里面使用apply:

function my_fun(options) {
  this.render()
}

export default class MyClass {
    render() {}
    test() {
      my_fun.apply(this, 'options')
    }
}

没人会知道你都在类内部使用过哪些私有方法,虽然这些方法实际上都在操作着实例化对象。

2017-02-21 | ,

已有2条评论
  1. peng 2017-12-12 15:40

    hi
    i can’t tpye chinese language in here

    your article is so goooooooooood

    i pretty like your article

    • 否子戈 2017-12-12 17:27

      Thanks! 多交流。有不足之处请指出。