1、同步读取

  1. var res = fs.readFileSync("./a.json")
  2. console.log(res.toString());
  1.  - 手动操作的步骤
  2.  *          1、打开文件
  3.  *           fs.openSync(path[, flags[, mode]])
  4.  *              - path  要打开文件的路径   
  5.  *              - flags 打开文件要做的操作的类型
  6.  *                  r   只读的
  7.  *                  w   可写的
  8.  *              - mode  设置文件的操作权限，一般不传
  9.  *           返回值：
  10.  *              - 该方法会返回一个文件的描述符作为结果，我们可以通过该描述符来对文件进行各种操作
  11.  * 
  12.  *          2、向文件中写入内容
  13.  *              fs.writeSync(fd, string[, position[, encoding]])
  14.  *                  - fd    文件的描述符，需要传递要写入的文件的描述符
  15.  *                  - string    要写入的内容
  16.  *                  - position  写入的起始位置
  17.  *                  - encoding  写入的编码，默认是utf-8
  18.  *      
  19.  *          3、保存并关闭文件
  20.  *              fs.closeSync(fd)
  21.  *                  - fd    要关闭的文件的描述符
  22. var fs = require("fs")
  23. // console.log(fs);
  24. //打开文件
  25. var fd = fs.openSync("hello.txt","w")
  26. //向文件中写入内容
  27. fs.writeSync(fd,"今天是个晴天")
  29. //关闭文件
  30. fs.closeSync(fd)
  31. //console.log(fd);
  33. console.log("程序向下执行");

2、异步读取

  1. fs.readFile("./a.json",(err,data)=>{
  2.     if(err){
  3.         throw new Error("读取错误")
  4.     }else{
  5.         console.log(data.toString());
  6.     }
  7. })

异步文件写入

  1. fs.open(path[, flags[, mode]], callback)
  2.  *          - 用来打开一个文件
  3.  *          - 异步调用的方法：结果都是通过回调函数的参数返回的
  4.  *          - 回调函数两个参数
  5.  *              err 错误对象，如果没有错误则为null
  6.  *              fd  文件的描述符
  7.  *      fs.write(fd, string[, position[, encoding]], callback)
  8.  *          - 用来异步写入文件
  9.  *      fs.close(fd[, callback])
  10.  *          - 用来关闭文件
  11. fs.open("hello2.txt","w",function(err , fd){
  12.     //console.log(arguments);
  13.     if(!err){
  14.         //console.log(fd);
  15.         //如果没有出错，则对文件进行写入操作
  16.         fs.write(fd,"这是异部写入的内容",function(err){
  17.             if(!err){
  18.                 console.log("写入成功");
  19.             }
  20.             //关闭文件
  21.             fs.close(fd,function(err){
  22.                 if(!err){
  23.                     console.log("文件已关闭");
  24.                 }
  25.             })
  26.         })
  27.     }else{
  28.         console.log(err);
  29.     }
  30. })
  31. console.log("程序向下执行");

简单文件写入

  1. fs.writeFile(file, data[, options], callback)
  2.  *      fs.writeFileSync(file, data[, options])
  3.  *          - file  要操作的文件的路径
  4.  *          - data  要写入的数据
  5.  *          - options   选项，可以对写入进行一些设置
  6.  *          - callback  当写入完成以后执行的函数
  7.  *      flag:
  8.  *          r   可读
  9.  *          w   写入
  10.  *          a   追加
  12.  fs.writeFile("C:\\Users\\chengdong\\Desktop\\hello.txt","这是通过writeFile写入的内容",{flag:"w"},function(err){
  13.     if(!err){
  14.         console.log("写入成功");
  15.     }else{
  16.         console.log(err);
  17.     }
  18. })

流式文件写入

  1. 同步、异步、简单文件的写入都不适合大文件的写入，性能较差，容易导致内存溢出
  1. fs.createWriteStream(path[, options])
  2.  *  - 可以用来创建一个可写流
  3.  *  - path  文件路径
  4.  *  - options 配置的参数
  6. 可以通过监听流的open和close事件来监听流的打开和关闭
  7.  * on(事件字符串，回调函数) 
  8.  *      - 可以为对象绑定一个事件
  9.  * once(事件字符串，回调函数)
  10.  *      - 可以为对象绑定一个一次性的事件，该事件将会在触发一次以后自动失效
  12. var ws = fs.createWriteStream("hello3.txt")
  13. ws.once("open",function(){
  14.     console.log("流打开了");
  15. })
  17. ws.once("close",function(){
  18.     console.log("流关闭了");
  19. })
  21. //通过ws向文件中输出内容
  22. ws.write("通过可写流写入的内容，")
  23. ws.write("今天天气真不错，")
  24. ws.write("锄禾日当午，")
  25. ws.write("红掌拨清波，")
  26. ws.write("通过可写流写入的内容，")
  28. //关闭流
  29. //ws.close()
  30. ws.end()

流式文件读写

  1. /**
  2.  * 流式文件读取也适用于一些较大的文件，可以分多次将文件读取到内存中
  3.  */
  5. var fs = require("fs")
  7. //创建一个可读流
  8. var ws = fs.createReadStream("hello3.txt")
  9. //创建一个可写流
  10. var ss = fs.createWriteStream("hello.txt")
  12. ws.once("open",function(){
  13.     console.log("可读流打开");
  14. })
  15. ws.once("close",function(){
  16.     console.log("关闭成功");
  17. })
  19. ss.once("open",function(){
  20.     console.log("可写流打开");
  21. })
  22. ss.once("close",function(){
  23.     console.log("关闭成功");
  24. })
  26. //如果要读取一个可读流中的数据，必须要为可读流绑定一个data事件，data事件绑定完毕，它会自动开始读取数据
  27. // ws.on("data",function(data){
  28. //     //console.log(data.toString());
  30. //     ss.write(data)
  31. // })
  33. //pipe()    可以将可读流中的数据，直接输出到可写流中
  34. ws.pipe(ss)

简单文件读取

  1. fs.readFile(path[, options], callback)
  2.  *      fs.readFileSync(path[, options])
  3.  *          - path  要读取的路径
  4.  *          - options   读取的选项
  5.  *          - callback  通过回调函数将读取的内容返回
  6.  *              err 错误对象
  7.  *              data    读取到的数据，会返回一个buffer
  9.  var fs = require("fs")
  10. fs.readFile("hello3.txt",function(err,data){
  11.     if(!err){
  12.         //console.log(data.toString());
  13.         //将data写入到文件中
  14.         fs.writeFile("hello.txt",data,function(err){
  15.             if(!err){
  16.                 console.log("文件写入成功");
  17.             }
  18.         })
  19.     }else{
  20.         console.log(err);
  21.     }
  22. })