smtp-protocolSMTP e-postalarını yakalamak ve posta verileri üzerinde işlem yapmak için kullanan bir Düğüm programını hackliyorum . Kitaplık, posta verilerini bir akış olarak sağlar ve bunu bir dizeye nasıl sokacağımı bilmiyorum.

Şu anda stdout ile yazıyorum stream.pipe(process.stdout, { end: false }), ancak dediğim gibi, bunun yerine akış verisine bir dizede ihtiyacım var, bunu akış sona erdiğinde kullanabilirim.

Bir Node.js akışındaki tüm verileri bir dizeye nasıl toplarım?

(Bu yanıt, yıllar öncesinden, en iyi yanıt olduğu zamandan. Şimdi bunun altında daha iyi bir yanıt var. Node.js ile devam etmedim ve bu soruda "doğru" olarak işaretlendiği için bu yanıtı silemiyorum ". Aşağı tıklamayı düşünüyorsanız, ne yapmamı istersiniz?)

Anahtar, Okunabilir Akışındata ve endolaylarını kullanmaktır . Şu olayları dinleyin:

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

dataOlayı aldığınızda, yeni veri yığınını verileri toplamak için oluşturulan bir Arabelleğe ekleyin.

endOlayı aldığınızda , gerekirse tamamlanan Buffer'ı bir dizeye dönüştürün. O zaman onunla ne yapman gerekiyorsa yap.

Başka bir yol, akışı bir söze dönüştürmek (aşağıdaki örneğe bakın) ve çözümlenen değeri bir değişkene atamak için then(veya await) kullanmaktır .

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)

Yukarıdakilerin hiçbiri benim için işe yaramadı. Buffer nesnesini kullanmam gerekiyordu:

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

Umarım bu yukarıdaki cevaptan daha yararlıdır:

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

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

Dize birleştirme işleminin, dizi parçalarını toplamanın en verimli yolu olmadığını, ancak basitlik için kullanıldığını (ve belki de kodunuzun verimliliği önemsemediğini) unutmayın.

Ayrıca, bu kod ASCII olmayan metinler için öngörülemeyen hatalar üretebilir (her karakterin bir bayta sığdığını varsayar), ancak belki de bunu umursamıyorsunuzdur.

Bir akışı dizeye dönüştürmek için genellikle bu basit işlevi kullanıyorum:

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

Kullanım örneği:

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

Ve vaatleri kullanan dizeler için bir tane daha:

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

Kullanım:

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

.toString()gerekirse ikili verilerle kullanmak için kaldırın .

Güncelleme : @AndreiLED doğru bir şekilde bunun dizelerle ilgili sorunları olduğunu belirtti. Sahip olduğum düğüm sürümüyle dizeleri döndüren bir akış elde edemedim, ancak api bunun mümkün olduğunu belirtiyor.

Nodejs belgelerine göre bunu yapmalısınız - kodlamanın sadece bir grup bayt olduğunu bilmeden her zaman bir dizeyi hatırlayın:

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

Akışların basit bir .toString()işlevi (anladığım) veya işlev gibi (anlamadığım) bir şey .toStringAsync(cb)yok.

Bu yüzden kendi yardımcı işlevimi yarattım:

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

Böyle kullanırken daha çok şansım oldu:

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

Düğümü kullanıyorum v9.11.1ve geri aramadan readstreamgelen yanıt http.get.

En temiz çözüm, bir akışı bir sözle dizgeye dönüştüren "dizgi akışı" paketini kullanmak olabilir.

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

Popüler (haftada 5 milyondan fazla indirme) ve hafif get-stream kitaplığı ile kolay yol :

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

Akış azaltıcı gibi bir şeye ne dersiniz?

İşte ES6 sınıflarının nasıl kullanılacağıyla ilgili bir örnek.

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

Bu benim için çalıştı ve Node v6.7.0 belgelerine dayanıyor :

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');

Aferin Sebastian J yukarıda.

Sahip olduğum birkaç satırlık test koduyla "tampon problemi" yaşadım ve kodlama bilgisini ekledim ve çözdü, aşağıya bakın.

Sorunu gösterin

yazılım

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

giriş

hello world

çıktı

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

Çözümü gösterin

yazılım

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

giriş

hello world

çıktı

string hello world

Listelenen tüm yanıtlar Okunabilir Akışı, NodeJS'de varsayılan olmayan akış modunda açıyor gibi görünmektedir ve NodeJS'nin Duraklatılmış Okunabilir Akış Modunda sağladığı geri basınç desteğinden yoksun olduğundan sınırlamaları olabilir. İşte Just Buffers, Native Stream ve Native Stream Transforms kullanan bir uygulama ve Nesne Modu desteği

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

Bunun hakkında ne düşünüyorsun ?

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

Muhtemelen proje bağımlılıklarınızda zaten sahip olduğunuz oldukça popüler stream-bufferspaketi kullanarak , bu oldukça basittir:

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

Benim durumumda, içerik türü yanıt başlıkları Content-Type: text / plain idi . Bu yüzden, Buffer'daki verileri şöyle okudum:

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