单例模式（Signleton）：又被称为单体模式，是只允许实例化一次的对象类。
有时我们也用一个对象来规划一个命名空间，井井有条地管理对象上的属性和方法。

一，命名空间

命名空间就是人们所说的 namespace，也称为名称空间。
由于不同的人定义的变量或者方法使用的单词名称可能重复，此时就需要用命名空间来约束每个人定义的变量来解决这类问题。

  1. var Ming = {
  2.     g: function(id) {
  3.       return document.getElementById(id)
  4.   },
  5.   css: function(id, key, value) {
  6.     // 通过当前对象 this 来使用 g 方法
  7.       this.g(id).style[key] = value
  8.   }
  9. }

二，创建一个小型代码库

我们以后写自己的小型方法库的时候也可以用单例模式来规范我们自己代码库的各个模块。
比如，我们有一个 A 库，它包含公用模块、工具模块、ajax 模块和其他模块。

  1. var A = {
  2.     Util: {
  3.       util_method1: function() {},
  4.     util_method2: function() {}
  5.   },
  6.   Tool: {
  7.       tool_method1: function() {},
  8.     tool_method2: function() {}
  9.   },
  10.   Ajax: {
  11.       get: function() {},
  12.     post: function() {}
  13.   },
  14.   Others: {
  15.       // ...
  16.   }
  17. }
  19. // 使用如下
  20. A.Util.util_method1();
  21. A.Ajax.get();

三，无法修改的静态变量

  1. var Conf = (function() {
  2.     // 私有变量
  3.   var conf = {
  4.       MAX_NUM: 100,
  5.     MIN_NUM: 1,
  6.     COUNT: 1000
  7.   }
  8.   // 返回取消器对象
  9.   return {
  10.       // 取指器方法
  11.     get: function() {
  12.         return conf[name] ? conf[name] : null;
  13.     }
  14.   }
  15. })();

“很奇妙呀，没有赋值器我们就不能修改内部定义的变量了。“

  1. // 使用如下
  2. var count = Conf.get('COUNT');
  3. console.log(count); // 1000

静态变量采用大写

四，惰性实例

有时候对于单例对象需要延迟创建，所以在单例中还存在一种延迟创建的形式，有人也称之为”惰性创建“。

  1. // 惰性载入单例
  2. var LazySignle = (function() {
  3.     var _instance = null;
  4.   // 单例
  5.     function Signle() {
  6.       return {
  7.         publicMethod: fucntion() {},
  8.       publicProperty: '1.0'
  9.     }
  10.   }
  11.   // 获取单例对象接口
  12.   return function() {
  13.         if (!_instance) {
  14.         _instance = Signle()
  15.     } else {
  16.         return _instance;
  17.     }
  18.     }
  19. })();
  21. // 测试如下
  22. console.log(LazySignle().publicProperty); // 1.0