Question

我正试图围绕你将如何做到这一点，因为你不能只从transform继承而且它不像似乎就像你可以继承自这个特别writeable stream。

理想情况下，它应该是：

const Writeable = require('Writeable');

class Transform extends Writeable {
  constructor() {
    super();
  }

  _transform(chunk, encoding) {

  }
}

但我可以说这不起作用。我试图继承的特定可写流将是tapjs/tap-parser。理想情况下，我可以利用其中的事件侦听器来解析TAP输出。

Answer 1

嗯，你写了关于Writable但粘贴了Transform的代码，不确定你是否犯了错误，但是如果你故意这样做，这里是一个过夜变换的例子。

line是您的数据，您可以在将其传递之前使用。

let Transform = require("stream").Transform;

class awesome_class_name extends Transform
{
    constructor()
    {
        super()
    }

    _transform (line, encoding, processed) {

        //
        //  Add the data that came in, to the output stream
        //
        this.push(line);

        //
        //  We let system know that we finished processing the data.
        //
        processed();

    }
}

Answer 2

我不确定es6语法，但这里是一个传统的Transform流，它接收TAP输出并输出描述各种解析部分的对象：

const Transform = require('stream').Transform;
const inherits = require('util').inherits;

const Parser = require('tap-parser');

function MyTransform() {
  const self = this;
  this._parser = new Parser();

  Transform.call(this, { readableObjectMode: true });

  this._parser.on('complete', function(results) {
    self.push({ type: 'complete', results });
  }).on('assert', function(assert) {
    self.push({ type: 'assert', assert });
  }).on('comment', function(comment) {
    self.push({ type: 'comment', comment });
  }).on('plan', function(plan) {
    self.push({ type: 'plan', plan });
  }).on('version', function(version) {
    self.push({ type: 'version', version });
  }).on('bailout', function(reason) {
    self.push({ type: 'bailout', reason });
  }).on('extra', function(extra) {
    self.push({ type: 'extra', extra });
  });
}
inherits(MyTransform, Transform);

MyTransform.prototype._write = function(chunk, encoding, cb) {
  this._parser.write(chunk, cb);
};
MyTransform.prototype._flush = function(cb) {
  const self = this;
  this._parser.end(function() {
    self.push(null);
    cb();
  });
};

扩展可写流以成为转换流？

2 个答案: