javascript篇：创建对象模式

/*
对象创建模式
除了普通的对象字面量和使用构造函数来创建对象外，还有很多更好的对象创建模式
1、命名空间 2、依赖声明 3、模块模式 4、沙箱模式
它们都帮助我们组织应用程序的代码结构，降低隐含地全局变量带来的后果
*/

/*Before*/
// 反模块设计
Parent = function() {}
Child = function() {}
module1 = {}
module1.data = [1,2,3,4]
module2 = {}

/*
命名空间
*/
var NEWAPP = {}

NEWAPP.Parent = function() {}
NEWAPP.Child = function() {}
NEWAPP.modules = {}
NEWAPP.modules.module1 = {}
NEWAPP.modules.module1.data = [1,2,3,4]
NEWAPP.modules.module2 = {}

/*
优点在于避免了命名冲突，
缺点在于代码量增加、任何部分的代码都可以修改该全局实例、解析查询时间变长
*/

/*
为了保证我们声明的全局变量不会和其他文件的变量冲突，可以进行判断是否已经存在
*/
if(typeof NEWAPP === "undefined") {
...
}
or

var NEWAPP = NEWAPP || {};

/*
附加的检查会增加代码的重复和量，将其封装为一个函数来调用
*/
var NEWAPP = NEWAPP || {};
NEWAPP.namespace = function(ns_string) {
var parts = ns_string.split('.'),
parent = NEWAPP,
i
;
if (parts[0] === "NEWAPP") {
parts = parts.slice(1);
}
for (i = 0, len = parts.length; i < len; i++) {
if (typeof parent[parts[i]] === "undefined") {
parent[parts[i]] = {}
}
parent = parent[parts[i]];
}
return parent;
};
// 将返回值赋给一个局部变量
var module1 = NEWAPP.namespace('NEWAPP.modules.module1');
// return true
console.log(module1 === NEWAPP.modules.module1);

/*
声明依赖关系
*/
var myFunction = function() {
// 依赖
var event = NEWAPP.util.Event,
dom = NEWAPP.util.dom
;
// 使用时间和Dom变量
}
// 显示地声明了使用到的脚本文件，
// 局部变量的解析速度快过全局变量的解析且只解析一次全局变量，
// 局部变量可压缩

/*
私有成员和方法
*/
// 对于字面量创建的对象和构造函数使用“this”关键字创建的变量和方法，在外部是可以进行访问和修改的
// 想将方法和属性变成私有，只需要让它成为函数的局部变量
function inner() {
var name = "cjs";
this.getName = function() {
return name;
};
}
var out = new inner();
// 无法获取name
console.log(out.name);
// 通过函数getname获取
// 这个方法就是特权方法
console.log(out.getName);
// 切记不要返回对象或者数组的引用，

/*
通过对象字面量以及私有性
*/
// 使用一个即时运行的匿名函数创建闭包来实现私有性
var obj = {}
(function() {
// 私有成员
var name = "cjs";
// 共有成员，没有var！
obj = {
getName : function() {
return name;
}
};
}());
// return name
obj.getName();

// 也可以直接：
var obj = (function() {
var name = "cjs";
return {
getName :function() {
return name;
}
};
}());
obj.getName();

// 这是模块模式的基础框架

/*
原型和私有性
*/
// 对于共有的属性和方法，将其添加到原型对象作为其方法和属性，减少复制工作和节省内存

function obj() {
// 私有成员
var name = "cjs"
// 特权共有方法
this.getname = function() {
return name;
}
}

obj.prototype = (function(){
// 私有成员
var age = 18;
// 公有原型方法
return {
getAge : function() {
return age;
}
}
}());

var obj1 = new obj();
obj1.getname();
obj1.getAge();

/*
揭示revalation 模式model
*/
// 将对象的私有方法通过赋值给外部对象作为其属性将其暴露成公有方法
// 如果暴露的公有方法被篡改，不会影响到其他暴露的公有方法
var obj;
(function(){
var name = "cjs";
var age = 18;
var clothes = {
pants : "black",
shirt : "white",
shoes : "yellow"
}
function getName() {
this.what ="hahahahahha";
return name;
}
function getAge() {
return age;
}
obj = {
getName : getName,
getAge : getAge,
getLocal : getName,
clothes : clothes,
color : clothes,
name : name,
localname : name
};

}());

/*
暴露出来的方法由于只是一个引用，即使被用户修改到，也不会影响到其他使用到内部私有函数的其他公有函数
机智的设计模式，但也只适用于函数，对于对象则不适用，需要进行浅复制将其暴露出来
*/

/*
终极模式--------------------------------------------------------模块模式
前面多种模式的组合，命名空间、即时函数、私有和特权成员、声明依赖
*/
// 命名空间
NEWAPP.namespace("NEWAPP.modules.module1")
NEWAPP.modules.module1 = (function() {
// 依赖声明
var dom = NEWAPP.util.Dom,
_event = NEWAPP.util.Event,

name = "cjs",
age = 18
;

return {
// 公有特权函数
getName : function() {
return name;
},
getAge : function() {
return age;
}
};
}());// 即时函数

/*
揭示模块模式
方法和模块模式是类似的，只不过将方法定义为私有方法，在通过return将函数暴露出来
*/