12-文件

    function readFileSync(path, options) {  
      options = getOptions(options, { flag: 'r' });  
      // 传的是fd还是文件路径  
      const isUserFd = isFd(path);   
      // 传的是路径，则先同步打开文件  
      const fd = isUserFd ? path : fs.openSync(path, options.flag, 0o666);  
      // 查看文件的stat信息，拿到文件的大小  
      const stats = tryStatSync(fd, isUserFd);  
      // 是否是一般文件  
      const size = isFileType(stats, S_IFREG) ? stats[8] : 0;  
      let pos = 0;  
      let buffer; 
      let buffers;  
      // 文件大小是0或者不是一般文件，size则为0  
      if (size === 0) {  
        buffers = [];  
      } else {  
        // 一般文件且有大小，则分配一个大小为size的buffer，size需要小于2G  
        buffer = tryCreateBuffer(size, fd, isUserFd);  
      }  

      let bytesRead;  
      // 不断地同步读文件内容  
      if (size !== 0) {  
        do {  
          bytesRead = tryReadSync(fd, isUserFd, buffer, pos, size - pos);  
          pos += bytesRead;  
        } while (bytesRead !== 0 && pos < size);  
      } else {  
        do {  
          /* 
            文件大小为0，或者不是一般文件，也尝试去读， 
            但是因为不知道大小，所以只能分配一个一定大小的buffer, 
            每次读取一定大小的内容 
          */  
          buffer = Buffer.allocUnsafe(8192);  
          bytesRead = tryReadSync(fd, isUserFd, buffer, 0, 8192);  
          // 把读取到的内容放到buffers里  
          if (bytesRead !== 0) {  
            buffers.push(buffer.slice(0, bytesRead));  
          }  
          // 记录读取到的数据长度  
          pos += bytesRead;  
        } while (bytesRead !== 0);  
      }  
      // 用户传的是文件路径，Node.js自己打开了文件，所以需要自己关闭  
      if (!isUserFd)  
        fs.closeSync(fd);  
      // 文件大小是0或者非一般文件的话，如果读到了内容  
      if (size === 0) {  
        // 把读取到的所有内容放到buffer中  
        buffer = Buffer.concat(buffers, pos);  
      } else if (pos < size) {  
        buffer = buffer.slice(0, pos);  
      }  
      // 编码
      if (options.encoding) buffer = buffer.toString(options.encoding);  
      return buffer;  
    }  

    FSReqWrapSync req_wrap_sync;  
    const int bytesRead = SyncCall(env, 
                                       args[6], 
                                       &req_wrap_sync, 
                                       "read",
                                       uv_fs_read, 
                                       fd, 
                                       &uvbuf, 
                                       1, 
                                       pos);  

    int SyncCall(Environment* env, 
                  v8::Local<v8::Value> ctx,  
           FSReqWrapSync* req_wrap, 
                  const char* syscall,  
           Func fn, 
                  Args... args) {  
      /*
         req_wrap->req是一个uv_fs_t结构体，属于request类，
          管理一次文件操作的请求  
        */
      int err = fn(env->event_loop(), 
                        &(req_wrap->req), 
                        args..., 
                        nullptr);  
      // 忽略出错处理
      return err;  
    }  

    function readFile(path, options, callback) {  
      callback = maybeCallback(callback || options);  
      options = getOptions(options, { flag: 'r' });  
      // 管理文件读的对象  
      if (!ReadFileContext)  
        ReadFileContext = require('internal/fs/read_file_context'); 
      const context = new ReadFileContext(callback, options.encoding)
      // 传的是文件路径还是fd  
      context.isUserFd = isFd(path); // File descriptor ownership  
      // C++层的对象，封装了uv_fs_t结构体，管理一次文件读请求  
      const req = new FSReqCallback();  
      req.context = context;  
      // 设置回调，打开文件后，执行  
      req.oncomplete = readFileAfterOpen;  
      // 传的是fd，则不需要打开文件，下一个tick直接执行回调读取文件  
      if (context.isUserFd) {  
        process.nextTick(function tick() {  
          req.oncomplete(null, path);  
        });  
        return;  
      }  

      path = getValidatedPath(path);  
      const flagsNumber = stringToFlags(options.flags);  
      // 调用C++层open打开文件  
      binding.open(pathModule.toNamespacedPath(path),  
            flagsNumber,  
            0o666,  
            req);  
    }  

    function readFileAfterOpen(err, fd) {  
      const context = this.context;  
      // 打开出错则直接执行用户回调，传入err  
      if (err) {  
        context.callback(err);  
        return;  
      }  
      // 保存打开文件的fd  
      context.fd = fd;  
      // 新建一个FSReqCallback对象管理下一个异步请求和回调  
      const req = new FSReqCallback();  
      req.oncomplete = readFileAfterStat;  
      req.context = context;  
      // 获取文件的元数据，拿到文件大小  
      binding.fstat(fd, false, req);  
    }  

    read() {  
        let buffer;  
        let offset;  
        let length;  

        // 省略部分buffer处理的逻辑  
        const req = new FSReqCallback();  
        req.oncomplete = readFileAfterRead;  
        req.context = this;  

        read(this.fd, buffer, offset, length, -1, req);  
      }  

    // 拿到C++层的FSReqCallback对象  
    FSReqBase* req_wrap_async = GetReqWrap(env, args[5]);  
    // 异步调用uv_fs_read  
    AsyncCall(env, req_wrap_async, args, "read", UTF8, AfterInteger,uv_fs_read, fd, &uvbuf, 1, pos);  

    do {                        \  
        if (cb != NULL) {          \  
          uv__req_register(loop, req);  \  
          uv__work_submit(loop,    \  
                    &req->work_req, \  
                    UV__WORK_FAST_IO, \  
                    uv__fs_work, \  
                    uv__fs_done); \  
          return 0;               \  
        }                          \  
        else {                    \  
          uv__fs_work(&req->work_req); \  
          return req->result;     \  
        }                           \  
      }                            \  
      while (0)  

    function watchFile(filename, options, listener) {  
      filename = getValidatedPath(filename);  
      filename = pathModule.resolve(filename);  
      let stat;  
      // 省略部分参数处理逻辑  
      options = {  
        interval: 5007,  
        // 一直轮询  
        persistent: true,  
        ...options  
      };  

      // 缓存处理，filename是否已经开启过监听  
      stat = statWatchers.get(filename);  

      if (stat === undefined) {  
        if (!watchers)  
          watchers = require('internal/fs/watchers');  
        stat = new watchers.StatWatcher(options.bigint);  
        // 开启监听  
        stat[watchers.kFSStatWatcherStart](filename,        
                                               options.persistent, 
                                               options.interval);  
        // 更新缓存            
        statWatchers.set(filename, stat);  
      }  

      stat.addListener('change', listener);  
      return stat;  
    }  

    StatWatcher.prototype[kFSStatWatcherStart] = function(filename,persistent, interval) {  
      this._handle = new _StatWatcher(this[kUseBigint]);  
      this._handle.onchange = onchange;  
      filename = getValidatedPath(filename, 'filename'); 
      const err = this._handle.start(toNamespacedPath(filename), 
                                          interval);  
    }  

    int uv_fs_poll_start(uv_fs_poll_t* handle,uv_fs_poll_cb cb,  
    const char* path, unsigned int interval) {  
      // 管理文件监听的数据结构  
      struct poll_ctx* ctx;  
      uv_loop_t* loop;  
      size_t len;  
      int err;  

      loop = handle->loop;  
      len = strlen(path);  
        // calloc会把内存初始化为0
      ctx = uv__calloc(1, sizeof(*ctx) + len);  
      ctx->loop = loop;  
        // C++层回调
      ctx->poll_cb = cb;  
      // 多久轮询一次  
      ctx->interval = interval ? interval : 1;  
      ctx->start_time = uv_now(loop);  
      // 关联的handle  
      ctx->parent_handle = handle;  
      // 监听的文件路径  
      memcpy(ctx->path, path, len + 1);  
      // 初始化定时器结构体  
      err = uv_timer_init(loop, &ctx->timer_handle);  
      // 异步查询文件元数据  
      err = uv_fs_stat(loop, &ctx->fs_req, ctx->path, poll_cb);  

      if (handle->poll_ctx != NULL)  
        ctx->previous = handle->poll_ctx;  
      // 关联负责管理轮询的对象  
      handle->poll_ctx = ctx;  
      uv__handle_start(handle);  
      return 0;  
    }  

    static void poll_cb(uv_fs_t* req) {  
      uv_stat_t* statbuf;  
      struct poll_ctx* ctx;  
      uint64_t interval;  
      // 通过结构体字段获取结构体首地址  
      ctx = container_of(req, struct poll_ctx, fs_req);  
      statbuf = &req->statbuf;  
      /* 
       第一次不执行回调，因为没有可对比的元数据，第二次及后续的操作才可能
          执行回调，busy_polling初始化的时候为0，第一次执行的时候置
          busy_polling=1 
      */  
      if (ctx->busy_polling != 0)  
        // 出错或者stat发生了变化则执行回调  
        if (ctx->busy_polling < 0 || 
                 !statbuf_eq(&ctx->statbuf, statbuf))  
          ctx->poll_cb(ctx->parent_handle, 
                             0,
                            &ctx->statbuf, 
                             statbuf);  
      // 保存当前获取到的stat信息，置1  
      ctx->statbuf = *statbuf;  
      ctx->busy_polling = 1;  

    out:  
      uv_fs_req_cleanup(req);  

      if (ctx->parent_handle == NULL) { 
        uv_close((uv_handle_t*)&ctx->timer_handle, timer_close_cb);  
        return;  
      }  
      /* 
        假设在开始时间点为1，interval为10的情况下执行了stat，stat
            完成执行并执行poll_cb回调的时间点是3，那么定时器的超时时间
            则为10-3=7，即7个单位后就要触发超时，而不是10，是因为stat
            阻塞消耗了3个单位的时间，所以下次执行超时回调函数时说明从
            start时间点开始算，已经经历了x单位各interval，然后超时回调里
            又执行了stat函数，再到执行stat回调，这个时间点即now=start+x
            单位个interval+stat消耗的时间。得出now-start为interval的
            x倍+stat消耗，即对interval取余可得到stat消耗，所以当前轮，
            定时器的超时时间为interval - ((now-start) % interval) 
      */  
      interval = ctx->interval;  
      interval = (uv_now(ctx->loop) - ctx->start_time) % interval; 

      if (uv_timer_start(&ctx->timer_handle, timer_cb, interval, 0)) 
        abort();  
    }  

    static int statbuf_eq(const uv_stat_t* a, const uv_stat_t* b) {
      return a->st_ctim.tv_nsec == b->st_ctim.tv_nsec  
          && a->st_mtim.tv_nsec == b->st_mtim.tv_nsec  
          && a->st_birthtim.tv_nsec == b->st_birthtim.tv_nsec  
          && a->st_ctim.tv_sec == b->st_ctim.tv_sec  
          && a->st_mtim.tv_sec == b->st_mtim.tv_sec  
          && a->st_birthtim.tv_sec == b->st_birthtim.tv_sec  
          && a->st_size == b->st_size  
          && a->st_mode == b->st_mode  
          && a->st_uid == b->st_uid  
          && a->st_gid == b->st_gid  
          && a->st_ino == b->st_ino  
          && a->st_dev == b->st_dev  
          && a->st_flags == b->st_flags  
          && a->st_gen == b->st_gen;  
    }  

    function watch(filename, options, listener) {  
      // Don't make changes directly on options object  
      options = copyObject(options);  
      // 是否持续监听
      if (options.persistent === undefined) 
          options.persistent = true;  
        // 如果是目录，是否监听所有子目录和文件的变化
      if (options.recursive === undefined) 
          options.recursive = false;  
        // 有些平台不支持
      if (options.recursive && !(isOSX || isWindows))  
        throw new ERR_FEATURE_UNAVAILABLE_ON_PLATFORM('watch recursively');  
      if (!watchers)  
        watchers = require('internal/fs/watchers');  
        // 新建一个FSWatcher对象管理文件监听，然后开启监听
      const watcher = new watchers.FSWatcher();  
      watcher[watchers.kFSWatchStart](filename,  
                      options.persistent,  
                      options.recursive,  
                      options.encoding);  

      if (listener) {  
        watcher.addListener('change', listener);  
      }  

      return watcher;  
    }  

    int main(int argc, char **argv) {  
        // 实现循环核心结构体loop  
        loop = uv_default_loop();   
        uv_fs_event_t *fs_event_req = malloc(sizeof(uv_fs_event_t));
        // 初始化fs_event_req结构体的类型为UV_FS_EVENT  
        uv_fs_event_init(loop, fs_event_req);  
            /* 
              argv[argc]是文件路径，
              uv_fs_event_start 向底层注册监听文件argv[argc],
              cb是事件触发时的回调 
            */  
        uv_fs_event_start(fs_event_req, 
                              cb, 
                              argv[argc], 
                              UV_FS_EVENT_RECURSIVE);  
        // 开启事件循环  
        return uv_run(loop, UV_RUN_DEFAULT);  
    }  

    static int init_inotify(uv_loop_t* loop) {  
      int err;  
      // 初始化过了则直接返回       
      if (loop->inotify_fd != -1)  
        return 0;  
      /*
          调用操作系统的inotify_init函数申请一个inotify实例，
          并设置UV__IN_NONBLOCK，UV__IN_CLOEXEC标记  
        */
      err = new_inotify_fd();  
      if (err < 0)  
        return err;  
      // 记录inotify实例对应的文件描述符,一个事件循环一个inotify实例  
      loop->inotify_fd = err;  
      /*
          inotify_read_watcher是一个IO观察者，
          uv__io_init设置IO观察者的文件描述符（待观察的文件）和回调  
        */
      uv__io_init(&loop->inotify_read_watcher, 
                    uv__inotify_read, 
                    loop->inotify_fd);  
      // 往Libuv中注册该IO观察者，感兴趣的事件为可读  
      uv__io_start(loop, &loop->inotify_read_watcher, POLLIN);  

      return 0;  
    }  

    int uv_fs_event_start(uv_fs_event_t* handle,  
                          uv_fs_event_cb cb,  
                          const char* path,  
                          unsigned int flags) {  
      struct watcher_list* w;  
      int events;  
      int err;  
      int wd;  

      if (uv__is_active(handle))  
        return UV_EINVAL;  
      // 申请一个inotify实例  
      err = init_inotify(handle->loop);  
      if (err)  
        return err;  
      // 监听的事件  
      events = UV__IN_ATTRIB  
             | UV__IN_CREATE  
             | UV__IN_MODIFY  
             | UV__IN_DELETE  
             | UV__IN_DELETE_SELF  
             | UV__IN_MOVE_SELF  
             | UV__IN_MOVED_FROM  
             | UV__IN_MOVED_TO;  
      // 调用操作系统的函数注册一个待监听的文件，返回一个对应于该文件的id  
      wd = uv__inotify_add_watch(handle->loop->inotify_fd, path, events);  
      if (wd == -1)  
        return UV__ERR(errno);  
      // 判断该文件是不是已经注册过了  
      w = find_watcher(handle->loop, wd);  
      // 已经注册过则跳过插入的逻辑  
      if (w)  
        goto no_insert;  
      // 还没有注册过则插入Libuv维护的红黑树  
      w = uv__malloc(sizeof(*w) + strlen(path) + 1);  
      if (w == NULL)  
        return UV_ENOMEM;  

      w->wd = wd;  
      w->path = strcpy((char*)(w + 1), path);  
      QUEUE_INIT(&w->watchers);  
      w->iterating = 0;  
      // 插入Libuv维护的红黑树,inotify_watchers是根节点  
      RB_INSERT(watcher_root, CAST(&handle->loop->inotify_watchers), w);  

    no_insert:  
      // 激活该handle  
      uv__handle_start(handle);  
      // 同一个文件可能注册了很多个回调，w对应一个文件，注册在用一个文件的回调排成队  
      QUEUE_INSERT_TAIL(&w->watchers, &handle->watchers);  
      // 保存信息和回调  
      handle->path = w->path;  
      handle->cb = cb;  
      handle->wd = wd;  

      return 0;  
    }  

    static void uv__inotify_read(uv_loop_t* loop,  
                                 uv__io_t* dummy,  
                                 unsigned int events) {  
      const struct uv__inotify_event* e;  
      struct watcher_list* w;  
      uv_fs_event_t* h;  
      QUEUE queue;  
      QUEUE* q;  
      const char* path;  
      ssize_t size;  
      const char *p;  
      /* needs to be large enough for sizeof(inotify_event) + strlen(path) */  
      char buf[4096];  
      // 一次可能没有读完  
      while (1) {  
        do  
          // 读取触发的事件信息，size是数据大小，buffer保存数据  
          size = read(loop->inotify_fd, buf, sizeof(buf));  
        while (size == -1 && errno == EINTR);  
        // 没有数据可取了  
        if (size == -1) {  
          assert(errno == EAGAIN || errno == EWOULDBLOCK);  
          break;  
        }  
        // 处理buffer的信息  
        for (p = buf; p < buf + size; p += sizeof(*e) + e->len) {  
          // buffer里是多个uv__inotify_event结构体，里面保存了事件信息和文件对应的id（wd字段）  
          e = (const struct uv__inotify_event*)p;  

          events = 0;  
          if (e->mask & (UV__IN_ATTRIB|UV__IN_MODIFY))  
            events |= UV_CHANGE;  
          if (e->mask & ~(UV__IN_ATTRIB|UV__IN_MODIFY))  
            events |= UV_RENAME;  
          // 通过文件对应的id（wd字段）从红黑树中找到对应的节点  
          w = find_watcher(loop, e->wd);  

          path = e->len ? (const char*) (e + 1) : uv__basename_r(w->path);  
          w->iterating = 1;  
          // 把红黑树中，wd对应节点的handle队列移到queue变量，准备处理  
          QUEUE_MOVE(&w->watchers, &queue);  
          while (!QUEUE_EMPTY(&queue)) {  
              // 头结点  
            q = QUEUE_HEAD(&queue);  
            // 通过结构体偏移拿到首地址  
            h = QUEUE_DATA(q, uv_fs_event_t, watchers);  
            // 从处理队列中移除  
            QUEUE_REMOVE(q);  
            // 放回原队列  
            QUEUE_INSERT_TAIL(&w->watchers, q);  
            // 执行回调  
            h->cb(h, path, events, 0);  
          }  
        }  
      }  
    }  

    const fs = require('fs');  
    fs.readFile('filename', 'utf-8' ,(err,data) => {  
      console.log(data)  
    })  
    //为了支持Promise模式，我们通常这样写
    const fs = require('fs');  
    function readFile(filename) {  
        return new Promise((resolve, reject) => {  
            fs.readFile(filename, 'utf-8' ,(err,data) => {  
                err ?  reject(err) : resolve(data);  
            });  
        });  
    }  

    const { open, readFile } = require('fs').promises;  
    async function runDemo() {   
      try {  
        console.log(await readFile('11111.md', { encoding: 'utf-8' }));  
      } catch (e){  

      }  
    }  
    runDemo();  

    const { open, readFile } = require('fs').promises;  
    async function runDemo() {  
      let filehandle;  
      try {  
        filehandle = await open('filename', 'r');  
        // console.log(await readFile(filehandle, { encoding: 'utf-8' }));  
        console.log(await filehandle.readFile({ encoding: 'utf-8' }));  
      } finally {  
        if (filehandle) {  
            await filehandle.close();     
        }  
      }  
    }  
    runDemo();  

    class FileHandle {  
      constructor(filehandle) {  
        // filehandle为C++对象  
        this[kHandle] = filehandle;  
        this[kFd] = filehandle.fd;  
      }  

      get fd() {  
        return this[kFd];  
      }  

      readFile(options) {  
        return readFile(this, options);  
      }  

      close = () => {  
        this[kFd] = -1;  
        return this[kHandle].close();  
      }  
      // 省略部分操作文件的api  
    }  

    async function readFile(path, options) {  
      options = getOptions(options, { flag: 'r' });  
      const flag = options.flag || 'r';  
      // 以面向对象的方式使用，这时候需要自己关闭文件描述符  
      if (path instanceof FileHandle)  
        return readFileHandle(path, options);  
      // 直接调用，首先需要先打开文件描述符，读取完毕后Node.js会主动关闭文件描述符  
      const fd = await open(path, flag, 0o666);  
      return readFileHandle(fd, options).finally(fd.close);  
    }  

    async function readFileHandle(filehandle, options) {  
      // 获取文件元信息  
      const statFields = await binding.fstat(filehandle.fd, false, kUsePromises);  

      let size;  
      // 是不是普通文件，根据文件类型获取对应大小  
      if ((statFields[1/* mode */] & S_IFMT) === S_IFREG) {  
        size = statFields[8/* size */];  
      } else {  
        size = 0;  
      }  
      // 太大了  
      if (size > kIoMaxLength)  
        throw new ERR_FS_FILE_TOO_LARGE(size);  

      const chunks = [];  
      // 计算每次读取的大小  
      const chunkSize = size === 0 ?  
        kReadFileMaxChunkSize :  
        MathMin(size, kReadFileMaxChunkSize);  
      let endOfFile = false;  
      do {  
        // 分配内存承载数据  
        const buf = Buffer.alloc(chunkSize);  
        // 读取的数据和大小  
        const { bytesRead, buffer } =  
          await read(filehandle, buf, 0, chunkSize, -1);  
        // 是否读完了  
        endOfFile = bytesRead === 0;  
        // 读取了有效数据则把有效数据部分存起来  
        if (bytesRead > 0)  
          chunks.push(buffer.slice(0, bytesRead));  
      } while (!endOfFile);  

      const result = Buffer.concat(chunks);  
      if (options.encoding) {  
        return result.toString(options.encoding);  
      } else {  
        return result;  
      }  
    }  

    async function read(handle, buffer, offset, length, position) {  
      // ...  
      const bytesRead = (await binding.read(handle.fd, buffer, offset, length, position, kUsePromises)) || 0;  
      return { bytesRead, buffer };  
    }  

    static void Read(const FunctionCallbackInfo<Value>& args) {  
      Environment* env = Environment::GetCurrent(args);  
      // ...  
      FSReqBase* req_wrap_async = GetReqWrap(env, args[5]);  
      // 异步执行，有两种情况  
      if (req_wrap_async != nullptr) {  
        AsyncCall(env, req_wrap_async, args, "read", UTF8, AfterInteger,  
                  uv_fs_read, fd, &uvbuf, 1, pos);  
      } else {  
        // 同步执行，比如fs.readFileSync  
        CHECK_EQ(argc, 7);  
        FSReqWrapSync req_wrap_sync;  
        FS_SYNC_TRACE_BEGIN(read);  
        const int bytesRead = SyncCall(env, args[6], &req_wrap_sync, "read",  
                                       uv_fs_read, fd, &uvbuf, 1, pos);  
        FS_SYNC_TRACE_END(read, "bytesRead", bytesRead);  
        args.GetReturnValue().Set(bytesRead);  
      }  
    }  

    FSReqBase* req_wrap_async = GetReqWrap(env, args[5]);  

    FSReqBase* GetReqWrap(Environment* env, v8::Local<v8::Value> value,  
                          bool use_bigint) {  
      // 是对象说明是继承FSReqBase的对象,比如FSReqCallback（异步模式）                      
      if (value->IsObject()) {  
        return Unwrap<FSReqBase>(value.As<v8::Object>());  
      } else if (value->StrictEquals(env->fs_use_promises_symbol())) {  
        // Promise模式（异步模式）  
        if (use_bigint) {  
          return FSReqPromise<AliasedBigUint64Array>::New(env, use_bigint);  
        } else {  
          return FSReqPromise<AliasedFloat64Array>::New(env, use_bigint);  
        }  
      }  
      // 同步模式  
      return nullptr;  
    }  

    FSReqBase* req_wrap_async = GetReqWrap(env, args[5]);  
    AsyncCall(env, req_wrap_async, args, "read", UTF8, AfterInteger,  
                  uv_fs_read, fd, &uvbuf, 1, pos);  
继续看AsyncCall函数（node_file-inl.h）
    template <typename Func, typename... Args>  
    FSReqBase* AsyncCall(Environment* env,  
                         FSReqBase* req_wrap,  
                         const v8::FunctionCallbackInfo<v8::Value>& args,  
                         const char* syscall, enum encoding enc,  
                         uv_fs_cb after, Func fn, Args... fn_args) {  
      return AsyncDestCall(env, req_wrap, args,  
                           syscall, nullptr, 0, enc,  
                           after, fn, fn_args...);  
    }  

    template <typename Func, typename... Args>  
    FSReqBase* AsyncDestCall(Environment* env, FSReqBase* req_wrap,  
                             const v8::FunctionCallbackInfo<v8::Value>& args,  
                             const char* syscall, const char* dest,  
                             size_t len, enum encoding enc, uv_fs_cb after,  
                             Func fn, Args... fn_args) {  
      CHECK_NOT_NULL(req_wrap);  
      req_wrap->Init(syscall, dest, len, enc);  
      // 调用libuv函数  
      int err = req_wrap->Dispatch(fn, fn_args..., after);  
      // 失败则直接执行回调，否则返回一个Promise，见SetReturnValue函数  
      if (err < 0) {  
        uv_fs_t* uv_req = req_wrap->req();  
        uv_req->result = err;  
        uv_req->path = nullptr;  
        after(uv_req);  // after may delete req_wrap if there is an error  
        req_wrap = nullptr;  
      } else {  
        req_wrap->SetReturnValue(args);  
      }  

      return req_wrap;  
    }  

    template <typename AliasedBufferT>  
    FSReqPromise<AliasedBufferT>*  
    FSReqPromise<AliasedBufferT>::New(Environment* env, bool use_bigint) {  
      v8::Local<v8::Object> obj;  
      // 创建一个C++对象存到obj中  
      if (!env->fsreqpromise_constructor_template()  
               ->NewInstance(env->context())  
               .ToLocal(&obj)) {  
        return nullptr;  
      }  
      // 设置一个promise属性，值是一个Promise::Resolver  
      v8::Local<v8::Promise::Resolver> resolver;  
      if (!v8::Promise::Resolver::New(env->context()).ToLocal(&resolver) ||  
          obj->Set(env->context(), env->promise_string(), resolver).IsNothing()) {  
        return nullptr;  
      }  
      // 返回另一个C++对象，里面保存了obj，obj也保存了指向FSReqPromise对象的指针  
      return new FSReqPromise(env, obj, use_bigint);  
    }  

    template <typename AliasedBufferT>  
    void FSReqPromise<AliasedBufferT>::SetReturnValue(  
        const v8::FunctionCallbackInfo<v8::Value>& args) {  
      // 拿到Promise::Resolver对象  
      v8::Local<v8::Value> val =  
          object()->Get(env()->context(),  
                        env()->promise_string()).ToLocalChecked();  
      v8::Local<v8::Promise::Resolver> resolver = val.As<v8::Promise::Resolver>();  
      // 拿到一个Promise作为返回值，即JS层拿到的值  
      args.GetReturnValue().Set(resolver->GetPromise());  
    }  

    void AfterInteger(uv_fs_t* req) {  
      // 通过属性拿到对象的地址  
      FSReqBase* req_wrap = FSReqBase::from_req(req);  
      FSReqAfterScope after(req_wrap, req);  

      if (after.Proceed())  
        req_wrap->Resolve(Integer::New(req_wrap->env()->isolate(), req->result));  
    }   

    template <typename AliasedBufferT>  
    void FSReqPromise<AliasedBufferT>::Resolve(v8::Local<v8::Value> value) {  
      finished_ = true;  
      v8::HandleScope scope(env()->isolate());  
      InternalCallbackScope callback_scope(this);  
      // 拿到保存的Promise对象，修改状态为resolve，并设置结果  
      v8::Local<v8::Value> val =  
          object()->Get(env()->context(),  
                        env()->promise_string()).ToLocalChecked();  
      v8::Local<v8::Promise::Resolver> resolver = val.As<v8::Promise::Resolver>();  
      USE(resolver->Resolve(env()->context(), value).FromJust());  
    }

    const bytesRead = (await binding.read(handle.fd, 
                                             buffer, 
                                             offset, 
                                             length,  
                                          position, kUsePromises))|0;  

    const http = require('http');  
    const fs = require('fs');  
    const server = http.createServer((req, res) => {  
      fs.readFile('11111.md', (err, data) => {  
        res.end(data);  
      })  
    }).listen(11111);  

    const http = require('http');  
    const fs = require('fs');  
    const server = http.createServer((req, res) => {  
      fs.createReadStream('11111.md').pipe(res);  
    }).listen(11111);  

    const fs = require('fs');  
    const { Writable } = require('stream');  
    class DemoWritable extends Writable {  
      _write(data, encoding, cb) {  
        console.log(data);  
        cb(null);  
      }  
    }  
    fs.createReadStream('11111.md').pipe(new DemoWritable);  

    const fs = require('fs');  
    const readStream = fs.createReadStream('11111.md');  
    readStream.on('data', (data) => {  
        console.log(data)  
    });  

    fs.createReadStream = function(path, options) {  
      return new ReadStream(path, options);  
    };  

    function ReadStream(path, options) {  
      if (!(this instanceof ReadStream))  
        return new ReadStream(path, options);  

      options = copyObject(getOptions(options, {}));  
      // 可读流的阈值  
      if (options.highWaterMark === undefined)  
        options.highWaterMark = 64 * 1024;  

      Readable.call(this, options);  

      handleError((this.path = getPathFromURL(path)));  
      // 支持传文件路径或文件描述符  
      this.fd = options.fd === undefined ? null : options.fd;  
      this.flags = options.flags === undefined ? 'r' : options.flags;  
      this.mode = options.mode === undefined ? 0o666 : options.mode;  
      // 读取的开始和结束位置  
      this.start = typeof this.fd !== 'number' && options.start === undefined ?  
        0 : options.start;  
      this.end = options.end;  
      // 流出错或结束时是否自动销毁流  
      this.autoClose = options.autoClose === undefined ? true : options.autoClose;  
      this.pos = undefined;  
      // 已读的字节数  
      this.bytesRead = 0;  
      // 流是否已经关闭  
      this.closed = false;  
      // 参数校验  
      if (this.start !== undefined) {  
        if (typeof this.start !== 'number') {  
          throw new errors.TypeError('ERR_INVALID_ARG_TYPE',  
                                     'start',  
                                     'number',  
                                     this.start);  
        }  
        // 默认读取全部内容  
        if (this.end === undefined) {  
          this.end = Infinity;  
        } else if (typeof this.end !== 'number') {  
          throw new errors.TypeError('ERR_INVALID_ARG_TYPE',  
                                     'end',  
                                     'number',  
                                     this.end);  
        }  

        // 从文件的哪个位置开始读，start是开始位置，pos是当前位置，初始化等于开始位置  
        this.pos = this.start;  
      }  
      // 如果是根据一个文件名创建一个流，则首先打开这个文件  
      if (typeof this.fd !== 'number')  
        this.open();  

      this.on('end', function() {  
        // 流结束时自动销毁流  
        if (this.autoClose) {  
          this.destroy();  
        }  
      });  
    }