Eine eingehende Analyse des Dateiflusses in node.js

In diesem Artikel wird der Dateifluss in Nodejs analysiert. Ich hoffe, er wird Ihnen hilfreich sein!

Dateistream

Aufgrund der unterschiedlichen Lese- und Speichergeschwindigkeiten und der unterschiedlichen Kapazitäten verschiedener Medien im Computer kann es sein, dass sich eine Partei während des Vorgangs längere Zeit in einem Wartezustand befindet

Es gibt drei Haupttypen von Dateien Streams, nämlich Eingabestream (lesbar) , Ausgabestream (beschreibbar) , Duplex-Stream (Duplex) . Es gibt eine andere Art von Stream, die nicht häufig verwendet wird: Transform stream (Transform)转换流（Transform）

在 node 中提供了 stream 模块，这个模块中有两个类实例：Readable 和 Writable，流中都会继承这两个类，因此会有很多共同的方法等。

可读流（Readable）

输入流：数据从源头流向内存，把磁盘里面的数据传输到内存里面。

createReadStream

fs.createReadStream(路径, 配置)

在配置里面有：encoding（编码方式）、start（起始读取字节）、end（结束读取字节）、highWaterMark（每次读取量）

highWaterMark：如果encoding有值，该数量表示一个字符数；如果encoding为null，该数量表示字节数

返回一个Readable的子类ReadStream

const readable = fs.createReadStream(filename, { encoding: 'utf-8', start: 1, end: 2, // highWaterMark: });

注册事件

readable.on(事件名，处理函数)

readable.on('open', (err, data)=> {
    // console.log(err);
    console.log('文件打开了');
})

readable.on('error', (data, err) => {
    console.log(data, err);
    console.log('读取文件发生错误');
})

readable.on('close', (data, err) => {
    // console.log(data, err);
    console.log('文件关闭');
})

readable.close() // 手动触发通过 readable.close()或者在文件读取完毕之后自动关闭--autoClose配置项默认为 true

readable.on('data', (data) => {
    console.log(data);
    console.log('文件正在读取');
})

readable.on('end', ()=>{
    console.log('文件读取完毕');
})

暂停读取

readable.pause() 暂停读取，会触发 pause 事件

恢复读取

readable.resume() 恢复读取，会触发 resume 事件

可写流

const ws = fs.createWriteStream(filename[, 配置])

ws.write(data)

写入一个数据，data 可以使字符串也可以是Buffer，返回一个布尔值。

如果返回的是 true 表示写入通道没有被占满，接下来的数据可以直接写入，写入通道就是配置中的 highWaterMark 表示的大小。

如果返回的是false 表示写入通道占满，其余字符开始等待，出现背压情况。

const ws = fs.createWriteStream(filename, {
    encoding: 'utf-8',
    highWaterMark: 2
})

const flag = ws.write('刘');
console.log(flag); // false 
这里虽然只会执行一次，但是在通道有空余空间的时候就会继续写入，并不在返回 值。

ws.write() 只会返回一次值。


const flag = ws.write('a');
console.log(flag);
const flag1 = ws.write('a');
console.log(flag1);
const flag2 = ws.write('a');
console.log(flag2);
const flag3 = ws.write('a');
console.log(flag3);

输出顺序：true、false、false、false

第二次写入的时候已经占了两字节，第三次写入后直接占满了，所以返回false

使用流复制粘贴文件，并解决背压问题

const filename = path.resolve(__dirname, './file/write.txt');
const wsfilename = path.resolve(__dirname, './file/writecopy.txt');

const ws = fs.createWriteStream(wsfilename);
const rs = fs.createReadStream(filename)

rs.on('data', chumk => {
    const falg = ws.write(chumk);
    if(!falg) {
        rs.pause();
    }
})

ws.on('drain', () => {
    rs.resume();
})

rs.on('close', () => {
    ws.end();
    console.log('copy end');
})

pipe

使用 pipe 也可以直接将 可读流 和 写入流串联起来，也可以解决背压问题

rs.pipe(ws);

rs.on('close', () => {
    ws.end();
    console.log('copy end');
})

学习下来，感觉文件流在大量文件读写的时候是很方便的，并且可以做到快速高效，相比于writeFile和readFile

stellt das Stream-Modul in

node bereit. In diesem Modul gibt es zwei Klasseninstanzen: Readable und Writable. beide werden vom Stream geerbt. Diese beiden Klassen haben daher viele gemeinsame Methoden usw.

Lesbarer Stream (Lesbar)🎜

🎜Eingabestream: Daten fließen von der Quelle zum Speicher und übertragen die Daten von der Festplatte in den Speicher. 🎜

createReadStream

🎜fs.createReadStream(path, Configuration)🎜🎜In der Konfiguration gibt es: Kodierung (Kodierungsmethode), Start ( Start beginnt mit dem Lesen von Bytes), Ende (Ende des Lesens von Bytes), HighWaterMark (Menge, die jedes Mal gelesen wird) 🎜🎜HighWaterMark: Wenn die Codierung einen Wert hat, stellt die Zahl eine Anzahl von Zeichen dar; wenn die Codierung null ist, stellt die Zahl die Anzahl der Bytes dar Gibt eine lesbare Unterklasse ReadStream🎜

🎜const readable = fs.createReadStream(filename, { Kodierung: 'utf-8', Beginn: 1, Ende: 2, // highWaterMark: }) 🎜Lesen fortsetzen🎜🎜🎜readable.resume() Lesen fortsetzen, das Resume-Ereignis wird ausgelöst🎜

🎜Beschreibbarer Stream🎜

🎜const ws = fs . createWriteStream(filename[, Configuration])🎜

ws.write(data)

🎜Daten schreiben, Daten können eine Zeichenfolge oder ein Puffer sein, werden zurückgegeben ein boolescher Wert. 🎜🎜Wenn true zurückgegeben wird, bedeutet dies, dass der Schreibkanal nicht voll ist und die nächsten Daten direkt geschrieben werden können. Der Schreibkanal hat die Größe, die in der Konfiguration durch highWaterMark dargestellt wird. 🎜🎜Wenn false zurückgegeben wird, bedeutet dies, dass der Schreibkanal voll ist und die verbleibenden Zeichen zu warten beginnen, was zu einem Gegendruck führt. 🎜rrreee🎜Verwenden Sie Streams, um Dateien zu kopieren und einzufügen und das Rückdruckproblem zu lösen 🎜rrreee🎜Lernen Sie es, ich finde, dass das Datei-Streaming beim Lesen und Schreiben einer großen Anzahl von Dateien sehr praktisch ist und im Vergleich zu writeFile und readFile schnell und effizient durchgeführt werden kann. Code>, es ist viel effizienter und kann korrekt verarbeitet werden. Es treten keine großen Blockaden auf. 🎜🎜Weitere Informationen zu Knoten finden Sie unter: 🎜nodejs-Tutorial🎜! ! 🎜

Das obige ist der detaillierte Inhalt vonEine eingehende Analyse des Dateiflusses in node.js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!