Detaillierte Interpretation des Dateisystems und der Streams in NodeJs

Dieser Artikel stellt hauptsächlich die detaillierte Erklärung des NodeJs-Dateisystems (fs) und des Streams (Stream) vor. Jetzt teile ich ihn mit Ihnen und gebe ihn als Referenz.

1. Einführung

In diesem Artikel werden einige APIs und Parameterverwendungen des Dateisystems (fs) und des Streams (Stream) von node.js vorgestellt.

2. Verzeichnis

Das Dateisystem führt die folgenden Methoden ein:

1.fs.readFile

2.fs .writeFile

3.fs.open

4.fs.read

5.fs.stat

6.fs.close

7.fs.mkdir

8.fs.rmdir

9.fs.readdir

10.fs.unlink

Vier Arten von Streams Ereignisse für lesbare, beschreibbare, Duplex-, Transformations- und Stream-Objekte.

3. Einführung in die Hauptmethoden des Dateisystems fs

1. Die readFile-Methode liest hauptsächlich den Dateiinhalt und führt sie aus asynchron.

var fs = require('fs')
fs.readFile('a.txt',function(err,data){
  if (err){
    return console.error(err);
  }else{
    console.log("异步读取: " + data.toString());
  }
})

2. fs.writeFile

writeFile schreibt Dateien asynchron, fs.writeFile(file, data[, options], callback)

var fs = require('fs')
console.log("准备写入文件")
fs.writeFile('input.txt',"写入的内容",function(err){
  if (err){
    return console.error(err);
  }else{
    console.log("写入成功");
  }
})

3. fs.open( )

Öffnen Sie die Datei im asynchronen Modus, fs.open(path, flags[, mode], callback)

var fs = require("fs");
// 异步打开文件
console.log("准备打开文件");
fs.open('a.txt', 'r+', function(err, fd) {//r+是以读写模式打开，fd为返回的文件描述符
  if (err) {
    return console.error(err);
  }
 console.log("文件打开成功！");   
});

4, fs.read()

Diese Methode liest Dateien im asynchronen Modus, Format: fs.read(fd, buffer, offset, length, position, callback)

var fs = require("fs");
var buf = new Buffer(1024);

console.log("准备打开文件！");
fs.open('at.txt', 'r+', function(err, fd) {
  if (err) {
    return console.error(err);
  }
  fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
   if (err){
     console.log(err);
   }
   // 仅输出读取的字节
   if(bytes > 0){
     console.log(buf.slice(0, bytes).toString());
   }
  });
});

5, fs.stat()

Diese Methode ruft Dateiinformationen asynchron ab . Das Format ist: fs.stat(path, callback)

fs.stat('fs.js', function (err, stats) {
  console.log(stats.isFile());     //true
})

Es gibt viele Methoden für asynchron zurückgegebene Instanzen der Stats-Klasse, wie zum Beispiel stats.isFile(), um zu bestimmen, ob es sich um eine Datei handelt, stats. isDirectory() ermittelt, ob es sich um ein Verzeichnis handelt. . . . . .

6. fs.close()

fs.close() schließt die Datei asynchron. Das Syntaxformat ist: fs.close(fd, callback). 🎜>

d – der von der Methode fs.open() zurückgegebene Dateideskriptor.

Rückruf – Rückruffunktion, keine Parameter.

7. fs.mkdir()

Diese Methode dient zum Erstellen eines Verzeichnisses. Das Format lautet: fs.mkdir(path[, mode], callback).

Pfad :Pfad.

Modus: Verzeichnisberechtigungen, Standard 0777.

Rückruf: Rückruf, keine Parameter.

var fs = require("fs");
console.log("创建目录/test/");
fs.mkdir("/test/",function(err){
  if (err) {
    return console.error(err);
  }
  console.log("创建/test目录成功。");
});

8. fs.rmdir()

Verzeichnis löschen, Syntaxformat: fs.rmdir(path,callback)

9. fs.readdir()

Diese Methode dient zum Lesen des Verzeichnisses. Das Syntaxformat lautet: fs.readdir (Pfad, Rückruf). Die Rückruffunktion hat zwei Parameter, der erste ist err und der zweite sind die Dateiarray-Dateien im Verzeichnis.

var fs = require("fs");

console.log("查看 /tmp 目录");
fs.readdir("/tmp/",function(err, files){
  if (err) {
    return console.error(err);
  }
  files.forEach( function (file){
    console.log( file );
  });
});

10. fs.unlink()

Diese Methode wird zum Löschen von Dateien verwendet. Das Format ist: fs.unlink(path, callback)

var fs = require("fs");

console.log("准备删除文件！");
fs.unlink('input.txt', function(err) {
  if (err) {
    return console.error(err);
  }
  console.log("文件删除成功！");
});

4. Stream-Einführung in Stream-Typen und Ereignisse

1. Stream: Stream ist eine abstrakte Schnittstelle. Es gibt vier Stream-Typen:

readable: lesbar;

1. beschreibbar: beschreibbarer Betrieb;

2. Duplex: lesbarer und beschreibbarer Betrieb; Operation Daten werden geschrieben und das Ergebnis wird gelesen.

3. Alle Stream-Objekte sind Instanzen von EventEmitter:

4. Daten: Wird ausgelöst, wenn lesbare Daten vorhanden sind,

Ende: wird ausgelöst, wenn keine Daten lesbar sind,

1. Fehler: wird ausgelöst, wenn ein Fehler auftritt,

2. Ende: Vollständiger Abzug.

3. 2. Daten aus dem Stream lesen

var fs = require("fs");
var data = '';

// 创建可读流
var readerStream = fs.createReadStream('input.txt');

// 设置编码为 utf8。
readerStream.setEncoding('UTF8');

// 处理流事件 --> data, end, and error
readerStream.on('data', function(chunk) {
  data += chunk;
});

readerStream.on('end',function(){
  console.log(data);
});

readerStream.on('error', function(err){
  console.log(err.stack);
});

console.log("程序执行完毕");

4. 3. In den Stream schreiben:

   var fs = require("fs");
   var data = '写入流数据';
   
   // 创建一个可以写入的流，写入到文件 output.txt 中
   var writerStream = fs.createWriteStream('output.txt');
   
   // 使用 utf8 编码写入数据
   writerStream.write(data,'UTF8');
   
   // 标记文件末尾
   writerStream.end();
   
   // 处理流事件 --> data, end, and error
   writerStream.on('finish', function() {
     console.log("写入完成。");
   });
   
   writerStream.on('error', function(err){
     console.log(err.stack);
   });
   
   console.log("程序执行完毕");

   4. Pipe-Stream (Pipe)

var fs = require("fs");

// 创建一个可读流
var readerStream = fs.createReadStream('input.txt');

// 创建一个可写流
var writerStream = fs.createWriteStream('output.txt');

// 管道读写操作
// 读取 input.txt 文件内容，并将内容写入到 output.txt 文件中
readerStream.pipe(writerStream);
console.log("程序执行完毕");

5. Verketteter Fluss

Verkettung ist ein Mechanismus, der einen Ausgabestream mit einem anderen Stream verbindet und mehrere Stream-Operationsketten erstellt. Verkettete Flüsse werden im Allgemeinen für Pipeline-Operationen verwendet.

Als nächstes verwenden wir Rohre und Ketten zum Komprimieren und Dekomprimieren von Dateien.

//压缩
var fs = require("fs");
var zlib = require('zlib');

// 压缩 input.txt 文件为 input.txt.gz
fs.createReadStream('input.txt')
 .pipe(zlib.createGzip())
 .pipe(fs.createWriteStream('input.txt.gz'));
console.log("文件压缩完成。");

//解压
var fs = require("fs");
var zlib = require('zlib');
// 解压 input.txt.gz 文件为 input.txt
fs.createReadStream('input.txt.gz')
 .pipe(zlib.createGunzip())
 .pipe(fs.createWriteStream('input.txt'));
console.log("文件解压完成。");

Ich habe das Obige für Sie zusammengestellt und hoffe, dass es Ihnen in Zukunft hilfreich sein wird.

Verwandte Artikel:

So implementieren Sie die Panda-TV-Navigation mit jquery+css3

So implementieren Sie zeitgesteuerte Ausblenddialogfelder in jQuery

So implementieren Sie eine DIV-Verzögerung für einige Sekunden, bevor sie in JS/jQuery verschwindet oder angezeigt wird

Verwenden Sie native JS, um eine dreistufige Verknüpfung von zu erreichen Provinzen und Gemeinden

Verwenden Sie Vue-Grundlagen zum Erstellen, Hinzufügen, Löschen, Ändern und Überprüfen

Detaillierte Antworten auf die JS-Operations-Zwischenablage

Vue-Router-Projektpraxis (ausführliches Tutorial)

Das obige ist der detaillierte Inhalt vonDetaillierte Interpretation des Dateisystems und der Streams in NodeJs. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!