处在国企单位，整天闲的要死要死的，民族的花朵都快枯萎了
哎呀呀，打起精神.......早睡早起，多看书。。。开始进入苦读状态，苦练武功，争取有朝一日报效祖国。。。哈哈 开玩笑的
开始看书吧 记得Node.js+MonogoDB+AngularJs 这本书好像是去年4月份买的 买了好久了 一直没领会他的精髓 上班没事 绝对再看看 虽然对我的工作没什么帮助，哎呀呀 还是看吧.....................
一、node的事件模型：包含了事件队列、事件循环、线程池
二、实现定时器：
超时时间：延迟一段时间执行，只需要执行一次setTimeout();clearTimeout()取消超时时间函数
时间间隔：按定期的延迟时间间隔执行工作，对于定期工作setInterval();
即时计时器：setImmediate();允许你把工作调度为在时间队列中的当前事件完成之后执行，即在I/O事件的回调函数开始执行之后
process. nextTick：调度工作，在I/O时间被触发之前执行
从事件循环中取消定时器引用：unref()/ref()重新引用
三、事件发射器和监听器：
创建自定义事件：
四、Node.js处理数据：
数据形式有：文本、JSON字符串、二进制缓冲区、数据流
1、处理json
Json字符串转js对象：JSON.parse(String);转化为对象用点来访问
js对象转为JSON字符串：JSON.stringify();
2.使用buffer管理二进制的缓冲数据
（缓冲数据：有字节组成，比文本数据占用较少空间）
node.js提供buffer(缓冲区模块，全局性的，不需要require()引入)允许在缓冲结构中创建、读取、写入和操作二进制数据
创建缓冲区：new Buffer（）；
写入缓冲区：buffer.writer();
读取缓冲区：tostring();
确定缓冲区长度：buffer.length();返回的是字节长度
复制缓冲区：buffer.copy(new_buffer);
缓冲区切片：buffer.slice(start,end);
拼接缓冲区：Buffer.concat();
3.使用Stream模块来传送数据流
（stream模块是node的重要模块。数据流是可读、可写、或者即可读又可写的内存结构）
流的目的是从一个地方向另一个地方传送数据的通用机制；流一般用于HTTP数据和文件
Readable流（可读流）：
常见实例：在客户端的HTTP相应、在服务器的HTTP请求、fs读取流、zlib流、crypto(加密)流、TCP套接字、子进程的stdout和stderr、process.stdin
公开事件：readable/data/end/close/error
方法：read():从流中读取数据。可以返回string对象、buffer对象或者null
setEncoding();设置从read()请求读取返回string的编码
pause();暂停从该对象发出的data事件
resume():恢复从该对象发出的data事件
pipe(de,[options]);把这个流的输出传输到由de目的地指定的writable流对象
unpipe():从写入的目的地断开这一对象
实现自定义Readable流对象：
1.首先继承：
var stream = require('stream');
var util = require('util');
util.inherits(answers,stream.Readable); //继承了Readable流的功能
2.创建对象调用的实例：
function answers(opt){
stream.Readable.call(this,opt); //创建对象调用的实例
...........
}
3.调用push()来输出Readable对象中的数据的_read()方法（即处理数据的推出）
answers.prototype._read = function(){
if(){
this.push();
}
}
Writable流（可写流）：
把数据写入一种可以轻松的在代码的另一个区域被使用的形式的机制
常见实例：客户端上的HTTP请求、服务骑上的HTTP响应、fs写入流、zlib流、crypto（加密）流、TCP套接字、子进程的stdin、process.stdout/process.stderr
公开事件：drain/finish/pipe/unpipe
方法：
.................................哟嘿 下班了 ...明天继续
2018/1/16 星期二 继续
Writable流（可写流）：
公开事件：
drain：当准备好写入更多的数据时，发出此事件通知监听器
finish：等end()在Writable对象上调用，所有的数据都被刷新，并且不会有更多的数据将被接收时发出此事件
pipe：当pipe()方法在Readable流上被调用，以添加此Writable为目的地，发出此事件
unpipe:当unpipe()方法在Readable流上被调用，以删除此Writable为目的地，发出此事件
方法：
write("要写入的数据"，【指定字符串的编码】，【指定当数据已经完全刷新时执行的回调函数】)：将数据块写入流对象的数据位置
end():与write()同，把writable对象置于不在接收数据的状态，并发送finish事件
实现自定义writable流对象：
1.首先继承：
var stream = require('stream');
var util = require('util');
util.inherits(answers,stream.writable); //继承了writable流的功能
2.创建对象调用的实例：
function answers(opt){
stream.writable.call(this,opt); //创建对象调用的实例
this.data = new Array();
}
3.实现一个_write()方法存储writable对象的数据（即处理数据的推出）
answers.prototype._write = function(data,encoding,callback){
this.data.push(data.toString(encoding));
console.log(data);
callback();
};
4.调用：
var W = new answers（）；
W.writer("iiiiiiii");
Duplex流（可读可写双向流）：
（TCP套接字链接）
实现自定义Duplex流对象：
1.首先继承：
var stream = require('stream');
var util = require('util');
util.inherits(answers,stream.Duplex); //继承了Duplex流的功能
2.创建对象调用的实例：
function answers(opt){
stream.Duplex.call(this,opt); //创建对象调用的实例
this.data = [];
}
***************************************************************************
Duplex流的opt参数接受一个allowHalfOpen属性设置为true或false的对象，如果为true,则即使可写入端已经结束，可读取端也保持打开状态；反之亦然；如果为false,则结束可写入端也会结束可读取端，反之亦然
****************************************************************************
3.实现一个全Duplex()流时，在原型化Duplex类的时候需要同时实现_read()方法和_write()方法
answers.prototype._write = function(data,encoding,callback){
this.data.push(data.toString(encoding));
};
answers.prototype._read = function(){
this.push();
}
4.调用：
var W = new answers（）；
W.writer("iiiiiiii");
W.on('data',function(chunk){
})
Transform(交换)流：
扩展了Duplex流，但他修改了Writable流和Readable流之间的数据，当你需要修改从一个系统到另一个系统的数据时，此流类型会非常有用。
Transform流的实例：
zlib流、crypto流
在Transform流中不需要实现_read()和_write()原型方法，这些被作为直通函数提供，
但是需要实现_transform（"要写入的数据"，【指定字符串的编码】，【指定当数据已经完全刷新时执行的回调函数】）方法和_flush（回调函数）方法
_transform（）接收来自Write()请求的数据，对齐修改，并推出修改后的数据
1.首先继承：
var stream = require('stream');
var util = require('util');
util.inherits(answers,stream.Transform); //继承了Duplex流的功能
2.创建对象调用的实例：
function answers(opt){
stream.Transform.call(this,opt); //创建对象调用的实例
}
3.实现一个Transform()流时，需要实现_transform()方法和_flush()方法
answers.prototype._transform = function(data,encoding,callback){}
answers.prototype._flush = function(data,encoding,callback){}
流对象最酷的事情：把Readable流用管道输送到Writable流-----------------pipe(writableStrem,[options]):即把Readable流的输出直接输入到Writable流中
options参数接收一个end属性设置为true，或false的对象，当end为true时，Writable流随着Readable流的结束而结束。
readStream.pipe(WriteStream,{end:true});
zlib压缩与解压缩数据：
zilib压缩模块可以使你非常方便、高效的压缩和解压缩在缓冲区中的数据
zlib支持的压缩办法：
gzip/gunzip:标准gzip压缩
deflate/inflate:基于huffman编码的标准deflate压缩算法
deflateRaw/inflateRaw:针对原始缓冲区的deflate压缩算法
压缩和解压缓冲区：
function(buffer,callback) function:压缩/解压缩办法 buffer:被压缩/解压缩的缓冲区 callback:压缩/解压缩发生之后执行的回调函数
压缩和解压缩流：
pipe();
Node访问文件系统：（fs模块）
如果需要通过管理动态文件来支持web应用程序或服务，文件系统的交互变得十分重要
fs模块提供了大多数语言中可用的标准文件访问API来打开、读取、写入文件及与其交互
（具备创建、读取、修改、在目录结构中穿行的能力、删除、截断、重命名文件和文件夹）
var fs = reqiure('fs');
同步和异步文件系统调用
异步：write() 同步：writeSync()
<英语不好的我呀 重症患者 同步：synchronization 异步：asynchronization>
(所有的异步调用最终都有一个额外的参数，即在调用完成时执行的回调函数，并且通常包含一个错误作为其第一个参数err)
打开和关闭文件：
fs.open(path,flags,[mode],callback);
fs.openSync(path,flags,[mode]);
path:文件系统的标准路劲字符串，flags:指定打开文件的模式（r/r+/rs/rs+/w/wx/w+/wx+/a/ax/a+/ax+）
fs.close(fd,callback);
fs.close(fd)
写入文件：
4种不同的方式将数据写入文件
1.简单文件写入：
fs.writeFile(path,data,[options],callback)
fs.writeFileSync(path,data,[options])
path:指定文件路径，data:写入数据string或者buffer对象 options:参数是一个对象（可包含encoding/mode/flag）
2.同步文件写入：（等待许久的快递到了 。。先去那个快递..）(没有想象中的号 有点悲伤)
开始吧............
1.fs.openSync();打开文件
fs.writeSync(fd,data,offset,length,position) 写入文件
3.异步写入文件：
（异步方法为了保证执行的吮吸，最简单的办法就是把异步操作卸载上一个惭怍的回调函数中）
1.fs.open()
2.fs.write(fd,data,offset,length,position,callback)
4.流式文件写入
往一个文件写入大量的数据，使用流是最好的办法
Writeable流打开，通过pipe()管道连接Readable流
1.创建Writable对象
fs.creatWriteStream(path,[options])
2.使用标准的流式write（buffer）方法来写，写入完后调用end()方法关闭流
读取文件：
1.简单的读取文件
fs.readFile(path,[options],callback)
fs.readFileSync(path,[options])
2.同步文件读取
fs.openSync();
fs.readSync(fd,buffer,offset,length,position);
3.异步文件读取
fs.open()
fs.read(fd,buffer,offset,length,position,callback);callback接收三个参数 error错误,bytes读取的字节数,buffer从读取请求填充数据的缓冲区
4.流式文件读取
Readable流打开，通过pipe（）管道连接Writable流
fs.creatReadStream(path,[options]);
打开文件流后，通过read()请求，或者通过data事件处理读出数据
验证路径的存在性：
fs.exists(path,callback) //回调函数带参 传入true或false
fs.exixtsSync(path)；//返回true或者false
获取文件信息：
fs.stats(path,callback)
fs.statsSync(path)
。。。。。。。。。。。。。。。。下班了 没看完 悲催 明天继续.....
获取文件信息：
fs.stats(path,callback); stats对象作为回调函数的第二个参数被传入，而第一个参数是error
fs.statsSync(path);同步方法返回一个stats对象
stats对象上常用的属性和方法：
isFile():如果是一个文件，返回true
isDirectory():如果是一个目录，返回true
isSocket():如果是一个套接字，返回true
dev :指定文件所造的设备的ID
mode:指定文件的访问模式
size:指定文件的字节数
blksize:指定用于存储该文件的块大小，以字节为单位
blocks:指定文件在磁盘上占用的块的数目
atime:指定上次访问文件的时间
mtime:指定文件的最后修改时间
ctime:指定文件的创建时间
列出文件：列出在目录中的文件和文件夹
fs.readdir(path,callback) 返回的列表作为第二个参数传递回回调函数，错误作为第一参数
fs.readdirSync(path) 返回指定目录中条目名称的字符串数组
删除目录：
fs.unlink(path,callback);
fs.unlinkSync(path);返回true或者false,代表是否删除成功
截断Truncate文件:通过把文件结束处设置为比当前值小的值来减少文件大小（不是很清楚）
fs.truncate(path,len,callback);传递一个错误值给回调函数
fs.truncate(path,len);函数返回true/false
建立和删除目录：
建立目录：
fs.mkdir(path,[mode],callback)
fs.mkdirSync(path,[mode])
mode:指定新目录的访问模式
删除目录：
fs.rmdir(path,callback)
fs.rmdirSync(path)
重命名文件和目录：
fs.rename(oldpath,newpath,callback);//回调函数传递一个错误值
fs.renameSync(oldpath,newpath);
监视文件更改入：文件发生变化时执行回调函数
fs.watchFile(path,[options],callback);
options:是一个对象，包含:presistent(持续)和interval(间隔)属性；{presistent:true}持续监视，{interval:2000}每隔2秒监视一次
callback:当文件发生变化，就会执行
在Node中实现HTTP服务：
node提供内置的http和https模块，实现HTTP和HTTPS服务器和服务的能力
使用http模块实现客户端和服务端时使用的对象：
处理URL：
（URL:统一资源定位符------充当HTTP服务器用来处理来自客户端的请求的一个地址标签）
协议http 身份验证user:pass 主机名host 主机host.com 端口：80 路径：resource/path?query=string 路径名：resource 搜索/查询: ？query=string 散列：#hash
http://user:pass@host.com:80/resource/path?query=string#hash
了解URL对象
url模块：
把URL字符串转化为URL对象的功能
url.parse(urlstr,[parseQueryString],[slasheeDenoteHost])
parseQueryString：为true，则解析查询字符串部分为对象字面量，默认为false
slasheeDenoteHost:为true把格式为//host/path的URL解析为{host:'host',pathname:'/path'} 而不是{pathname:'//host/path'},默认值为false
把URL对象转为URL字符串
url.format(urlobj);
URL对象的属性：
href/protocol/host/auth/hostname/port/pathname/search/path/query/hash
解析URL组件
把URL解析到新的位置，from:原始URL字符串，to:URL被解析到的新位置
url.resolve(from,to)://只是更改了路径以后的位置
处理查询字符串和表单参数：基本的键值对
使用querystring模块的parse（）方法将字符串转换成JS对象
使用querystring模块的stringify（）方法将JS对象转换成字符串
了解请求、响应、和服务器对象
http.clientRequest对象
http.request(options,callback); //得到一个ClientRequest对象
options:是一个对象，定义了如何把客户端的HTTP请求打开并发送到服务器
callback:回调函数，唯一的参数是 IncomingMessage对象，该对象来自服务端的响应
clientRequest对象实现了一个Writable流
clientRequest对象，指定的选项：
host/hostname/port/localAddress/socketPath/method/path/headers/auth/agent
http.serverResponse对象
使用serverResponse对象指定并发送到客户端的响应，实现了一个writeable流 ，提供其的所有功能
http.IncomingMessage对象
IncomingMessage对象实现了一个Readable流，让客户端请求或服务器响应作为流源读入，意味着readable和data事件可以被监听并用来从六中读出数据
HTTPserver对象
提供一个监听端口的底层套接字和接收请求，然后发送响应给客户端连接的处理程序
启动HTTP服务器：
http.createServer([requestListiner]);//返回一个server对象
requestListener参数是请求事件被触发时执行的回调函数，接收两个惨，一个参数代表客户端请求的IncomingMessage对象，第二个参数代表ServerResponse对象
通过server对象上的listen(port，【hostname】,【backlog】，【callback】)方法监听
在node中实现HTTP客户端和服务器
提供静态文件服务：
1.启动HTTP服务器并监听端口
2.使用fs模块在本地打开该文件，然后在响应中写入文件内容
var fs = require('fs');
var http = reqiure('http');
var url = reqiure('url');
var root_dir = "html/";
http.createServer(function(request,response){ //创建server对象
var urlObj = url.parse(req.url,true,false); //字符串转对象，为true，则解析查询字符串部分为对象字面量
fs.readFile(root_dir+urlObj.pathname,function(err,data){ //读取静态文件
if(err){
response.writerHead(404);
response.end(JSON.stringify(err));
return;
}
response.writeHead(200);
response.end(data); //把文件内容吸入响应对象中
})
}).listen(8080);
动态的GET服务器：