可写流 and 可读流 代码剖析

可读流

/**
 * 可读流调用的方法
 * on
 *  'open'  文件打开是触发
 *  'data'  文件读取时触发
 *  'end'   文件的数据读取完后触发
 *  'close' 文件关闭后触发， 该流将不再出发任何事件
 *  'error' 底层系统内部出错从而不能产生数据，或当流的实现试图传递错误数据时发生 
 */
let EventEmitter = require('events');
let fs = require('fs');
class ReadStream extends EventEmitter {
    constructor (path, options) {
        super();
        this.path = path;
       this.flags = options.flags || 'r';
       this.autoClose = options.autoClose || true;
       this.highWaterMark = options.highWaterMark || 64 * 1024;
       this.start = options.start || 0;
       this.end = options.end;
       this.encoding = options.encoding || null;

       // 文件默认为 暂停模式, 看是否监听了 data 事件， 如果监听了， 就要变成流动模式
       this.flowing= null; 
       // 要建立一个 buffer 来存储读取内容
       this.buffer = Buffer.alloc(this.highWaterMark);
       // pos读取的位置可变的， 但 start 是不变
       this.pos = this.start; 
       this.on('newListener', (eventName, callback) => {
           // 如果监听了  data 事件 文件读取状态需要变成 流动模式
           if (eventName === 'data') {
               this.flowing = true;
               this.read();  // 读区内容
           }
       });
       this.open(); //打开文件

    }

    destroy () {
        if (typeof this.fd === 'number') {
           fs.close(this.fd, () => {
               this.emit('close');
           });
           return;
        }
        this.emit('close'); // 销毁
    }

    resume () {
       // 继续 流动模式
       this.flowing = true;
       this.read();
    }

    pause () {
       // 暂停 流动模式
       this.flowing = false;
    }

    open () {
       fs.open(this.path, this.flags, (err, fd) => {
           if (err) {
               this.emit('error', err);
               if (this.autoClose) {
                   this.destroy();
               }
               return
           }
           this.fd = fd;
           this.emit('open')
       })
    }


      read () {
          // 此时文件可能还没打开
          if (typeof this.fd !== 'number') {
              // 当文件真正打开的时候 会触发open事件，触发事件后再执行read，此时fd肯定有了
              return this.once('open', () => this.read());
          }
          let howMuchToRead = this.end ? Math.min(this.highWaterMark,this.end-this.pos+1) : this.highWaterMark;
          fs.read(this.fd, this.buffer, 0, howMuchToRead, this.pos, (err, bytesRead) => {

              if (bytesRead > 0) { // 读到有内容

                  this.pos += bytesRead;
                  let data = this.encoding ? this.buffer.slice(0, bytesRead).toString(this.encoding) : this.buffer.slice(0, bytesRead);
                  this.emit('data', data);
                  // console.log('xxx,this.pos ',this.pos, 'this.end', this.end  )

                  if (this.pos > this.end) {
                      // console.log('=====xxxx=====')
                      this.emit('end');
                      this.destroy();
                      return
                  }

                  if (this.flowing) { // 流动模式继续触发
                      this.read();
                  }

              } else { // 内容读完
                  this.emit('end');
                  this.destroy();
              }
          });
      }

       pipe (ws) {
           this.on('data', (chunk) => {
               let flag = ws.write(chunk);
               if (!flag) {
                   this.pause();
               }
           });
           ws.on('drain', () => {
               this.resume();
           });
       }
}

module.exports = ReadStream;

可写流

let EventEmitter = require('events');
let fs = require('fs');

class WriteStream extends EventEmitter {
    constructor (path, options) {
        super();
        this.path = path;
        this.highWaterMark = options.highWaterMark || 16 * 1024
        this.autoClose = options.autoClose || true;
        this.mode = options.mode || 0o666;
        this.start = this.start || 0;
        this.flags = options.flags || 'w';
        this.encoding = options.encoding || 'utf-8';

        // 可写流存放缓存的是一个 链表数组
        this.buffers = [];
        this.length = 0;  // 缓存区的大小

        // 标识是否正在写入
        this.writing = false;

        // 是否满足出发 drain 事件
        this.needDrain = false;
        this.pos = this.start;
        this.open();
    }

    open () {
        fs.open(this.path, this.flags, this.mode, (err, fd) => {
            if (err) {
                this.emit('error', err);
                if (this.autoClose) {
                    this.destroy();
                }
                return;
            }
            this.fd = fd;
            this.emit('open');
        });
    }

    destroy () {
        if (typeof this.fd !== 'number') {
            return this.emit('close');
        }
        fs.close(this.fd, () => {
            this.emit('close');
        });
    }

    write (chunk, encoding = this.encoding, callback = () => {}) {
        // 因为写入的内容是个 buffer ， 所以要做个判断
        chunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
        this.length += chunk.length;
        let ret = this.length < this.highWaterMark; // 比较是否到到了缓存区的大小
        this.needDrain = !ret;                      // 是否需要触发 needDrain 事件

        // 判断是否正在写入 如果是正在写入  就写入到缓存区中
        if (this.writing) {
            this.buffers.push({
                chunk,
                encoding,
                callback
            });
        } else {
            this.writing = true;
            // 将内容写入到文件内
            this._write(chunk, encoding, () => {
                // 写入完成后需要将缓存区的内容清空
                callback();
                this.clearBuffer(); // 清空缓存区
            });
        }

        // write 函数返回一个布尔类型的值
        return ret;
    }

    clearBuffer () {
        let buffer = this.buffers.shift();
        if (buffer) {
            this._write(buffer.chunk, buffer.encoding, () => {
                buffer.callback();
                this.clearBuffer();
            })
        } else {
            this.writing = false;
            if (this.needDrain) { // 是否需要出发 drain 事件
                this.needDrain = false;
                this.emit('drain');
            }
        }
    }

    // 真正的写入
    _write (chunk, encoding, callback) {
        if (typeof this.fd !== 'number') {
            return this.once('open', () => this._write(chunk, encoding, callback));
        }
        fs.write(this.fd, chunk, 0, chunk.length, this.pos, (err, bytesWritten) => {
            this.length -= bytesWritten;
            this.pos += bytesWritten;

            callback(); // 清空缓存区的内容
        });
    }
}

module.exports = WriteStream;