nodejs-API-fs文件系统
这个是集成在node里面的
node,读写文件也有同步和异步的接口
node就是异步写的nb

java和python都是同步来获取我们磁盘的数据，而且同步不用搞一些同步之类的
但node肯定要用到回调函数(异步)来执行一些异步的操作

node-fs的俩种方式:

同步

首先要打开文件:
fs.openSync

  1. path:文件路径
  2. flags:标识,你是写入还是读取
  3. mode:读取的时候的一个模式
  1. var fs = require('fs')
  3. //首先open打开
  4. var fd = fs.openSync('./hello.txt','r')
  5. console.log(fd)
  1. node xxx.js

但是你还是拿不到里面的内容,
得到的是一个标识(第几个窗口)，它确实打开了，但是是在内存里面打开了

拿到标识通过读取的方式去获取内容:
就要用到fs.readSync
需要一个缓存区(Buffer内存开辟出来的缓存区)
高度封装，如果不行就使用fs.readFileSync

  1. var content = fs.readFileSync('./hello.txt',{flag:'r',encoding:'utf-8'})

如果下面有一个

  1. var content = fs.readFileSync('./hello.txt',{flag:'r',encoding:'utf-8'})
  2. console.log(123)

如果是同步则要等上一句执行完后才能输出123

异步

在node里面默认就是异步的
fs.open

  1. path:文件路径
  2. flags:标识,你是写入还是读取
  3. callback:回调

fs.readFile

如果文档里面写options的接口

那它就要你传入一个对象进去

异步不会让系统停下来，也不会赋值，所以要给你一个回调函数:

  1. fs.readFile('./hello.txt',{flag:'r',encoding:'utf-8'},function(){
  2.     console.log(456)
  3. })
  4. console.log(123)

这里先是123先输出，读取完文本的时候才输出456
回调函数由俩个形参,一个是error(错误) , 一个是data数据

  1. fs.readFile('./hello.txt',{flag:'r',encoding:'utf-8'},function(err,data){
  2.     if(err){
  3.         console.log(err)
  4.     }else{
  5.         console.log(data)
  6.     }
  7.     console.log(456)
  8. })
  9. console.log(123)

输出:

  1. 123
  2. hello world
  3. 456

对于异步来说，我们结果可以封装成Promise对象的形式(Promise)
对原生读文件的方式进行封装:

  1. function myFsReadFile(path){
  2.     return new Promise(function(resolve,reject){
  3.         fs.readFile(path,{flag:'r',encoding:'utf-8'},function(err,data){
  4.             if(err){
  5.                 reject(err)
  6.             }else{
  7.                 resolve(data)
  8.             }
  9.         })
  10.     })
  11. }

封装完后读取文件的写法就可以:

  1. var w1 = myFsReadFile('./hello.txt')
  2. w1.then(function(res){
  3.     console.log(res)
  4. })

async function可以参考这个
了解async function:

  1. async function asyncCeShiFun(){
  2.     return 'hello?';
  3. }
  4. //Promise { 'hello?' }
  5. console.log(asyncCeShiFun())
  6. asyncCeShiFun().then(v=>{
  7.     console.log(v)
  8. })

输出为:

  1. Promise { 'hello?' }
  2. hello?

async function于await:
菜鸟教程解释:async 函数中可能会有 await 表达式，async 函数执行时，如果遇到 await 就会先暂停执行 ，等到触发的异步操作完成后，恢复 async 函数的执行并返回解析值。

await

await 操作符用于等待一个 Promise 对象, 它只能在异步函数 async function 内部使用。

  1. function delayms(m){
  2.     return new Promise((resolve) => {
  3.         setTimeout(function(){
  4.             console.log('定时器里的log输出了')
  5.             resolve();
  6.         },m)
  7.     })
  8. }
  10. async function asyncCeShiFun(){
  11.     await delayms(2000)
  12.     console.log('async funtion里的log输出了')
  13.     setTimeout(()=>{
  14.         console.log('等待2秒')
  15.     },2000)
  16. }
  17. asyncCeShiFun()

这个例子的输出结果是:

  1. 定时器里的log输出了
  2. async funtion里的log输出了
  3. 等待2秒

人话:先执行await里面的代码。在受await影响的代码没有执行完之前，方法里的代码不会执行

写读取多个文本

  1. async function ReadList(){
  2.     var file = await myFsReadFile('hello.txt')
  3.     console.log(file)
  4. }
  5. ReadList()

你会发现未来的很多框架来写或读取相关的数据

用异步的方式来写，因为同步的方式会降低我们的效率,因为同步它要等