级详细node.js读写文件方法

nodejs中所有与文件相关的操作都在fs模块中，而读写操作又是我们会经常用到的操作，nodejs的fs模块针对读操作为我们提供了readFile，read, createReadStream三个方法，针对写操作为我们提供了writeFile，write， createWriteStream三个方法，下面分析一下它们的区别：

一、readFile和writeFile

1、readFile方法是将要读取的文件内容完整读入缓存区，再从该缓存区中读取文件内容，具体操作如下：

1.  
   const { log } = require('console');
2.  
   let fs = require('fs')
3.  
   fs.readFile('./files/1.txt','utf8',function(err,dataStr){
4.  
   console.log(err);
5.  
   console.log('-------------');
6.  
   console.log(dataStr);
7.  
   })

与其对应的同步方法为：

1.  
   let niu = fs.readFileSync('./files/1.txt','utf8')
2.  
   log("同步读取",niu)

同步方法和异步方法的区别是：在使用同步方法执行的操作结束之前，不能执行后续代码的执行；而异步方法将操作结果作为回调函数的参数进行返回，方法调用之后，就可以立即执行后续的代码，读取完毕后会调用对应的回调函数。

2、writeFile方法是将要写入的文件内容完整的读入缓存区，然后一次性的将缓存区中的内容写入都文件中，其同步和异步具体操作如下：

1.  
   //异步写入
2.  
   fs.writeFile('./index1.txt',"开心阿松大",function(err){
3.  
   console.log(err);
4.  
   console.log('---------');
5.  
   console.log("写入成功");
6.  
   })
7.  
   //同步写入
8.  
   let shangXin = fs.writeFileSync('./index2.txt',"伤心太平洋")

以上的读写操作，Node.js将文件内容视为一个整体，为其分配缓存区并且一次性将文件内容读取到缓存区中，在这个期间，Node.js将不能执行任何其他处理。所以当读写大文件的时候，有可能造成缓存区“爆仓”。

二、read和write

1、read或readSync方法读取文件内容是不断地将文件中的一小块内容读入缓存区，最后从该缓存区中读取文件内容，具体操作如下：

1.  
   fs.open('./index1.txt','r',function(err,fd){
2.  
   var buf = new Buffer(225); //读取fd文件内容到buf缓存区
3.  
   fs.read(fd,buf,0,9,3,function(err,bytesRead,buffer){
4.  
   console.log(buf.slice(0,bytesRead).toString());
5.  
   });
6.  
   var buff = new Buffer(225); //位置设置为null会默认从文件当前位置读取
7.  
   fs.read(fd,buff,0,3,null,function(err,bytesRead,buffer){
8.  
   console.log(buff.slice(0,bytesRead).toString());
9.  
   }); var buffer = new Buffer(225); //同步方法读取文件
10.  
    var bytesRead = fs.readFileSync(fd,buffer,0,9,3);
11.  
    console.log(bytesRead);
12.  
    console.log(buffer.slice(0,bytesRead).toString());
13.  
    });

2、write或writeSync方法写入内容时，node.js执行以下过程：1将需要写入的数据写入到一个内存缓存区；2待缓存区写满后再将缓存区中的内容写入到文件中；3重复执行步骤1和步骤2，知道数据全部写入文件为止。具体操作如下：

1.  
   var fs = require('fs');var buf = new Buffer('我喜爱编程');
2.  
   fs.open('./mess.txt','w',function(err,fd){
3.  
   fs.write(fd,buf,3,9,0,function(err,written,buffer){
4.  
   fs.write(fd,buf,12,3,null,function(err,written,buffer){ if(err) console.log('写文件操作失败');
5.  
   console.log('写文件操作成功');
6.  
   });
7.  
   }); //同步写入
8.  
   fs.writeSync(fd,buf,3,9,0);
9.  
   });

以上读写操作，node.js会将文件分成一块一块逐步操作，在读写文件过程中允许执行其他操作。

但有的时候我们并不关心整个文件的内容，而只关注从文件中读取到的某些数据，以及读取到数据时需要执行的处理，这时我们可以使用文件流来处理。

三、createReadStream和createWriteStream

1、createReadStream方法创建一个将文件内容读取为流数据的ReadStream对象，方法如下所示：

1.  
   var fs = require('fs');var readStream = fs.createReadStream('./message.txt',{start:3,end:12});
2.  
   readStream.on('open',function(fd){
3.  
   console.log('开始读取文件');
4.  
   });
5.  
   readStream.on('data',function(data){
6.  
   console.log('读取到数据：');
7.  
   console.log(data);
8.  
   });
9.  
   readStream.on('end',function(){
10.  
    console.log('文件已全部读取完毕');
11.  
    });
12.  
    readStream.on('close',function(){
13.  
    console.log('文件被关闭');
14.  
    });
15.  
    readStream.on('error',function(err){
16.  
    console.log('读取文件失败');
17.  
    });

2、createWriteStream方法创建一个将流数据写入文件中的WriteStream对象，方法如下所示：

1.  
   var fs = require('fs');var file = fs.createReadStream('./message.txt');var out = fs.createWriteStream('./anotherMessage.txt');
2.  
   file.on('data',function(data){
3.  
   out.write(data);
4.  
   });
5.  
   out.on('open',function(fd){
6.  
   console.log('需要被写入的文件已打开');
7.  
   });
8.  
   file.on('end',function(){ //将操作系统缓存区中的数据全部写入文件
9.  
   out.end('再见',function(){
10.  
    console.log('文件全部写入完毕');
11.  
    console.log('共写入' out.bytesWritten '数据');
12.  
    });
13.  
    });

以上方法可以对读写文件的过程中进行监听，并定义相关的方法pause和resume暂停或恢复文件的读取操作，可以监听写入时缓存区数据是否已满或者是否已全部输出，如下所示：

1.  
   //监听writeStream对象的drain事件var fs = require('fs');var out = fs.createWriteStream('./test1.txt');for(var i=0;i<10000;i ){ //返回true或false true代表缓存区已满
2.  
   var flag = out.write(i.toString());
3.  
   console.log(flag);
4.  
   }
5.  
   out.on('drain',function(){
6.  
   console.log('操作系统缓存区中的数据已全部输出'); var out = fs.createWriteStream('./test2.txt'); for(var i=0;i<10;i ){ var flag = out.write(i.toString());
7.  
   console.log(flag);
8.  
   }
9.  
   out.on('drain',function(){
10.  
    console.log('操作系统缓存区中的数据已全部输出');
11.  
    });
12.  
    });

案例:读取文件内容，并写入到另外一个文件；

1.  
   const fs = require('fs');
2.  
    
3.  
   fs.readFile('./txt.txt','utf8',function(err,dataStr){
4.  
   if (err) {
5.  
   return console.log('读取失败' err.message)
6.  
   }
7.  
   console.log('读取成功' dataStr)
8.  
   let oldArr = dataStr.split(' ')
9.  
   console.log(oldArr)
10.  
    let arrNew = []
11.  
    oldArr.forEach(item=>{
12.  
    arrNew.push(item.replace('=',':'))
13.  
    })
14.  
    console.log(arrNew);
15.  
    // arrNew.join('\r\n')
16.  
    const newArr = arrNew.join('\r\n')
17.  
    console.log(newArr);
18.  
     
19.  
    fs.writeFile('./txt1.txt',newArr,function(err){
20.  
    if (err) {
21.  
    console.log("写入失败" err.message);
22.  
    }
23.  
    console.log("写入成功")
24.  
    })
25.  
    })

案例2：读取文件，地址使用path模块，里边有惊艳的地方；

1.  
   fs.readFile(fpath.join(__dirname,'/files/1.txt'),'utf-8',function(err,dataStr){
2.  
   if (err) {
3.  
   console.log('file读取失败',err)
4.  
   }
5.  
   console.log('file读取成功' dataStr)
6.  
   })

注意：使用path模块去拼接文件地址的时候，为什么要用join方法，而不是去直接拼接呢？因为用join方法，可以跨平台使用，比如跨平台在mac上使用；

每次遇到相关的读取知识都是进行添加到这里边，也是希望对于学it的小伙伴一个帮助，这是自己总结的内容，路过的兄弟姐妹辛苦点个赞吧；

这篇好文章是转载于：学新通技术网