Jak tworzyć strumienie z ciągu znaków w węźle.Js?

Nie używaj odpowiedzi życiorysu Jo Lissa. To będzie działać w większości przypadków, ale w moim przypadku stracił mi Dobre 4 lub 5 godzin wykrywania błędów. Nie ma potrzeby stosowania modułów innych firm.

NOWA ODPOWIEDŹ :

var Readable = require('stream').Readable

var s = new Readable
s.push('beep')    // the string you want
s.push(null)      // indicates end-of-file basically - the end of the stream

Powinien to być w pełni zgodny strumień czytelny. Zobacz tutaj aby uzyskać więcej informacji na temat Prawidłowego Korzystania ze strumieni.

STARA ODPOWIEDŹ : Po prostu użyj natywnego strumienia PassThrough:

var stream = require("stream")
var a = new stream.PassThrough()
a.write("your string")
a.end()

a.pipe(process.stdout) // piping will work as normal
/*stream.on('data', function(x) {
   // using the 'data' event works too
   console.log('data '+x)
})*/
/*setTimeout(function() {
   // you can even pipe after the scheduler has had time to do other things
   a.pipe(process.stdout) 
},100)*/

a.on('end', function() {
    console.log('ended') // the end event will be called properly
})

Zauważ, że zdarzenie "close" nie jest emitowane (co jest nie jest wymagane przez interfejsy strumienia).

Po prostu utwórz nową instancję stream i dostosuj ją do swoich potrzeb:

var Stream = require('stream');
var stream = new Stream();

stream.pipe = function(dest) {
  dest.write('your string');
  return dest;
};

stream.pipe(process.stdout); // in this case the terminal, change to ya-csv

Lub

var Stream = require('stream');
var stream = new Stream();

stream.on('data', function(data) {
  process.stdout.write(data); // change process.stdout to ya-csv
});

stream.emit('data', 'this is my string');

Edytuj: odpowiedź Gartha jest chyba lepsza.

Mój stary tekst odpowiedzi jest zachowany poniżej.

Aby przekonwertować łańcuch znaków na strumień, możesz użyć wstrzymanego poprzez stream:

through().pause().queue('your string').end()

Przykład:

var through = require('through')

// Create a paused stream and buffer some data into it:
var stream = through().pause().queue('your string').end()

// Pass stream around:
callback(null, stream)

// Now that a consumer has attached, remember to resume the stream:
stream.resume()

Jest do tego moduł: https://gist.github.com/kawanet/8aea35dc4a578f09757d

/**
* @see https://www.npmjs.com/package/string-to-stream
*/
var str = require('string-to-stream')
str('hi there').pipe(process.stdout) // => 'hi there' 

W kawie-scenariusz:

class StringStream extends Readable
  constructor: (@str) ->
    super()

  _read: (size) ->
    @push @str
    @push null

Użyj go:

new StringStream('text here').pipe(stream1).pipe(stream2)

Zmęczyło mnie, że muszę uczyć się tego co pół roku, więc właśnie opublikowałem moduł npm, aby wyodrębnić szczegóły implementacji:

Https://www.npmjs.com/package/streamify-string

To jest rdzeń modułu:

const Readable = require('stream').Readable;
const util     = require('util');

function Streamify(str, options) {

  if (! (this instanceof Streamify)) {
    return new Streamify(str, options);
  }

  Readable.call(this, options);
  this.str = str;
}

util.inherits(Streamify, Readable);

Streamify.prototype._read = function (size) {

  var chunk = this.str.slice(0, size);

  if (chunk) {
    this.str = this.str.slice(size);
    this.push(chunk);
  }

  else {
    this.push(null);
  }

};

module.exports = Streamify;

str jest string, które muszą zostać przekazane konstruktorowi podczas wywołania i będą wyprowadzane przez strumień jako dane. options są typowymi opcjami, które mogą być przekazywane do strumienia, na dokumentacja .

Według Travisa CI, powinien być kompatybilny z większością wersji node.

Innym rozwiązaniem jest przekazanie funkcji read do konstruktora Readable (cf doc stream readable options)

var s = new Readable({read(size) {
    this.push("your string here")
    this.push(null)
  }});

Możesz po użyciu s. pipe dla exemple

JavaScript jest pisany kaczką, więc jeśli po prostu skopiujesz czytelny API strumienia , będzie działać dobrze. W rzeczywistości prawdopodobnie nie możesz zaimplementować większości z tych metod lub po prostu pozostawić je jako stuby; wszystko, czego potrzebujesz, aby zaimplementować, to to, czego używa biblioteka. Możesz użyć wstępnie zbudowanego węzła EventEmitter klasa do radzenia sobie również z wydarzeniami, więc nie musisz wdrażać addListener i tego typu siebie.

class StringStream extends require('events').EventEmitter
  constructor: (@string) -> super()

  readable: true
  writable: false

  setEncoding: -> throw 'not implemented'
  pause: ->    # nothing to do
  resume: ->   # nothing to do
  destroy: ->  # nothing to do
  pipe: -> throw 'not implemented'

  send: ->
    @emit 'data', @string
    @emit 'end'

Wtedy możesz użyć go jak więc:

stream = new StringStream someString
doSomethingWith stream
stream.send()