Obsługa błędów za pomocą węzła.strumienie js

Jeśli używasz node >= v10. 0. 0 możesz użyć strumienia .rurociąg i strumień .zakończone .

Na przykład:

const { pipeline, finished } = require('stream');

pipeline(
  input, 
  transformA, 
  transformB, 
  transformC, 
  (err) => {
    if (err) {
      console.error('Pipeline failed', err);
    } else {
      console.log('Pipeline succeeded');
    }
});


finished(input, (err) => {
  if (err) {
    console.error('Stream failed', err);
  } else {
    console.log('Stream is done reading');
  }
});

Domeny są przestarzałe. nie potrzebujesz ich.

W tym pytaniu rozróżnienie między transformacją a zapisywalną nie jest tak ważne.

ODPOWIEDŹ Mshell_lauren jest świetna, ale jako alternatywę możesz również wyraźnie słuchać zdarzenia błędu w każdym strumieniu, który Twoim zdaniem może być błędny. i użyj ponownie funkcji obsługi, jeśli wolisz.

var a = createReadableStream()
var b = anotherTypeOfStream()
var c = createWriteStream()

a.on('error', handler)
b.on('error', handler)
c.on('error', handler)

a.pipe(b).pipe(c)

function handler (err) { console.log(err) }

Błędy z całego łańcucha mogą być propagowane do strumienia po prawej stronie za pomocą prostej funkcji:

function safePipe (readable, transforms) {
    while (transforms.length > 0) {
        var new_readable = transforms.shift();
        readable.on("error", function(e) { new_readable.emit("error", e); });
        readable.pipe(new_readable);
        readable = new_readable;
    }
    return readable;
}

Który może być użyty w następujący sposób:

safePipe(readable, [ transform1, transform2, ... ]);

.on("error", handler) zajmuje się tylko błędami strumienia, ale jeśli używasz niestandardowych strumieni transformacji, .on("error", handler) nie wychwytywaj błędów występujących wewnątrz funkcji _transform. Można więc zrobić coś takiego do sterowania przepływem aplikacji: -

this słowo kluczowe w funkcji _transform odnosi się do samego Stream, które jest EventEmitter. Możesz więc użyć try catch jak poniżej, aby wychwycić błędy, a następnie przekazać je do niestandardowych programów obsługi zdarzeń.

// CustomTransform.js
CustomTransformStream.prototype._transform = function (data, enc, done) {
  var stream = this
  try {
    // Do your transform code
  } catch (e) {
    // Now based on the error type, with an if or switch statement
    stream.emit("CTError1", e)
    stream.emit("CTError2", e)
  }
  done()
}

// StreamImplementation.js
someReadStream
  .pipe(CustomTransformStream)
  .on("CTError1", function (e) { console.log(e) })
  .on("CTError2", function (e) { /*Lets do something else*/ })
  .pipe(someWriteStream)

W ten sposób można zachować logikę i procedury obsługi błędów oddzielnie. Możesz również zdecydować się na obsługę tylko niektórych błędów i ignorowanie innych.

UPDATE
Alternatywa: Rxjs Observable

Użyj pakietu multippe , aby połączyć kilka strumieni w jeden strumień dupleksu. I obsługi błędów w jednym miejscu.

const pipe = require('multipipe')

// pipe streams
const stream = pipe(streamA, streamB, streamC) 


// centralized error handling
stream.on('error', fn)

Użyj Węzła.wzorzec js poprzez stworzenie mechaniki strumienia transformacji i wywołanie jego wywołania zwrotnego done z argumentem w celu propagacji błędu:

var transformStream1 = new stream.Transform(/*{objectMode: true}*/);

transformStream1.prototype._transform = function (chunk, encoding, done) {
  //var stream = this;

  try {
    // Do your transform code
    /* ... */
  } catch (error) {
    // nodejs style for propagating an error
    return done(error);
  }

  // Here, everything went well
  done();
}

// Let's use the transform stream, assuming `someReadStream`
// and `someWriteStream` have been defined before
someReadStream
  .pipe(transformStream1)
  .on('error', function (error) {
    console.error('Error in transformStream1:');
    console.error(error);
    process.exit(-1);
   })
  .pipe(someWriteStream)
  .on('close', function () {
    console.log('OK.');
    process.exit();
  })
  .on('error', function (error) {
    console.error(error);
    process.exit(-1);
   });

Try catch nie wychwytuje błędów, które wystąpiły w strumieniu, ponieważ są one wyrzucane po zakończeniu kodu wywołującego. możesz zapoznać się z dokumentacją:

Https://nodejs.org/dist/latest-v10.x/docs/api/errors.html