An article to talk about streams in Node

What is a stream? How to understand flow? The following article will give you an in-depth understanding of streams in Nodejs. I hope it will be helpful to you!

#stream is a stream, which can be understood as a series of bytes that exist like water flow. According to the explanation of Official Document:

A stream is an abstract interface for working with streaming data in Node.js.

A stream is an abstract interface for working with streaming data in Node.js. Processing stream data in Node.js is an abstract interface for continuous bytes. There are 4 basic types of streams, and this article mainly introduces two of them - readable streams and writable streams.

Readable

We can create a readable stream through fs.createReadStream()readableStream , the first parameter can be the file path to be read, for example, the content of the existing file test.txt is:

hello juejin

The second parameter (optional) can be passed in an option object to control the reading Get the starting and ending positions of the data, etc.: [Related tutorial recommendations: nodejs video tutorial]

const fs = require('fs')

const readableStream = fs.createReadStream('./test.txt', {
  start: 6,
  end: 11
})

Note that the read data includes start and end of. As mentioned before when introducing the events module, all streams are instances of EventEmitter. So the data is obtained by listening to the 'data' event:

readableStream.on('data', data => {
  console.log(data)
  console.log(data.toString())
})

The print result is as follows, the default is the Buffer object, which can be passed toString() Method to convert to string:

Note that when reading data, a maximum of 64 * 1024 bytes can be read at a time. If you want to change this value, you can pass highWaterMark Options changed. In addition, you can also use pause() to pause the operation, and use resume() to continue reading:

const readableStream = fs.createReadStream('./test.txt', {
  start: 6,
  end: 11,
  highWaterMark: 2 // 默认为 64 * 1024
})

readableStream.on('data', data => {
  console.log(data)
  console.log(data.toString())
  readableStream.pause() // 暂停读取
  setTimeout(() => {
    readableStream.resume() // 恢复读取
  }, 2000)
})

The execution results are as follows:

In addition to the 'data' event, the readable stream also has other events, such as listening to the file being opened 'open' (the callback will be passed infd parameter), 'end' when the listening file is read to end (the default is reading to the end), 'close' when the listening file is closed (The file will be closed automatically after reading):

readableStream.on('data', data => console.log(data))
readableStream.on('open', fd => console.log(`${fd}文件打开了`))
readableStream.on('end', () => console.log('文件读取到 end 位置了'))
readableStream.on('close', () => console.log('文件已关闭'))

The printing result is as follows:

Writable

Use fs.createWriteStream() You can create a writable stream. The first parameter is passed in the file to be written, and the second parameter is also an optional parameter for configuration. Here we change flags from 'w' indicating overwrite writing to 'a', which means append writing (if the starting point of writing is also specified) The starting position start, in order to be compatible with windows systems, flags should be written as 'r '):

const writableStream = fs.createWriteStream('test.txt', {
  flags: 'a'
})

writableStream.write('养成', err => console.log(`错误信息：${err}`)) // 错误信息：undefined
writableStream.write('写作的')
writableStream.end('好习惯')

Writing data is through write method, the result of executing the code above is to add "Develop a good habit of writing" after the original "hello juejin". The last write can use the end method, so that the 'close' event of the writable stream can be monitored:

writableStream.on('close', () => {
  console.log('关闭')
})

Otherwise, the writable stream needs to be manually writableStream.close() Only when it is closed can the 'close' event be monitored. If the writing is successful, the err of the callback passed in as the second parameter of write()/end() will be undefined.

The readable stream also has other events, such as the 'open' event when the file is opened, when close() or end() 'finish' event after the file writing is completed after being called.

Connection of readable streams and writable streams

Readable streams and writable streams can be connected through the pipe method to realize the file Copy:

const readableStream = fs.createReadStream('./test.txt')
const writableStream = fs.createWriteStream('./copy.txt')

readableStream.pipe(writableStream)

In this way, the text in ./test.txt can be copied to ./copy.txt.

For more node-related knowledge, please visit: nodejs tutorial!

The above is the detailed content of An article to talk about streams in Node. For more information, please follow other related articles on the PHP Chinese website!