javascript - passthrough - ¿Cómo crear secuencias de cadena en Node.Js?

stream javascript

Question

Estoy usando una biblioteca, ya-csv , que espera un archivo o una secuencia como entrada, pero tengo una cadena.

¿Cómo convierto esa cadena en una secuencia en Node?

Answer 1

Como @substack me corrigió en #node , la nueva API de transmisiones en el Nodo v10 lo hace más fácil:

var Readable = require(''stream'').Readable;
var s = new Readable();
s._read = function noop() {}; // redundant? see update below
s.push(''your text here'');
s.push(null);

... después de lo cual puede pipe libremente o pasarlo a su consumidor previsto.

No es tan limpio como el resumer una línea, pero evita la dependencia adicional.

( Actualización: en v0.10.26 hasta v9.2.1 hasta el momento, una llamada para push directamente desde el indicador REPL se bloqueará con una excepción not implemented si no configuró _read . No se bloqueará dentro de una función o un script. Si la inconsistencia te pone nervioso, incluye el noop .)

Answer 2

Hay un módulo para eso: 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'' 

Answer 3

JavaScript está escrito en pato, por lo que si solo copia la API de una secuencia legible , funcionará perfectamente. De hecho, probablemente no pueda implementar la mayoría de esos métodos o simplemente dejarlos como talones; todo lo que necesitará implementar es lo que usa la biblioteca. También puede usar la clase EventEmitter para tratar los eventos, de modo que no tenga que implementar addListener y usted mismo.

Así es cómo puede implementarlo en CoffeeScript:

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

Entonces podrías usarlo así:

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

Answer 4

Me cansé de tener que volver a aprender esto cada seis meses, así que acabo de publicar un módulo npm para abstraer los detalles de implementación:

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

Este es el núcleo del módulo:

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 es la string que se debe pasar al constructor al invocarse, y la corriente la generará como datos. options son las opciones típicas que se pueden pasar a una secuencia, según la documentación .

Según Travis CI, debería ser compatible con la mayoría de las versiones de nodo.

Answer 5

No use la respuesta de reanudación de Jo Liss. Funcionará en la mayoría de los casos, pero en mi caso me ha dejado una buena búsqueda de errores de 4 o 5 horas. No hay necesidad de módulos de terceros para hacer esto.

NUEVA RESPUESTA :

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

Esta debería ser una transmisión legible completamente compatible. Consulte aquí para obtener más información sobre cómo usar las transmisiones de manera adecuada.

ANTIGUA RESPUESTA : Solo usa la transmisión nativa 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
})

Tenga en cuenta que el evento ''cerrar'' no se emite (lo cual no es requerido por las interfaces de flujo).

Answer 6

Otra solución es pasar la función de lectura al constructor de lectura legible (ver opciones de lectura de flujo de doc)

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

usted puede después de usar en el tubo para ejemplo

Answer 7

Simplemente cree una nueva instancia del módulo de stream y personalícelo según sus necesidades:

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

o

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

Answer 8

en coffee-script:

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

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

usarlo:

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

Answer 9

Editar: la respuesta de Garth es probablemente mejor.

Mi antiguo texto de respuesta se conserva a continuación.

Para convertir una cadena en una secuencia, puede usar una secuencia en pausa:

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

Ejemplo:

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