【读书笔记】读《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()方法 
 */