《JavaScript 模式》读书笔记（5）— 对象创建模式2

var myobj = {
    myprop:1,
    getProp: function() {
        return this.myprop;
    }
};
console.log(myobj.myprop); // 'myprop'是共有可访问的
console.log(myobj.getProp()); //getProp()也是公有可访问的

// 当使用构造函数创建对象时也通用如此，即所有的成员仍然都是公共的：
function Gadget() {
    this.name = 'iPod';
    this.stretch = function () {
        return 'iPad';
    };
}
var toy = new Gadget();
console.log(toy.name); // 'name'是共有的
console.log(toy.stretch()); //stretch()是公有的

function Gadge() {
    // 私有成员
    var name = 'iPod';
    // 公有函数
    this.getName = function () {
        return name;
    };
}
var toy = new Gadge();

// 'name'是undefined的，它是私有的
console.log(toy.name);//undefined

// 公有方法访问'name'
console.log(toy.getName());// 'iPod'

function Gadget() {
    // 私有成员
    var specs = {
        screen_width:320,
        screen_height:480,
        color:"white"
    };
    // 公有函数
    this.getSpecs = function () {
        return specs;
    };
}

// 这里的问题是在于getSpecs()方法返回了一个引用的specs对象。这使得Gadget的用户可以修改表面上看起来是隐藏和私有的specs对象：
var toy = new Gadget(),
    specs = toy.getSpecs();
specs.color = "black";
specs.price = "free";

console.dir(toy.getSpecs());    

var myobj; //这将会是对象
(function() {
    // 私有成员
    var name = 'my,oh my';

    // 实现公有部分
    // 注意，没有'var'修饰符
    myobj = {
        // 特权方法
        getName: function () {
            return name;
        }
    };
}());
myobj.getName(); //'my, oh my';

// 下面的例子与上面的具有同样的思想，但是在实现上略有不同：
var myobj = (function () {
    // 私有成员
    var name = 'my,oh my';

    // 实现公有部分
    return {
        getName:function () {
            return name;
        }
    };
}());
// 这个例子也是模块模式的基础框架，后面会再聊。

function Gadget() {
    // 私有成员
    var name = 'iPod';
    // 公有函数
    this.getName = function () {
        return name;
    };
}

Gadget.prototype = (function () {
    // 私有成员
    var browser = "Mobile Webkit";
    // 公有原型成员
    return {
        getBrowser: function() {
            return browser;
        }
    };
}());

var toy = new Gadget();
console.log(toy.getName()); //自身特权方法
console.log(toy.getBrowser());// 原型特权方法

var myarray;
(function () {
    var astr = "[Object Array]",
        toString = Object.prototype.toString;
    
    function isArray(a) {
        return toString.call(a) === astr;
    }

    function indexOf(haystack,needle) {
        var i = 0,
            max = haystack.length;
        
        for(;i < max; i += 1) {
            if(haystack[i] === needle) {
                return i;
            }
        }
        return -1;
    }
    myarray = {
        isArray:isArray,
        indexOf:indexOf,
        inArray:indexOf
    }
}());

// 上面的例子中，有两个私有变量以及两个私有函数，isArray()和indexOf()。
// 在匿名函数（immediate function）的最后，对象myarray中填充了认为适用于公共访问的功能。
// 在这种情况下，同一个私有函数indexOf()可以暴露为ES5风格的indexOf以及PHP范式的inArray。
myarray.isArray([1,2]); // true
myarray.isArray({0:1}); // false
myarray.indexOf(["a","b","z"],"z"); // 2
myarray.inArray(["a","b","z"],"z"); // 2

// 现在，如果发生了意外的情况，例如公共indexOf()方法发生意外，但私有indexOf()方法仍然是安全的，因此inArray()将继续正常运行：
myarray.indexOf = null;
myarray.inArray(["a","b","z"],"z"); // 2

MYAPP.namespace('MYAPP.utilities.array');
// 下一步是定义该模块。对于需要保持私有性的情况，本模式使用了一个可以提供私有作用域的即时函数。
// 该即时函数返回了一个对象，即具有公共接口的实际模块，可以通过这些接口来使用这些模块。
MYAPP.utilities.array = (function () {
    return {
        // todo...
    }
}());

// 接下来我们向该公共接口添加一些方法：
MYAPP.utilities.array = (function () {
    return {
        inArray:function(needle,haystack) {
            // ...
        },
        isArray:function(a) {
            // ...
        }
    };
}());

MYAPP.namespace('MYAPP.utilities.array');

// 接下来我们向该公共接口添加一些方法：
MYAPP.utilities.array = (function () {
    // 依赖
    var uobj = MYAPP.utilities.object,
        ulang = MYAPP.utilities.lang,
    // 私有属性
    array_string = "[Object Array]",
    ops = Object.prototype.toString;

    // 私有方法
    // ...

    // var 变量定义结束

    // 可选的一次性初始化过程
    // ...

    return {
        inArray:function(needle,haystack) {
            for(var i = 0;i < haystack.length; i += 1) {
                if(haystack[i] === needle) {
                    return true;
                }
            }
        },
        isArray:function(a) {
            return ops.call(a) === array_string;
        }
        // 更多方法和属性
    };
}());

MYAPP.namespace('MYAPP.utilities.array');

MYAPP.utilities.array = (function () {
    // 私有属性
    var array_string = "[Object Array]",
    ops = Object.prototype.toString,
    // 私有方法
    inArray = function (needle,haystack) {
        for(var i = 0;i < haystack.length; i += 1) {
            if(haystack[i] === needle) {
                return true;
            }
        }
        return -1;
    },
    isArray = function(a) {
        return ops.call(a) === array_string;
    }
    // var 变量定义结束

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

MYAPP.namespace('MYAPP.utilities.Array');

MYAPP.utilities.Array = (function () {
    // 依赖
    var uobj = MYAPP.utilities.object,
        ulang = MYAPP.utilities.lang,

    // 私有属性和方法
    Constr;

    // var 变量定义结束

    // 可选的一次性初始化过程
    // ...

    // 公有API——构造函数
    Constr = function(o) {
        this.elements = this.toArray(o);
    };
    // 公有API——原型
    Constr.prototype = {
        constructor:MYAPP.utilities.Array,
        version:"2.0",
        toArray:function(obj) {
            for(var i = 0,a = [],len = obj.length; i < len; i += 1) {
                a[i] = obj[i]
            }
            return a;
        }
    };

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

// 这样使用
var arr = new MYAPP.utilities.Array(obj);

MYAPP.utilities.module = (function(app,global) {
    // 引用全局对象
    // 以及现在被转换成局部变量的全局应用程序命名空间对象
}(MYAPP,this));