1,命名空间模式 namespace
var myApp = {};//通过全局变量来实现命名空间
maApp.Parent = function (){
};
myApp.Child = function(){
};
script>
通用命名空间函数
//不安全代码
var myApp = {};
//安全代码
if(typeof myApp === "undefined"){
var myApp = {};
}
//或者使用更短的语句
var myApp = myApp || {};
script>
使用命名空间函数
myApp.namespace("myApp.modules.module2");
//等同于如下代码
var myApp = {
modules : {
module2:{}
}
};
script>
var myApp = myApp || {};
myApp.namespace = function(ns_string){
var parts = ns_string.split('.'), parent = myApp, i;
if(parent[0] === "myApp"){
parts = parts.slice(1);
}
for(i = 0; i < parts.length; i++){
if(typeof parent[parts[i]] === "undefined"){
parent = parent[parts[i]];
}
}
return parent;
};
var modules2 = myApp.namespace("myApp.modules.module2");
console.log(modules2 === myApp.modules.module2);
myApp.namespace("modules.module2");
script>
2,声明依赖关系
js库通常是模块化且依据命名空间组织的。
var myFunction = function(){ var event = YAHOO.util.event, dom = YAHOO.util.Dom; }
3,私有属性和方法
JS并没有特殊的语法来表示私有。JS中所有对象的成员是公共的。
var myObj = {
myProp : 1,
getPro: function(){
return this.myProp;
}
};
console.log(myObj.myProp);
console.log(myObj.getPro());
但是可以使用闭包实现成员私有化。
function Gadget(){
//私有成员
var name = "iPoid";
//共有函数
this.getName = function(){
return name;
};
}
var toy = new Gadget();
console.log(toy.name);//undefined
console.log(toy.getName);//iPoid
script>
私有性失效:因为涉及到引用传值,如果传递私有属性给外部,则外部可直接访问私有属性,如下:
function Gadget(){
//私有成员
var specs = {
screen_width: 320,
screen_hight: 650,
color: 'RED'
};
//共有函数
this.getSpecs = function(){
return specs;
};
}
var toy = new Gadget(),
specs = toy.getSpecs();
specs.color = "GUESS";
console.log(specs.screen_width);//320
console.log(specs.color);//GUESS
console.dir(toy.getSpecs());
script>
4,对象字面量以及私有属性
var myObj = (function(){
var name = "name";
return {
getName: function(){
return name;
}
};
}());
console.log(myObj.getName());//name
script>
5,原型和私有性
通过prototype可以动态的给对象添加属性和方法。
function Gadget(){
var name = "Ipod";
this.getName = function(){
return name;
};
}
Gadget.prototype = (function(){
var browser = "others";
return{
getBrowser: function(){
return browser;
}
};
}());
var toy = new Gadget();
console.log(toy.getName());//name
console.log(toy.getBrowser());//others
script>
6,将私有方法揭示为公共方法
通过全局变量可以将匿名函数的私有方法公开。
var myArray;
(function(){
var astr = "[object Array]",
toString = Object.prototype.toString;
function isArray(s){
return toString.call(s) === 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};
console.log(myArray.isArray([1, 2]));//true
console.log(myArray.isArray({ 0 : 1}));//false
console.log(myArray.indexOf(["a", "b"], "a"));//0
console.log(myArray.indexOf(["a", "b"], "d"));//-1
}());
console.log(myArray.indexOf(["a", "b"], "a"));//0
console.log(myArray.indexOf(["a", "b"], "d"));//-1
script>
7,模块模式
模块模式通过命名空间,完成函数变量定义和使用。
myApp.namespace("myApp.util.array");
myApp.util.array = (function(){
var uobj = myApp.util.object,
ulang = myApp.util.lang,
array_string = "[object Array]",
ops = Object.prototype.toString;
return {
inArray: function(needle, haystack){
for(var i = 0, max = haystack.length; i < max; i+= 1){
if(haystack[i] === needle){
return true;
}
}
},
isArray: function(s){
return ops.call(a) === array_string;
}
};
}());
script>
通过揭示模式暴漏想暴漏的方法。
myApp.namespace("myApp.util.array");
myApp.util.array = (function(){
var uobj = myApp.util.object,
ulang = myApp.util.lang,
array_string = "[object Array]",
ops = Object.prototype.toString;
inArray: function(needle, haystack){
for(var i = 0, max = haystack.length; i < max; i+= 1){
if(haystack[i] === needle){
return true;
}
}
},
isArray: function(s){
return ops.call(a) === array_string;
};
return {
isArray: isArray,
indexOf: inArray
};
}());
script>
创建构造函数的模块
myApp.namespace("myApp.util.array");
myApp.util.array = (function(){
var uobj = myApp.util.object,
ulang = myApp.util.lang;
Constr;
Constr = function(o){
this.elements = this.toArray(o);
};
//共有API原型
Constr.prototype = {
constructor: myApp.util.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.util.array([obj]);
script>
8,将全局变量导入到模块中
MYAPP.util.module = (function(app, global){
//
}(MYAPP, this));
script>
9,沙箱模式
沙箱模式解决命名空间模式的如下特点:
-1,对单个全局变量的依赖变成了对应用程序的全局变量依赖。在命名空间模式中,是没有办法使用同一个应用程序或库的两个版本在同一页面中,因为这两者都需要同一个全局符号名。
-2,对这种以点分割的名字来说,需要输入更长的字符,同时解析时需要更长的时间。如:myapp.a.b.c.d
沙箱模式提供了一个可用于模块运行的环境,且不会对其他模块和沙箱造成影响。
10,全局构造函数
最基础的使用如下图所示
new Sandbox(function(box){
//write your code
});
script>
通过以下两种方式扩展属性:
-1,在创建对象的时候不实用new操作符。
-2,Sandbox()狗仔函数可以接受一个额外的配置参数,其中改参数制订了对象事例所需要的模块名。
Sandbox(['ajax', 'event'], function(box){
//your code
});
script>
或者,
Sandbox('ajax', 'event', function(box){
//your code
});
script>
一个沙箱中可以继续使用一个沙箱模块。
Sandbox('dom', 'event', function(box){
//your code
Sandbox('ajax', function(box){
//your cide
})
//此处无法获取ajax
});
script>
11,增加模块
Sandbox.modules = ();
Sandbox.modules.dom = function(box){
box.getElement = function(){};
box.getStyle = function(){};
box.foo = "bar";
};
Sandbox.modules.event = function(box){
//如果需要,可以通过如下语句访问Sandbox原型
//box.constructor.prototype.m = "mmmmm";
box.attachEvent = function(){};
box.dettachEvent = function(){};
};
Sandbox.modules.ajax = function(box){
box.makeRequest = function(){};
boix.getResponse = function(){};
}
script>
12,实现构造函数
function Sandbox(){
//将参数转为一个数组
var args = Array.prototype.slice.call(arguments),
//最后一个参数是回调函数
callback = args.pop(),
//模块可以做为一个数组传递,或作为单独的参数传递
modules = (args[0] && typeof args[0] === "string") ? args : args[0],
i;
//确保该函数做为狗仔函数被调用
if(! (this instanceof Sandbox)){
return new Sandbox(modules, callback);
}
//向this添加属性
this.a = 1;
this.b = 2;
//向this对象添加模块
//不制定模块或指定“*”都表示使用所有模块
if(!modules || modules === "*"){
for(i in Sandbox.modules){
if(Sandbox.modules.hasOwnProperty(i)){
moduls.push(i);
}
}
}
//初始化模块
for(i = 0; i < modules.length; i+= 1){
Sandbox.modules[[moduls[i]]](this);
}
callback(this);
}
Sandbox.prototype = {
name: "My Application",
version: "1.00",
getName: function(){
return this.name;
}
};
script>
以上代码的关键部分:
-1,存在一个类型的检查语句,检查this是否为Sandbox的实例。
-2,可以在该构造函数中将一些属性添加到this中。
-3,所需的模块可以魔窟名称数组的形式传递。
13,公有静态成员
//构造函数
var Gadget = function(){};
//静态方法
Gadget.isShiny = function(){
return "Static Method!";
};
//原型添加方法
Gadget.prototype.setPrice = function(price){
this.price = price;
};
console.log(Gadget.isShiny());//Static Method!
var iphone = new Gadget();
iphone.setPrice(500);
console.log(typeof Gadget.setPrice);//undefined
console.log(typeof iphone.isShiny);//undefined
Gadget.prototype.isShiny = Gadget.isShiny;
console.log(iphone.isShiny());//Static Method!
script>
14,私有静态成员
-1,以同一个构造函数创建的所有对象共享该成员
-2,构造函数外部不可访问该成员。
var Gadget = (function(){
var counter = 0;
return function(){
console.log(counter += 1);
}
}());//立即执行
var g1 = new Gadget();//1
var g2 = new Gadget();//2
script>
15,链模式
如:
myObj.method1("11").method2("w").method3();
16,method方法
var Person = function(name){
this.name = name;
}.method("getName", function(){
return this.name;
});