nodejs操作文件和数据流

前言

　　node中有一组流api，它们可以像处理网络流一样处理文件。流api用起来非常方便，本节学习介绍文件处理基础和流的概念。

目录

1. 处理文件路径
2. fs核心模块简介
3. 操作流
4. 慢客户端问题

1. 处理文件路径

　　处理文件路径需要用到一个核心模块（path），path模块可以规范化、连接、解析路径，还可以将绝对路径转换为相对路径，提取路径的组成以及判断路径是否存在。

1.1. 规范化路径

在存储和使用路径前最好能够将其进行规范化，这里使用path模块的normalize()函数

 //规范化路径
 var path=require('path');
 path.normalize('/pathstudy//path1')
 // =>'/pathstudy/path1'

1.2. 连接路径

通过path.join()函数可以连接多个路径字符串，如下所示：

 //连接路径
 var path=require('path');
 path.join('/pathstudy','path1','test');
 // => '/pathstudy/path1/test'

1.3. 解析路径

使用path.resolve()函数将多个路径解析为一个规范化的路径

 //解析路径
 var path=require('path');
 path.resolve('/foo/bar','./dd');
 // =>/foo/bar/dd

1.4. 提取路径的组成部分

 //提取路径组成部分
 var path=require('path');
 path.dirname('/foo/bar/dd/a1.txt');//获取文件路径的目录 => /foo/bar/dd
 path.basename('/foo/bar/dd/a1.txt');//获取文件名 => a1.txt
 path.basename('/foo/bar/dd/a1.txt','.txt');//获取不包含文件类型的文件名 => a1
 path.extname('/foo/bar/dd/a1.txt','.txt');//获取文件扩展类型 =>.txt

1.5. 判断路径是否存在

使用path.exists()函数判断路径是否存在，0.8版本以后使用fs.exists()函数代替，只需将导入模块替换为fs即可。

 //判断路径是否存在
 var path=require('path');
 path.exists('/foo/bar/dd',function(exists){
     console.log('是否存在：',exists);
 })

2. fs模块简介

fs核心模块内置查询文件信息和打开/读写/关闭文件操作

查询文件信息

使用fs.stat()函数查询文件特征，例如大小、创建时间、权限等

//查询文件信息
var fs=require('fs');
fs.stat('/foo/bar/dd',function(stats){
    console.log(stats);//打印出文件信息
    stats.isFile();//判断是否文件
    stats.isDirectory();//判断是否目录
    stats.isSocket();//判断是否UNIX套接字
    //...
});

打开/读写/关闭文件

 var fs=require('fs');
 //打开文件，‘r’表示模式类型
 fs.open('/foo/bar/dd/a1.txt','r',function(err,fd){
     //获取文件描述符 fd
 });

 //读取文件
 fs.open('/foo/bar/dd/a1.txt','r',function(err,fd){
     if(err){
         throw err;
     }
     var readbuffer=new Buffer(1024),//设置缓冲区
         bufferOffset=0,
         filePosition=100,//从100字节开始
         bufferLength=readbuffer.length;//读取随后的1024字节数据;
         fs.read(fd,readbuffer,bufferOffset,bufferLength,filePosition,
             function (err, readBytes){
                 if(err){
                     throw err;
                 }
                 if(readBytes>0){
                     console.log(readbuffer.slice(0,readBytes));//获取读入缓冲区的字节数
                 }
             });
 });

 //写入文件
 fs.open('/foo/bar/dd/a1.txt','a',function(err,fd){
     if(err){
         throw err;
     }
     var writebuffer=new Buffer('准备写入缓冲区的数据'),//设置缓冲区
         bufferPosition=0,//写入起始位置
         filePosition=null,//从文件什么位置开始写
         bufferLength=readbuffer.length;//长度
         fs.write(fd,writebuffer,bufferPosition,bufferLength,filePosition,
             function (err, write){
                 if(err){
                     throw err;
                 }
                 console.log('write bytes:',write);//获取读入缓冲区的字节数
             });
 });

 //关闭文件
 fs.open('/foo/bar/dd/a1.txt','a',function(err,fd){
     if(err){
         throw err;
     }
     //write...
     //close
     fs.close(fd,function(){
         //...
     })
 });

文件模式类型：

r——数据流的位置从起始处打开文件读取

r+——数据流的位置从起始处打开文件读写

w——如果文件存在则清零，不存在则创建文件并写入数据，数据流的位置从文件起始处

w+——打开文件进行读写，如果文件存在则清零，不存在则创建文件并写入数据，数据流的位置从文件起始处

a——打开文件写入数据，如果文件存在则清零，不存在则创建文件，数据流的位置从文件结尾处，写操作都将追加到文件后面

a+——打开文件读写数据，如果文件存在则清零，不存在则创建文件，数据流的位置从文件结尾处，写操作都将追加到文件后面

需要注意，在读写文件操作回调函数执行之后，不要使用提供的缓冲区，不然可能会导致读写数据不完整。

3. 操作流

流是由几个node对象实现的抽象概念，创建或读取流的方式取决于使用流的类型，流的特性包含可读流和可写流，通过监听data事件，在流每次提交数据时，都能够得到通知。

3.1. 创建文件系统流

 var fs=require('fs');
 //根据文件路径创建一个可读流
 fs.createReadStream('/foo/bar/file');

 fs.open('/foo/bar/file','r',function(err,fd){
     fs.createReadStream(null,{fd:fd,encoding:'utf8'});
     fs.on('data',function(data){
         console.log('data:',data);
     });
 });

 //创建可写流
 fs.createWriteStream('/foo/bar/file');

 fs.createWriteStream('/foo/bar/file',option);
 //option表示第二个参数，默认值为{flags:'w',encoding:null,mode:0666}

可以指定createReadStream和createWriteStream函数的第二个参数，用来设置文件的起始结束位置、编码格式等等，参数选项如下所示：

• encoding——data事件发送的编码格式
• fd——如果已经有一个打开文件描述符则可以传入该参数选项
• bufferSize——要被读取的每个文件块大小，单位是字节，默认64kb
• start——设置文件中第一个被读取的字节位置，用来限制读取数据范围
• end——与start相反
• flags——表示用于打开文件的模式类型
• mode——指定要打开文件的权限

4. 慢客户端问题

当客户端的网络连接速度较慢时，可写流也就慢速，可读流会快速产生data事件并监听，数据被发送到可写流，导致node不得不缓存数据导致缓冲区被快速填满。

一般情况可以通过暂停数据生产者来避免这个问题：

 var http=require('http');
 var fs=require('fs');
 http.createServer(function(req,res){
     var rs= fs.createReadStream('/foo/bar/file');

     rs.on('data',function(data){
         if(!res.write(data)){
             rs.pause();//暂停可读流
         }
     });

     rs.on('drain',function(){
         rs.resume();//恢复可读流
     });

     rs.on('end',function(){
         res.end();//结束操作
     });

 }).listen('8080');

扩展：使用pipe函数操作上述暂停/恢复操作

 var http=require('http');
 var fs=require('fs');
 http.createServer(function(req,res){
     var rs= fs.createReadStream('/foo/bar/file');
     rs.pipe(res);//由传输源调用并接受目标可写流作为参数
 }).listen('8080');

 http.createServer(function(req,res){
     var rs= fs.createReadStream('/foo/bar/file');
     //默认情况下end()在可读流结束时在可写流上被调用，设置第二个参数end选项为false表示不让pipe函数进行end操作
     rs.pipe(res,{end:false});

     rs.on('end',function(){
         res.write('endend~~');
         res.end();//结束操作
     });
 }).listen('8080');

总结

对于流我表示比较懵逼，对概念理解的还不是很透彻。。