Làm cách nào để tạo luồng từ chuỗi trong Node.Js?

Tôi đang sử dụng một thư viện, ya-csv , dự kiến ​​một tệp hoặc một luồng làm đầu vào, nhưng tôi có một chuỗi.

Làm cách nào để chuyển đổi chuỗi đó thành một luồng trong Node?

Từ nút 10.17, stream.Readable có một fromphương thức để dễ dàng tạo các luồng từ bất kỳ iterable nào (bao gồm cả mảng bằng chữ):

const { Readable } = require("stream")

const readable = Readable.from(["input string"])

readable.on("data", (chunk) => {
  console.log(chunk) // will be called once with `"input string"`
})

Lưu ý rằng ít nhất trong khoảng từ 10.17 đến 12.3, một chuỗi tự nó có thể lặp lại, do đó Readable.from("input string")sẽ hoạt động, nhưng phát ra một sự kiện cho mỗi ký tự. Readable.from(["input string"])sẽ phát ra một sự kiện cho mỗi mục trong mảng (trong trường hợp này là một mục).

Cũng lưu ý rằng trong các nút sau này (có thể là 12.3, vì tài liệu nói rằng hàm đã được thay đổi sau đó), không còn cần thiết phải bọc chuỗi trong một mảng.

https://nodejs.org/api/stream.html#stream_stream_readable_from_iterable_options

Vì @substack đã sửa tôi trong #node , API luồng mới trong Node v10 giúp việc này dễ dàng hơn:

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

... sau đó bạn có thể tự do ống nó hoặc nếu không vượt qua nó để người tiêu dùng dự định của bạn.

Nó không phải là sạch như resumer một lót, nhưng nó tránh được sự phụ thuộc thêm.

( Cập nhật: từ v0.10.26 đến v9.2.1 cho đến nay, một cuộc gọi đến pushtrực tiếp từ lời nhắc REPL sẽ bị lỗi với một not implementedngoại lệ nếu bạn không đặt _read. Nó sẽ không bị lỗi bên trong một chức năng hoặc tập lệnh. Nếu không nhất quán làm cho bạn lo lắng, bao gồm noop.)

Không sử dụng câu trả lời số liệu của Jo Liss. Nó sẽ hoạt động trong hầu hết các trường hợp, nhưng trong trường hợp của tôi, tôi đã mất 4 hoặc 5 giờ để tìm lỗi. Không cần các mô-đun bên thứ ba để làm điều này.

TRẢ LỜI MỚI :

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

Đây phải là một luồng có thể đọc hoàn toàn tuân thủ. Xem ở đây để biết thêm về cách sử dụng luồng đúng cách.

TRẢ LỜI TRẢ LỜI : Chỉ cần sử dụng luồng PassTh khóa gốc:

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

Lưu ý rằng sự kiện 'đóng' không được phát ra (không bắt buộc bởi các giao diện luồng).

Chỉ cần tạo một phiên bản mới của streammô-đun và tùy chỉnh nó theo nhu cầu của bạn:

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

hoặc là

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

Chỉnh sửa: Câu trả lời của Garth có lẽ tốt hơn.

Văn bản trả lời cũ của tôi được bảo tồn dưới đây.

Để chuyển đổi một chuỗi thành một luồng, bạn có thể sử dụng một luồng được tạm dừng thông qua :

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

Thí dụ:

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

Có một mô-đun cho điều đó: https://www.npmjs.com/package/opes-to-stream

var str = require('string-to-stream')
str('hi there').pipe(process.stdout) // => 'hi there' 

trong kịch bản cà phê:

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

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

sử dụng nó:

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

Một giải pháp khác là chuyển chức năng đọc đến hàm tạo của Readable ( tùy chọn có thể đọc luồng tài liệu cf )

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

bạn có thể sau khi sử dụng s.pipe cho ví dụ

Tôi đã mệt mỏi vì phải học lại điều này sáu tháng một lần, vì vậy tôi chỉ xuất bản một mô-đun npm để trừu tượng hóa các chi tiết thực hiện:

https://www.npmjs.com/package/streamify- chuỗi

Đây là cốt lõi của mô-đun:

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;

strlà stringcái phải được chuyển đến hàm tạo khi gọi và sẽ được luồng ra dưới dạng dữ liệu. optionslà các tùy chọn điển hình có thể được truyền cho một luồng, theo tài liệu .

Theo Travis CI, nó phải tương thích với hầu hết các phiên bản của nút.

Đây là một giải pháp gọn gàng trong TypeScript:

import { Readable } from 'stream'

class ReadableString extends Readable {
    private sent = false

    constructor(
        private str: string
    ) {
        super();
    }

    _read() {
        if (!this.sent) {
            this.push(Buffer.from(this.str));
            this.sent = true
        }
        else {
            this.push(null)
        }
    }
}

const stringStream = new ReadableString('string to be streamed...')

JavaScript được gõ bằng vịt, vì vậy nếu bạn chỉ sao chép API của luồng có thể đọc được , nó sẽ hoạt động tốt. Trên thực tế, có lẽ bạn không thể thực hiện hầu hết các phương thức đó hoặc chỉ để chúng dưới dạng sơ khai; tất cả những gì bạn cần thực hiện là những gì thư viện sử dụng. Bạn cũng có thể sử dụng EventEmitterlớp dựng sẵn của Node để xử lý các sự kiện, do đó bạn không phải tự thực hiện addListenervà như vậy.

Đây là cách bạn có thể triển khai nó trong 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'

Sau đó, bạn có thể sử dụng nó như vậy:

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