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的常量），在模块内部给常量名加上随机数前缀。