JavaScript静态和常量

22 Jul

JavaScript模块里介绍了用模块实现封装的方式。传统OO语言里还有两个重要特性就是静态和常量,但JavaScript里没有static和const关键字。本篇就介绍一下JavaScript里如何实现它们。

静态

分公有静态和私有静态。公有静态成员是不需要实例化对象就能直接运行的:

var Person = function () {};    //构造函数

Person.sayHi = function () {  //公有静态方法
    return "hi";
}
Person.prototype.setAge = function (a) { //实例方法
    this.age = a;
}
Person.prototype.getAge = function (a) { //实例方法
    return this.age;
}

Person.sayHi();         //hi

var p1 = new Person();
p1.setAge(33);
console.log(p1.getAge());   //33

var p2 = new Person();
p2.setAge(25);
console.log(p2.getAge());   //25

console.log(typeof Person.sayHi);    //function
console.log(typeof Person.setAge);   //undefined
console.log(typeof Person.getAge);   //undefined
console.log(typeof p1.sayHi);        //undefined
console.log(typeof p1.setAge);       //function
console.log(typeof p1.getAge);       //function

上例中静态方法可以直接运行,而实例化的对象里并不存在静态方法。因此实例化对象的改变不会影响到静态成员。

如果要静态方法与实例方法一起工作,很简单,可采用外观模式的思想来组织代码:

Person.prototype.sayHi = Person.sayHi;
p1.sayHi();   //hi

但上面这样的话,在静态方法内使用this要小心。Person.sayHi();里的this指向Person的构造函数。p1.sayHi();里的this指向p1,基于这个特点,可以让静态和非静态都调用同一个方法,让其行为不同:

var Person = function (n) { //构造函数
    this.name = n;
};
Person.sayHi = function () {  //静态方法
    var msg = "hi";
    if (this instanceof Person) {   //实例调用静态方法
        msg += (" " + this.name);
    }
    return msg;
}
Person.prototype.sayHi = function () {    //实例方法
    return Person.sayHi.call(this);
}

Person.sayHi();   //hi,因为this是function
var p1 = new Person("Jack");
p1.sayHi();  	 //hi Jack,因为this是object

私有静态成员,对该类的用户而言是不可见的,但仍旧可以在类的多个实例间共享。

var Count = (function () {
    var counter = 0;    //私有静态属性

    return function () {
        console.log(counter+=1);
    }
}());

var c1 = new Count();  //1
var c2 = new Count();  //2
var c3 = new Count();  //3

这种静态属性其实很有用,可以通过特权方法将其公开,例如增加一个getLastCount():

var Count = (function () {
    var counter = 0,    //私有静态属性
        NewCount;

    NewCount = function () {    //新构造函数
        counter += 1;
    }
    NewCount.prototype.getLastCount = function () {
        return counter;
    }

    return NewCount;    //覆盖构造函数
}());

var c1 = new Count();
console.log(c1.getLastCount());    //1
var c2 = new Count();
console.log(c2.getLastCount());    //2
var c3 = new Count();
console.log(c3.getLastCount());    //3

在单例模式中常见该例子。

公有或私有的静态成员会带来很多便利,它们独立于实例对象,不受实例对象的影响,可以将需要共享,非实例相关的属性或方法定义成静态。

常量

自定义的常量通常用大写字母,但这只是一种约定,无意中改了也不易发现。如果没必要做的这么严谨,或团队对这潜规则都心知肚明,那用大写字母就OK了。否则的话,我们希望有真正的常量,例如:

Math.PI = 2;
console.log(Math.PI);	//3.1415926,不变

我们可以自定义一个常量模块,提供3个方法:isDefined验证该常量是否已经被定义过。get / set方法用于取设常量。一旦常量被set过后,就无法再次被set。

var constant = (function () {
    var constants = {},
        ownProp = Object.prototype.hasOwnProperty,
        allowed = {
            string: 1,
            number: 1,
            boolean: 1
        },
        perfix = (Math.random() + "_").slice(2);

    return {
        isDefined: function (name) {        //是否已经定义过
            return ownProp.call(constants, perfix + name);
        },
        set: function (name, value) {
            if (this.isDefined(name)) {
                return false;
            }
            if (!ownProp.call(allowed, typeof value)) {
                return false;
            }
            constants[perfix + name] = value;
            return true;
        },
        get: function (name) {
            if (this.isDefined(name)) {
                return constants[perfix + name];
            }
            return null;
        }
    };
}());

console.log(constant.isDefined("maxwidth")); //false
console.log(constant.set("maxwidth", 200));  //true
console.log(constant.get("maxwidth"));       //200
console.log(constant.isDefined("maxwidth")); //true
console.log(constant.set("maxwidth", 400));  //false
console.log(constant.get("maxwidth"));       //200不变

其他细节说明一下,被定义的常量,统一保持到私有属性constants里。只支持allowed里的3种类型的值(当然你可以扩展或删减)。为保证常量名和内置属性名不冲突(例如用户定义一个名叫toString的常量),在模块内部给常量名加上随机数前缀。

Leave a Reply

Your email address will not be published. Required fields are marked *