Я зламаю програму Node, яка використовує smtp-protocolдля зйомки SMTP-електронних листів та дії над поштовими даними. Бібліотека надає поштові дані як потік, і я не знаю, як це перетворити в рядок.

Я зараз пишу це в stdout stream.pipe(process.stdout, { end: false }), але, як я вже сказав, мені потрібні дані потоку в рядку, який я можу використовувати, коли потік закінчився.

Як зібрати всі дані з потоку Node.js у рядок?

(Ця відповідь була з років тому, коли це була найкраща відповідь. Зараз є краща відповідь нижче цього. Я не відставав від node.js, і я не можу видалити цю відповідь, оскільки вона позначена "правильною в цьому питанні. ". Якщо ви думаєте про натискання вниз, що ви хочете, щоб я робив це?)

Ключовим моментом є використання dataта endподії читаного потоку . Послухайте ці події:

stream.on('data', (chunk) => { ... });
stream.on('end', () => { ... });

Коли ви отримаєте data подію, додайте новий фрагмент даних до буфера, створеного для збору даних.

Коли ви отримаєте endподію, перетворіть заповнений буфер у рядок, якщо це необхідно. Потім зробіть те, що вам потрібно з цим зробити.

Іншим способом було б перетворення потоку в обіцянку (див. Приклад нижче) та використання then(або await) для присвоєння розв'язаному значенню змінній.

function streamToString (stream) {
  const chunks = []
  return new Promise((resolve, reject) => {
    stream.on('data', chunk => chunks.push(chunk))
    stream.on('error', reject)
    stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')))
  })
}

const result = await streamToString(stream)

Ніщо з перерахованого вище не працювало для мене. Мені потрібно було використовувати об'єкт Buffer:

  const chunks = [];

  readStream.on("data", function (chunk) {
    chunks.push(chunk);
  });

  // Send the buffer or you can put it into a var
  readStream.on("end", function () {
    res.send(Buffer.concat(chunks));
  });

Сподіваюся, це корисніше, ніж наведена вище відповідь:

var string = '';
stream.on('data',function(data){
  string += data.toString();
  console.log('stream data ' + part);
});

stream.on('end',function(){
  console.log('final output ' + string);
});

Зауважте, що конкатенація рядків - не найефективніший спосіб збирання частин рядків, але він використовується для простоти (і, можливо, ваш код не піклується про ефективність).

Крім того, цей код може спричинити непередбачувані збої для тексту, що не належить до ASCII (передбачається, що кожен символ входить в байт), але, можливо, вас це теж не хвилює.

Я зазвичай використовую цю просту функцію для перетворення потоку в рядок:

function streamToString(stream, cb) {
  const chunks = [];
  stream.on('data', (chunk) => {
    chunks.push(chunk.toString());
  });
  stream.on('end', () => {
    cb(chunks.join(''));
  });
}

Приклад використання:

let stream = fs.createReadStream('./myFile.foo');
streamToString(stream, (data) => {
  console.log(data);  // data is now my string variable
});

І ще одна для рядків із використанням обіцянок:

function getStream(stream) {
  return new Promise(resolve => {
    const chunks = [];

    # Buffer.from is required if chunk is a String, see comments
    stream.on("data", chunk => chunks.push(Buffer.from(chunk)));
    stream.on("end", () => resolve(Buffer.concat(chunks).toString()));
  });
}

Використання:

const stream = fs.createReadStream(__filename);
getStream(stream).then(r=>console.log(r));

при необхідності видаліть .toString()для використання бінарні дані.

оновлення : @AndreiLED правильно вказав, що це проблеми з рядками. Я не міг отримати рядки, що повертають потоки, з версією вузла, який у мене є, але api зазначає, що це можливо.

З документації на nodejs ви повинні це зробити - завжди пам'ятайте рядок, не знаючи, що кодування є лише купою байтів:

var readable = getReadableStreamSomehow();
readable.setEncoding('utf8');
readable.on('data', function(chunk) {
  assert.equal(typeof chunk, 'string');
  console.log('got %d characters of string data', chunk.length);
})

У потоків немає ні простої .toString()функції (яку я розумію), ні чогось подібного до .toStringAsync(cb)функції (якої я не розумію).

Тому я створив свою власну функцію помічника:

var streamToString = function(stream, callback) {
  var str = '';
  stream.on('data', function(chunk) {
    str += chunk;
  });
  stream.on('end', function() {
    callback(str);
  });
}

// how to use:
streamToString(myStream, function(myStr) {
  console.log(myStr);
});

У мене було більше удачі, використовуючи таке:

let string = '';
readstream
    .on('data', (buf) => string += buf.toString())
    .on('end', () => console.log(string));

Я використовую вузол, v9.11.1і readstreamце відповідь від http.getзворотного дзвінка.

Найчистішим рішенням може бути використання пакету "string-stream", який перетворює потік у рядок із обіцянкою.

const streamString = require('stream-string')

streamString(myStream).then(string_variable => {
    // myStream was converted to a string, and that string is stored in string_variable
    console.log(string_variable)

}).catch(err => {
     // myStream emitted an error event (err), so the promise from stream-string was rejected
    throw err
})

Простий спосіб за допомогою популярної (понад 5 мільйонів завантажень щотижня) та легкої бібліотеки отримання потоків :

https://www.npmjs.com/package/get-stream

const fs = require('fs');
const getStream = require('get-stream');

(async () => {
    const stream = fs.createReadStream('unicorn.txt');
    console.log(await getStream(stream)); //output is string
})();

А як щодо чогось типу редуктора потоку?

Ось приклад використання класів ES6, як ним користуватися.

var stream = require('stream')

class StreamReducer extends stream.Writable {
  constructor(chunkReducer, initialvalue, cb) {
    super();
    this.reducer = chunkReducer;
    this.accumulator = initialvalue;
    this.cb = cb;
  }
  _write(chunk, enc, next) {
    this.accumulator = this.reducer(this.accumulator, chunk);
    next();
  }
  end() {
    this.cb(null, this.accumulator)
  }
}

// just a test stream
class EmitterStream extends stream.Readable {
  constructor(chunks) {
    super();
    this.chunks = chunks;
  }
  _read() {
    this.chunks.forEach(function (chunk) { 
        this.push(chunk);
    }.bind(this));
    this.push(null);
  }
}

// just transform the strings into buffer as we would get from fs stream or http request stream
(new EmitterStream(
  ["hello ", "world !"]
  .map(function(str) {
     return Buffer.from(str, 'utf8');
  })
)).pipe(new StreamReducer(
  function (acc, v) {
    acc.push(v);
    return acc;
  },
  [],
  function(err, chunks) {
    console.log(Buffer.concat(chunks).toString('utf8'));
  })
);

Це працювало для мене і базується на документах Node v6.7.0 :

let output = '';
stream.on('readable', function() {
    let read = stream.read();
    if (read !== null) {
        // New stream data is available
        output += read.toString();
    } else {
        // Stream is now finished when read is null.
        // You can callback here e.g.:
        callback(null, output);
    }
});

stream.on('error', function(err) {
  callback(err, null);
})

setEncoding ('utf8');

Молодці Себастьян Дж вище.

У мене була "проблема буфера" з декількома рядками тестового коду, який я мав, і додав інформацію про кодування, і вона вирішила її, див. Нижче.

Продемонструйте проблему

програмне забезпечення

// process.stdin.setEncoding('utf8');
process.stdin.on('data', (data) => {
    console.log(typeof(data), data);
});

вхід

hello world

вихід

object <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64 0d 0a>

Продемонструйте розчин

програмне забезпечення

process.stdin.setEncoding('utf8'); // <- Activate!
process.stdin.on('data', (data) => {
    console.log(typeof(data), data);
});

вхід

hello world

вихід

string hello world

Усі перелічені відповіді, як видається, відкривають читабельний потік у поточному режимі, що не є типовим для NodeJS, і може мати обмеження, оскільки йому не вистачає підтримки зворотного тиску, яку надає NodeJS у призупиненому режимі читання потоку. Ось реалізація з використанням просто буферів, Native Stream та Native Stream перетворює та підтримку для Object Mode

import {Transform} from 'stream';

let buffer =null;    

function objectifyStream() {
    return new Transform({
        objectMode: true,
        transform: function(chunk, encoding, next) {

            if (!buffer) {
                buffer = Buffer.from([...chunk]);
            } else {
                buffer = Buffer.from([...buffer, ...chunk]);
            }
            next(null, buffer);
        }
    });
}

process.stdin.pipe(objectifyStream()).process.stdout

Що ти думаєш про це ?

// lets a ReadableStream under stream variable 
const chunks = [];

for await (let chunk of stream) {
    chunks.push(chunk)
}

const buffer  = Buffer.concat(chunks);
const str = buffer.toString("utf-8")

Використовуючи досить популярний stream-buffersпакет, який, напевно, вже є у ваших залежностях від проекту, це досить просто:

// imports
const { WritableStreamBuffer } = require('stream-buffers');
const { promisify } = require('util');
const { createReadStream } = require('fs');
const pipeline = promisify(require('stream').pipeline);

// sample stream
let stream = createReadStream('/etc/hosts');

// pipeline the stream into a buffer, and print the contents when done
let buf = new WritableStreamBuffer();
pipeline(stream, buf).then(() => console.log(buf.getContents().toString()));

У моєму випадку заголовки відповідей типу вмісту були Content-Type: text / plain . Отже, я читав дані з буфера на зразок:

let data = [];
stream.on('data', (chunk) => {
 console.log(Buffer.from(chunk).toString())
 data.push(Buffer.from(chunk).toString())
});