new stream.Duplex(options)

• options <Object> 传给 Writable 和 Readable 构造函数。还有以下字段：

  ¥options <Object> Passed to both Writable and Readable constructors. Also has the following fields:

  • allowHalfOpen <boolean> 如果设置为 false，则流将在可读端结束时自动结束可写端。默认值：true。

    ¥allowHalfOpen <boolean> If set to false, then the stream will automatically end the writable side when the readable side ends. Default: true.

  • readable <boolean> 设置 Duplex 是否可读。默认值：true。

    ¥readable <boolean> Sets whether the Duplex should be readable. Default: true.

  • writable <boolean> 设置 Duplex 是否可写。默认值：true。

    ¥writable <boolean> Sets whether the Duplex should be writable. Default: true.

  • readableObjectMode <boolean> 为流的可读端设置 objectMode。如果 objectMode 为 true，则无效。默认值：false。

    ¥readableObjectMode <boolean> Sets objectMode for readable side of the stream. Has no effect if objectMode is true. Default: false.

  • writableObjectMode <boolean> 为流的可写端设置 objectMode。如果 objectMode 为 true，则无效。默认值：false。

    ¥writableObjectMode <boolean> Sets objectMode for writable side of the stream. Has no effect if objectMode is true. Default: false.

  • readableHighWaterMark <number> 为流的可读端设置 highWaterMark。如果提供 highWaterMark，则无效。

    ¥readableHighWaterMark <number> Sets highWaterMark for the readable side of the stream. Has no effect if highWaterMark is provided.

  • writableHighWaterMark <number> 为流的可写端设置 highWaterMark。如果提供 highWaterMark，则无效。

    ¥writableHighWaterMark <number> Sets highWaterMark for the writable side of the stream. Has no effect if highWaterMark is provided.

const { Duplex } = require('node:stream');

class MyDuplex extends Duplex {
  constructor(options) {
    super(options);
    // ...
  }
} 拷贝

或者，当使用 ES6 之前的样式构造函数时：

¥Or, when using pre-ES6 style constructors:

const { Duplex } = require('node:stream');
const util = require('node:util');

function MyDuplex(options) {
  if (!(this instanceof MyDuplex))
    return new MyDuplex(options);
  Duplex.call(this, options);
}
util.inherits(MyDuplex, Duplex); 拷贝

或者，使用简化的构造函数方法：

¥Or, using the simplified constructor approach:

const { Duplex } = require('node:stream');

const myDuplex = new Duplex({
  read(size) {
    // ...
  },
  write(chunk, encoding, callback) {
    // ...
  },
}); 拷贝

使用管道时：

¥When using pipeline:

const { Transform, pipeline } = require('node:stream');
const fs = require('node:fs');

pipeline(
  fs.createReadStream('object.json')
    .setEncoding('utf8'),
  new Transform({
    decodeStrings: false, // Accept string input rather than Buffers
    construct(callback) {
      this.data = '';
      callback();
    },
    transform(chunk, encoding, callback) {
      this.data += chunk;
      callback();
    },
    flush(callback) {
      try {
        // Make sure is valid json.
        JSON.parse(this.data);
        this.push(this.data);
        callback();
      } catch (err) {
        callback(err);
      }
    },
  }),
  fs.createWriteStream('valid-object.json'),
  (err) => {
    if (err) {
      console.error('failed', err);
    } else {
      console.log('completed');
    }
  },
); 拷贝