ฉันกำลังแฮ็กโปรแกรม 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เหตุการณ์ให้แปลง Buffer ที่เสร็จสมบูรณ์เป็นสตริงหากจำเป็น จากนั้นทำสิ่งที่คุณต้องทำกับมัน

อีกวิธีหนึ่งคือการแปลงสตรีมเป็นสัญญา (ดูตัวอย่างด้านล่าง) และใช้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)

ข้างต้นไม่ได้ผลสำหรับฉัน ฉันต้องการใช้วัตถุบัฟเฟอร์:

  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โทรกลับ

วิธีแก้ปัญหาที่สะอาดที่สุดอาจใช้แพ็กเกจ "สตริงสตรีม" ซึ่งจะแปลงสตรีมเป็นสตริงโดยมีคำมั่นสัญญา

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
})();

คุณคิดอย่างไรเกี่ยวกับเรื่องนี้ ?

// 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")

แล้วตัวลดกระแสล่ะ?

นี่คือตัวอย่างการใช้คลาส 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');

ทำได้ดีมาก Sebastian J ด้านบน

ฉันมี "ปัญหาบัฟเฟอร์" พร้อมรหัสทดสอบสองสามบรรทัดที่ฉันมีและเพิ่มข้อมูลการเข้ารหัสและแก้ไขได้ดูด้านล่าง

แสดงให้เห็นถึงปัญหา

ซอฟต์แวร์

// 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

คำตอบทั้งหมดในรายการดูเหมือนจะเปิด Readable Stream ในโหมดการไหลซึ่งไม่ใช่ค่าเริ่มต้นใน NodeJS และอาจมีข้อ จำกัด เนื่องจากไม่มีการรองรับแรงดันย้อนกลับที่ NodeJS ให้ไว้ในโหมดสตรีมที่อ่านได้หยุดชั่วคราว นี่คือการนำไปใช้งานโดยใช้ Just Buffers, Native Stream และ Native Stream Transforms และรองรับ 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

การใช้แพ็คเกจยอดนิยม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 ดังนั้นฉันได้อ่านข้อมูลจาก Buffer เช่น:

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