技巧型设计模式
27.链模式 return this；
28.委托模式
点击事件委托到父元素上，内存外泄，数据分发
29.数据访问对象模式
var BaseLocalStorage = function(preId,timeSign){
this.preId = preId;
this.timeSign = timeSign || '|-|';
}
BaseLocalStorage.prototype = {
status:{
SUCCESS:0,
FAILURE:1,
OVERFLOW:2,
TIMEOUT:3
},
storage:localStorage || window.localStorage,
getKey:function(key){
return this.preId +key;
},
set:fucntion(key,value,callback,time){
var status = this.status.SUCCESS,
key = thsi.getKey(key);
try{
time = new Date(time).getTime()||time.getTime();
}cache(e){
time = new Date().getTime()+1000*60*60*24*31;
}
try{
this.storage.setTime(key,time+this.timeSign+value);
}catch(e){
status = this.status.OVERFLOW;
}
callback && callback.call(this.status,key,value);
},
get:fucntion(){
var status = this.status.SUCCESS,
key = this.getKey(key),
value = null,
timeSignLen = this.timSign.length,
that=this,
index,
time,
result;
try{
value = that.storage.getItem(key);
}catch(e){
result = {
status:that.status.FAILURE,
value:null
};
callback && callback.call(this,result.status,result.value);
return result;
}
if(value){
index = value.indexOf(that.timeSign);
time =+value.slice(0.index);
if(new Date(time).getTime > new Date().getTime() || time == 0){
value = value.slice(index+timeSignLen);
}else{
value = null,
status = that.status.TIMEOUT;
that.remove(key);
}
}else{
status = that.status.FAILURE;
}
result = {
status:status,
value:value
};
callback && callback.call(this,result.stauts,result.value);
return result;
},
remove:function(){}
var status = this.status.FAILURE,
key = this.getKey(key),
value=null;
try{
value = this.storage.getItem(key);
}cache(e){
if(value){
try{
this.storage.removeItem(key);
status=this.status.SUCCESS;
}catch(e){}
}
callback && callback.call(this,status,status>0?null:value.slice(value.indexOf(this.timeSign)+this.timeSign.length))
}
}
node.js MongoDB
30.节流模式
var throttle = function(){
var isClear = arguments[0],fn;
if(type of isClear === 'boolean'){
fn = arguments[1];
fn._throttleID && clearTimeout(fn._throttleID);
}else{
fn = isClear;
param = arguments[1];
var p = extend({
context:null,
args:[],
time:300
},param);
arguments.call(true,fn);
fn._throttleID = setTimeout(function(){
fn.apply(p.context,p.args)
},p.time)
}
}
31.简单模板模式
var A= A ||{};
A.root = document.getElementById('container');
A.strategy = {
'listPart':function(){}
}
A.init = function(data){
this.strategy[data.type](data);
}
//模板渲染方法
A.formateString = function(str,data){
return str.replace(/\{#(\w+)#\}/g,function(match,key)){
return typeof data[key] === undefined ?'':data[key];
}
}
//模板生成器
32.惰性模式
//加载即执行
var A = {};
A.on = function(dom,type,fn){
if(document.addEventListener){
return function(dom,type,fn){
dom.addEventListener(type,fn ,false);
}
}
}();
//惰性执行
A.on=function(dom,type,fn){
if(dom.addEventListener){
A.on =function(dom,type,fn){
dom.addEventListener(type,fn,false);
}
}
A.on();
}
33.参与者模式
//函数绑定
function bind(fn,context){
return function(){
return fn.apply(context,arguments);
}
}
//函数柯里化
function curry(fn){
var Slice = [].slice;
var args = Slice.call(arguments,1);
return function(){
var addArgs = Slice.call(arguments),
allArgs = args.concat(addArgs);
return fn.apply(null,allArgs);
}
}
//函数柯里化后的函数绑定
function bind(fn,context){
var Slice = Array.prototype.slice,
args = Slice.call(argument,2);
return fucntion(){
var addArgs = Slice.call(arguments),
allArgs = addArgs.concat(args);
return fn.apply(context,allArgs);
}
}
34.等待者模式
var Waiter = function(){
var dfd =[],
doneArr=[],
failArr=[],
slice = Array.prototype.slice,
that=this;
var Primise = fucntion(){
this.resolved = false;
this.rejected = false;
}
Primise.prototype = {
resolved:function(){
this.resolved = true;
if(!dfd.length){
return;
}
for(var i = dfd.length-1;i>=0;i--){
if(dfd[i] && !dfd[i].resolved || dfd[i].rejected){
return;
}
dfd.splice(i,1)
}
_exec(doneArr);
},
reject:function(){
this.rejected = true;
if(!dfd.length){
return;
}
dfd.splice(0);
_exec(failArr);
}
}
that.Deferred = function(){
return new Primise();
}
function _exec(arr){
var i = 0,
len = arr.length;
for(;i<len;i++){
try{
arr[i]&&arr[i]();
}catch(e){}
}
}
this.when = function(){
dfd = slice.call(argument);
var i = dfd.length;
for(--i;i>=0;i--){
if(!dfd[i] || dfd[i].resolved || dfd[i].rejected || !dfd[i] instanceof Peimise){
dfd.splice(i,1);
}
}
return that;
};
that.done = function(){
doneArr = done Arr.concat(slice.call(arguments));
return that;
};
that.fail = function(){}
failArr = failArr.concat(slice.call(arguments));
return that;
}
架构型设计模式
35.同步模块模式
模块定义，模块调用
36.异步模块模式
模块定义，模块调用
37.Widget模式
模板引擎：处理数据，获取模板，处理模板，编译执行
38.MVC模式
39.MVP模式
模型model，视图view，管理器presenter
40.MVVM模式
双向绑定（data-binding）：View的变动，自动反映在 ViewModel
模型model，视图view，视图模型viewmodel
