node把读写的文件视为一个整体，为其分配缓存区并一次性将文件内容读取到缓存区中,在此之间node不能做任何工作。 如果文件特别大很容易带来内存溢出的问题
var http = require('http');
var fs = require('fs');
var server = http.createServer(function (req, res) {
fs.readFile('./data.txt', function (err, data) {
res.end(data);
});
});
server.listen(8080);
在有些时候我们并不关心文件内容，只是关注是否读到数据，以及读到数据时的处理,此时可以用流
流是一组有序的，有起点和终点的字节数据传输手段
网络中传输数据时，总是先将对象包含的数据转成流数据也就是字节数据,再通过流的传输，到达目的地时再转换为原始的数据
用了stream.Readable接口的对象来将对象数据读取为流数据
readable可以从流中读取数据时触发。如果指定了回调函数，将迫使操作系统先读入缓存区，再从缓存区中读取数据 当缓存区中的对象全部读出时，且可以继续读取数据时，触发一个新的readable事件
使用readstream对象读取文件
流动模式
var file = fs.createReadStream('./msg.txt',{start:3,end:11});//要注意end是包括这个位置的，
file.on('open',function(){
console.log('文件打开了');
})
file.on('data',function(data){
console.log('数据拿到了'+data.length);
})
file.on('end',function(){
console.log('全部读取完毕');
})
file.on('close',function(){
console.log('文件关闭了');
})
file.on('error',function(err){
console.log('出错了'+err);
})
//使用pause方法暂停data事件的触发，这个意味着停止文件的读取，而已经被读取到操作系统缓存区中的数据也将被
//保存在操作系统缓存区。
var readStream = fs.createReadStream('./msg.txt');
readStream.pause();
readStream.on('data',function(data){
console.log(data);
})
setTimeout(function(){
readStream.resume();
},5000)
非流动式读取
var rs = fs.createReadStream('./128.txt');//要注意end是包括这个位置的，
var arr = [];
rs.on('readable',function(){
var data;
while(null != (data = rs.read())){
//console.log('read:%d',data.length);
arr.push(data);
}
}).on('end',function(){
var b = Buffer.concat(arr);
//console.log(b.toString());
})
使用writeStream对象写入文件,可以创建一个将流数据写入文件中的writestream对象
fs.createWriteStream(path,[options]);
writeable对象有一个write方法，用于将流数据写入到目标对象中。 write(chunk,[encoding],callback());
chunk要写入的数据
encoding 编写格式
callback指定当数据写入完毕后的回调函数
它有一个返回值，操作系统缓存区已满时返回false,未满时返回true 它还有一个end方法，当没有数据再被写入时可调用该方法关闭文件， 这将迫使操作系统缓存区中的剩余数据立即被写入 到文件中。可以在回调中指定关闭之前的处理。
writeable.end(chunk,[encoding],[callback]) writeStream还有一个byteswritten属性，表示已经在文件中写入的数据的字节数
var fs = require('fs');
var src = fs.createReadStream('./msg.txt');
var desc = fs.createWriteStream('./anotherMsg.txt');
desc.on('open',function(){
console.log('需要写入的文件已经被打开');
});
src.on('data',function(data){
desc.write(data);
})
src.on('end',function(){
desc.end('再见',function(){
console.log('文件全部写入完毕');
console.log('共写入%d字节数据',desc.bytesWritten);
});
})
var stream = require('stream');
var util = require('util');
var fs= require('fs');
//构建一个自定义的读流
function ZfReadStream(){
stream.Readable.call(this);
}
util.inherits(ZfRadStream,stream.Readable);
//实现_read方法
ZfRadStream.prototype._read = function(){
var content = fs.readFileSync('./qqq.txt')
this.push(content);
this.push(null);//表示结束
}
function Zf1RadStream(){
stream.Readable.call(this);
}
util.inherits(Zf1RadStream,stream.Readable);
Zf1RadStream.prototype._read = function(){
var content = fs.readFileSync('./qqq.txt')
this.push(content);
this.push(null);
}
var zfRadStream = new ZfRadStream();
zfRadStream.on('data',function(data){
fs.writeFile('./ttt.jpg',data);
}).on('end',function(){
console.log('end');
});
var stream = require('stream');
var util = require('util');
var fs= require('fs');
//自定义的写流
function ZfWriteStream(){
stream.Writable.call(this);
}
util.inherits(ZfWriteStream,stream.Writable);
ZfWriteStream.prototype._write = function(data,encoding,callback){
console.log('zf1'+data.toString('utf8'));
callback();
}
function Zf2WriteStream(){
stream.Writable.call(this);
}
util.inherits(Zf2WriteStream,stream.Writable);
Zf2WriteStream.prototype = new stream.Writable();
Zf2WriteStream.prototype._write = function(data,encoding,callback){
console.log('zf2'+data.toString('utf8'));
callback();
}
var zfWriteStream = new ZfWriteStream();
zfWriteStream.write(new Buffer('珠峰'),function(){
console.log('写入成功');
});
var zf2WriteStream = new Zf2WriteStream();
zf2WriteStream.write(new Buffer('珠峰'),function(){
console.log('写入成功');
});
/**
*双工流，能读能写
*/
var Duplex = require('stream').Duplex;
var util = require('util');
var fs = require('fs');
function Change(){
Duplex.call(this);
}
util.inherits(Change,Duplex);
Change.prototype._read = function(){
}
Change.prototype._write = function(data,encoding,cb){
for(var i=0;i<data.length;i++){
data[i] = 255-data[i];
}
this.push(data);
this.push(null);
}
var c = new Change();
fs.createReadStream('./qqqt.txt').pipe(c)
.pipe(fs.createWriteStream('qqqtt.txt'));
/**
* Stream.Transform
*/
var Transform = require('stream').Transform;
var util = require('util');
var fs = require('fs');
function Tran(){
Transform.call(this);
}
util.inherits(Tran,Transform);
Tran.prototype._transform = function(chunk, encoding, cb){
console.log(chunk);
for(var i=0;i<chunk.length;i++){
chunk[i] = 255-chunk[i];
}
this.push(chunk);
this.push(null);
}
var c = new Tran();
fs.createReadStream('./qqq2.txt').pipe(c)
.pipe(fs.createWriteStream('qqq3.txt'));