【读书笔记】读《JavaScript模式》 - 对象创建模式

　　JavaScript是一种简洁明了的语言，其中并没有在其他语言中经常使用的一些特殊语法特征，比如命名空间(namespace)、模块(module)、包(package)、私有属性(private property)，以及静态成员等语法。

　　当然，我们使用其他方式来模拟实现上述语法特征。

 /**
  * 1.命名空间模式
  *     1>命名名称的选取：应用程序(QIANGBA)或库的名称(TIANLANG)、域名或公司(CYOU)名称
  *     2>通用命名空间
  *         注意名称覆盖的问题
  *         //不安全的代码
  *         var MYAPP = {};
  *         //更好的代码
  *         if (typeof MYAPP === 'undefined') {
  *             var MYAPP = {};
  *         }
  *         //或者用更短的语句
  *         var MYAPP = MYAPP || {};
  *         由此，我们不必太过担心加载顺序了。
  * 2.声明依赖关系
  * 3.私有属性和方法
  *     1>私有成员(函数字面量来实现私有性)
  *     function Gadget() {    //仅仅是一个包含私有数据的函数，我们可以用一个立即执行的匿名函数来替换之。
  *         //私有成员
  *         var name = 'iPod';
  *         //公有函数
  *         this.getName = function () {    //特权函数
  *             return name;
  *         }
  *     }
  *     2>特权方法
  *     3>私有性失效
  *     4>对象字面量以及私有性
  *     var myobj = (function () {
  *        //私有成员
  *        var name = 'oh my baby';
  *        //实现公有部分
  *        return {
  *            getName: function () {
  *                return name;
  *            }
  *        }
  *    })();
  *    myobj.getName();    //oh my baby
  *     5>原型和私有性
  *         为了避免复制工作以及节省内存，可以将常用属性和方法添加到构造函数的prototype属性中。
  *  6>将私有方法揭示为公共方法
  *  var myarray;
     (function () {
         var astr = '[Object Array]',
             toString = Object.prototype.toString;
         function isArray(a) {
             return toString.call(a) === atr;
         }
         function indexOf(haystack, needle) {
             var i = 0,
                 max = haystack.length;
             for (; i < max; i++) {
                 if (haystack[i] === needle) {
                     return i;
                 }
             }
             return -1;
         }
         myarray = {
             isArray: isArray,
             indexOf: indexOf,    //当公共indexOf方法发生了意外(如myarray.indexOf = null)，
                                 //但私有indexOf()方法仍然是安全的，此时inArray将继续正常运行
             inArray: indexOf
         }
     })();
  */

 /**
  * 4.模块模式
  *     1>命名空间
  *     2>即时函数
  *     3>私有和特权成员
  *     4>声明依赖
  *
  *     ----------- (a)揭示模块模式 -------------
  * //(1)建立一个命名空间
     MYAPP.namespace('MYAPP.utilities.array');
     //(2)定义模块
     MYAPP.utilities.array = (function () {    //用即时函数进行包围
             //声明依赖
         var uobj = MYAPP.utilities.object,
             ulang = MYAPP.utilities.lang,

             //私有属性
             array_string = '[Object Array]',
             ops = Object.prototype.toString,

             //私有方法
             isArray = function (a) {
                 return opts.call(a) === array_string;
             };
             inArray = function (haystack, needle) {
                 var i = 0,
                     max = haystack.length;
                 for (; i < max; i++) {
                     if (haystack[i] === needle) {
                         return i;
                     }
                 }
                 return -1;
             };

         //揭示公有API
         return {
             isArray: isArray,
             indexOf: inArray
         };

     })();

     ----------- (b)创建构造函数的模块 -------------
     MYAPP.namespace('MYAPP.utilities.array');
     MYAPP.utilities.array = (function () {    //用即时函数进行包围
             //声明依赖
         var uobj = MYAPP.utilities.object,
             ulang = MYAPP.utilities.lang,

             //私有属性
             Constr;

         //公有API
         Constr = function (o) {
             this.elems = this.toArray(o);
         };

         Constr.prototype = {
             constructor: MYAPP.utilities.Array,
             version: '2.0',
             toArray: function (obj) {
                 for (var i = 0, a = [], len = obj.length; i < len; i++) {
                     a[i] = obj[i];
                 }
                 return a;
             }
         };

         //返回要分配给新命名空间的构造函数
         return Constr;
     })();

     ----------- (c)将全局变量导入到模块中 -----------
     MYAPP.utilities.module = (function (app, global) {
         //引用全局变量对象
         //引用现在被转换成局部变量的全局应用程序命名空间对象(app)
     })(MYAPP, this);
  */

 /**
  * 5.静态成员
  *     1>公有静态成员
  * //构造函数
     var Gadget = function () {};
     //静态方法
     Gadget.isShiny = function () {
         return 'you bet';
     };
     //向该原型中添加普通方法
     Gadget.prototype.setPrice = function (price) {
         this.price = price;
     };
     2>私有静态成员(普通闭包)
  */

 /**
  * 6.链模式
  *     return this;实现
  */

 /**
  * 7.method()方法
  */