//发布订阅功能
var event= {
    clientList: [],
    
    //订阅
    listen: function(key,fn) {
      if (!this.clientList[key]) {
          this.clientList[key]=[];
      }
      //订阅的消息进缓存
      this.clientList[key].push(fn);
    },
    
    //发布
    trigger: function() {
      var key = Array.prototype.shift.call(arguments),
          fns=this.clientList[key];
      if (!fns || fns.length===0) {
          return false;
      }
      
      for (var i=0,fn;fn=fns[i++];) {
          fn.apply(this,arguments);
      }
    },
    
    //取消订阅
    remove:function(key,fn) {
      var fns=this.clientList[key];
      if (!fns) {
          return false;
      }
      
      //没有传入回调，表示需要取消key对应的所有回调
      if (!fn) {
          fns && (fns.length =0);
      } else {
          for (var i=0;i<fns.length;i++) {
              var _fn=fns[i];
              if (fn===_fn) {
                  fns.splice(i,1);
              }
          }
      }
    }
} 
//为对象添加发布订阅
var installEvent=function(obj) {
  for (var i in event) {
      if (event.hasOwnProperty(i)) {
          obj[i]=event[i];
      }
  }
}

//先发布后订阅
Event.trigger('click',1);
Event.listen('click',function(a) {
  console.log(a);
})
//使用命名空间
Event.create('namespace1').listen('click',function(a) {
  console.log(a);
})
Event.create('namespace1').trigger('click',1);
//代码实现
var Event=(function() {
  
    var global=this,
     Event,
     _default='default';
    
    Event=function() {
      var _listen,
      _trigger,
      _remove,
      _slice=[].slice,
      _shift=[].shift,
      _unshift=[],unshift,
      namespaceCache={},
      _create,
      find,
      each=function(ary,fn) {
        for (var i=0;i<ary.length;i++) {
            var cur=ary[i];
            fn.call(cur,cur,i);
        }
        
      };
      
      _listen=function(key,fn,cache) {
        if (!cache[key]) {
            
        }
      }
      
    }
    
})()

//用代理模式实现缓存
//先实现一个目标函数 这里是求阶乘
var mult=function() {
  console.log('开始计算阶乘');
  var a=1;
  for (var i=0,cur=arguments[i];i<arguments.length;i++) {
      a=a*cur;
  }
  console.log('输出：',a);
  return a;
}
//缓存结果的代理 调用代理即可
var proxyMult=(function() {
  var cache={};
  return function() {
    var args=Array.prototype.join.call(arguments,',');
    if (args in cache) {
        console.log('输出：',cache[args]);
        return cache[args];
    }
    return (cache[args]=mult.apply(this,arguments));
  }
})()
//这里我们可以更进一步，创建一个 缓存代理的工厂,就可以接受不同的运算规则了
var createProxyfactory=function(fn) {
  var cache={};
  return function() {
    var args=Array.prototype.join.call(arguments,',');
    if (args in cache) {
        return cache[args];
    }
    return cache[args]=fn.apply(this,arguments);
  }
}

var Provider = {
    // ...
    
   //缓存初始化后的组件
    _cache: {},
    
    //返回一个数组 数组为当前函数工厂函数的传参，也就是依赖组件的名称
    annotate: function (fn) {
        var res = fn.toString()
            .replace(/((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg, '')
            .match(/\((.*?)\)/);
        if (res && res[1]) {
            return res[1].split(',').map(function (d) {
                return d.trim();
            });
        }
        return [];
    },
    
    //接下来两个函数将互相调用，调用组件的初始化工厂函数，并循环遍历解决依赖（以及依赖的依赖）
    //解决依赖的意思就是将依赖组件的名称转换成对应组件的工厂函数，传入。
    
    //传入组件名，locals为所有本地依赖的对象集合，返回初始化后的组件
    get: function(name,locals) {
    
      //如果已有缓存的初始化工厂函数，返回他
      if (this._cache[name]) {
          return this._cache[name];
      }
      var provider=this._providers[name];
      if (!provider || typeof provider !=='function') {return;}
      return (this._cache[name] = this.invoke(provider,locals));
    },
    
    //用于初始化一个组件。如果该组件依赖的组件还未初始化，则会先初始化依赖的组件
    invoke: function(fn,locals) {
      locals= locals || {};
      
        //通过依赖名找出依赖的工厂函数
      var deps=this.annotate(fn).map(function(item) {
        return locals[item] || this.get(item,locals);
      },this);
      return fn.apply(null,deps);
    }
}

/*
传入 初始缓存记忆的数组memo 和计算公式formula
返回 一个管理memo存储和在需要时调用formula的函数recur
*/
var memoizer = function(memo,formula) {
  var recur=function(n) {
    var result=memo[n];
    if (typeof result !=='function') {
        result=formula(recur,n);
        memo[n]=result;
    }
    return result;
  };
  return recur;
}

var fibonacci=memoizer([0,1],function(recur,n) {
  return recur(n-1)+recur(n-2);
})

var fibonacci=memoizer([1,1],function(recur,n) {
  return n*recur(n-1);
})

function win (attr,value) {
	if (typeof value !=='undefined') {
		return document.documentElement[attr] ||document.body[attr];
	}
	document.documentElement[attr]=value;
	document.body[attr]=value;
}

function offset (curEle) {
	var l=curEle.offsetLeft;
	var t=curEle.offsetTop;
	var par=curEle.offsetParent;
	//一层层定位祖先向上累加
	while (par) {
		if (window.navigator.userAgent.indexOf('MSIE 8.0')!==-1) {
				l+=par.clientLeft;
				t+=par.clientTop;
		}
		l+=par.offsetLeft;
		t+=par.offsetTop;
		par=par.offsetParent;
	}
	return {left:l,top:t};
}

function getCss (curEle,attr) {
	var val=null;
	try {
		val=window.getComputedStyle(curEle,null)[attr];
	} catch (e) {
		val=curEle.currentStyle[attr];
	}
	return val;
}