//在Scope中定义任务队列
function Scope () {
	this.$$watchers=[];
	this.$$asyncQueue=[];
}
//定义$evalAsync,传入需要延迟执行的函数
Scope.prototype.$evalAsync=function (fn) {
	this.$$asyncQueue.push({scope:this,expression:fn});
} 
Scope.prototype.$digest=function () {
	var time=10;
	var dirty;
	do {
		while (this.$$asyncQueue.length) {
			var task=this.$$asyncQueue.shift();
			this.$eval(task.expression);
		}
		dirty=this.$$digestOnce();
		if (dirty &&!(time--)) {
			throw '已到10次脏值查询'
		}
	} while (dirty);
}

function equals(o1, o2) {
	//对基本类型值的比较
  if (o1 === o2) return true;
  if (o1 === null || o2 === null) return false;
  //对NaN特殊处理，使得NaN === NaN
  if (o1 !== o1 && o2 !== o2) return true; 
  var t1 = typeof o1, t2 = typeof o2, length, key, keySet;
  //如果比较的值都是对象
  if (t1 == t2 && t1 == 'object') {
    if (isArray(o1)) {
      if (!isArray(o2)) return false;
      //都是数组，遍历数组每一项
      if ((length = o1.length) == o2.length) {
        for (key = 0; key < length; key++) {
          if (!equals(o1[key], o2[key])) return false;
        }
        return true;
      }
    } else if (isDate(o1)) {
      if (!isDate(o2)) return false;
      return equals(o1.getTime(), o2.getTime());
    } else if (isRegExp(o1)) {
      if (!isRegExp(o2)) return false;
      return o1.toString() == o2.toString();
    } else {
      if (isScope(o1) || isScope(o2) || isWindow(o1) || isWindow(o2) ||
        isArray(o2) || isDate(o2) || isRegExp(o2)) return false;
      keySet = createMap();
      for (key in o1) {
        if (key.charAt(0) === '$' || isFunction(o1[key])) continue;
        if (!equals(o1[key], o2[key])) return false;
        keySet[key] = true;
      }
      for (key in o2) {
        if (!(key in keySet) &&
            key.charAt(0) !== '$' &&
            isDefined(o2[key]) &&
            !isFunction(o2[key])) return false;
      }
      return true;
    }
  }
  return false;
}

function clone (obj) {
	var buf;
	if (obj instanceof Array) {
		buf=[];
		var i=obj.length;
		while (i--) {
			buf[i]=clone(obj[i]);
		}
		return buf;
	}
	else if (obj instanceof Object) {
		buf={};
		for (var k in obj) {
			buf[k]=clone(obj[k]);
		}
		return buf;
	}
	else {
		return obj;
	}
}

Scope.prototype.$$$digestOnce=function () {
	var that=this;
	var dirty;
	this.$$watchers.forEach(function (watch){
		var oldVal=watch.last;
		var newVal=watch.watchFn(that);
		if (oldVal!=newVal) {
			watch.listenerFn(newVal,oldVal,that);
			dirty=true;
		}
		watch.last=newVal;
	})
	return dirty;
}
Scope.prototype.$digest=function () {
	var dirty;
	do {
		dirty=this.$$digestOnce();
	} while (dirty)
}

Scope.prototype.$digest=function () {
	var ttl=10;
	var dirty;
	do {
		dirty=this.$$digestOnce();
		if (dirty && !(ttl--)) {
			throw '10 digest iterations reached';
		}
	} while (dirty)
}

Scope.porototype.$watch=function (watchFn,listenerFn,valueEq) {
	var watcher={
		watchFn:watchFn,
		listenerFn:listenerFn,
		//这里通过两次取反，使得强制转换成布尔类型，如果未传递值undefined会被转换成false
		valueEq:!!valueEq
	};
	this.$$watchers.push(watcher);
}

Scope.prototype.$$digestOnce = function() {
  var that  = this;
  var dirty;
  this.$$watchers.forEach(function(watch) {
    var newValue = watch.watchFn(that);
    var oldValue = watch.last;
    if (!that.$$areEqual(newValue, oldValue, watch.valueEq)) {
      watch.listenerFn(newValue, oldValue, that);
      dirty = true;
    }
    watch.last = (watch.valueEq ? this.$$cloneDeep(newValue) : newValue);
  });
  return dirty;
};

Scope.prototype.$$areEqual = function(newValue, oldValue, valueEq) {
  if (valueEq) {
    return this.$$isEqual(newValue, oldValue);
  } else {
    return newValue === oldValue ||
      (typeof newValue === 'number' && typeof oldValue === 'number' &&
       isNaN(newValue) && isNaN(oldValue));
  }
};

function Scope () {
	this.$$watchers=[];
}

Scope.prototype.$watch=function  (watchFn,listenerFn) {
	var watcher={watchFn:watchFn,listenerFn:listenerFn};
	this.$$watchers.push(watcher);
}

Scope.prototype.$digest=function () {
	var self=this;
	this.$$watchers.forEach(function (watcher) {
		var newVal=watcher.watchFn(self);
		var oldVal=watcher.last;
		if (newVal!==oldVal) {
			//如果发现值变化了就调用监听函数
			watcher.listener(newVal,oldVal,self);
		}
		//每次调用都会更新数据
		watch.last=newVal;
	})
}

//用中间件的形式实现
module.exports=function (req,res,next) {
	res.redirect=function (url) {
		//设置http状态码为302（重定向）
		res.statusCode=302;
		//设置响应头,注意状态码与响应头缺一不可
		res.setHeader('Location',url);
		res.end('');
	}
}

//与express配合使用
var express=require('express');
var app=express();
var server=require('http').createServer(app);
var io=require('socket.io')(server);
server.listen(1234);
//检测客户端的连接
io.on('connection',function (socket) {
	
	//检测连接来的客户端发送的信息
	socket.on('message',function (msg) {
	})
	
	//向socket客户端发送消息
	socket.send('123');
})

socket.join('chatroom');   //客户端进入chatroom房间
socket.leave('chatroom');   //客户端立刻chatroom房间

io.emit('message','全局广播');

Socket.prototype.send = function(){
	//ES6方法，类数组转数组
  var args = toArray(arguments);
  //推入事件名message
  args.unshift('message');
  //执行
  this.emit.apply(this, args);
  return this;
};

var WebSocketServer=require('ws').Server;
var server=new WebSocketServer({port:8000});
//监听客户端请求 ,即与客户端握手
server.on('connection',function (websocket){
	
	//监听从客户端传来的信息
	websocket.on('message',function (msg) {
		console.log(msg);
		//向客户端发送信息
		websocket.send(msg);
	})
})

var WebSocket=require('ws');
var ws=new WebSocket('ws://localhost:8080/');
//检测服务器是否开放，即与服务端握手
ws.on('open',function () {
	//如果服务器开放向服务器发送信息
	ws.send('hello')
});
//监听从服务器传来的数据
ws.on('message',function (data,flag){
	console.log(data);
})

var ws=new WebSocket('ws://localhost:8080/');
//监听连接事件
ws.onopen=function (){
	//向服务器发送数据
	ws.send(123);
}
//监听服务器传来的数据
ws.onmessage=function (){
	
}

var myModules=(function () {
	
	//保存所有定义的模块
	var modules={};
	/**
	 *定义新模块，接收3个参数
	 *name:模块名
	 *deps:模块依赖的其他模块
	 *impl:模块的定义
	**/ 
	function define(name,deps,impl) {
		
		//遍历依赖每一项，取出每个模块
		for (var i=0;i<deps.length;i++) {
			deps[i]=modules[deps[i]];
		}
		//将新模块存储进模块池，并注入依赖
		modules[name]=impl.apply(impl,deps);
	}
	//从模块池中取出模块
	function get (name) {
		return modules[name];
	}
	//暴露api
	return {
		define: define,
		get: get
	}
})()

var fs=require('fs');
var path=require('path');
//作为中间件使用
module.exports=function (p) {
	return function (req,res,next) {
		var file=path.join(p,req.path);
		fs.exists(file,function (exist){
		//如果文件存在则发送给客户端
			if (exist&&file!='/') {
				fs.createReadStream(file).pipe(res);
			} else next();
		})
	}
}

res.send=function (msg) {
	//是字符串或buffer
	if (typeof msg=='string'||Buffer.isBuffer(msg)) {
		res.setHeader('content-type','text/plain;charset=utf8');
		res.end(msg);
	}
	//是对象
	if (typeof msg=='object') {
		res.setHeader('content-type','applicaton/json;charset=utf8');
		res.end(JSON.stringify(msg));
	}
	//是数字类型，转换成状态码
	if (typeof msg=='number') {
		var STATUS_CODE=require('http').STATUS_CODES;
		res.statusCode=msg;
		res.end(STATUS_CODE[msg]);
	}
}