Interprétation détaillée du système de fichiers et des flux dans nodeJs

Cet article présente principalement l'explication détaillée du système de fichiers nodeJs (fs) et du flux (stream). Maintenant, je le partage avec vous et le donne comme référence.

1. Introduction

Cet article présentera l'utilisation de l'API et des paramètres du système de fichiers node.js (fs) et du flux (stream).

2. Répertoire

Le système de fichiers introduira les méthodes suivantes :

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

Quatre types de flux Événements pour les objets lisibles, inscriptibles, duplex, de transformation et de flux.

3. Introduction aux principales méthodes du système de fichiers fs

1 fs.readFile

La méthode readFile lit principalement le contenu du fichier et opère. de manière asynchrone.

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 écrit les fichiers de manière asynchrone, 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()

Ouvrez le fichier en mode asynchrone, 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 ()

Cette méthode lit les fichiers en mode asynchrone, 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 ()

Cette méthode obtient les informations sur le fichier de manière asynchrone. Le format est : fs.stat(path, callback)

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

Il existe de nombreuses méthodes pour les instances renvoyées de manière asynchrone de la classe stats, telles que stats isFile(). détermine s'il s'agit d'un fichier et stats.isDirectory() détermine s'il s'agit d'un répertoire. . . . . .

6. fs.close()

fs.close() ferme le fichier de manière asynchrone. Le format de syntaxe est : fs.close(fd, callback). 🎜>

d - le descripteur de fichier renvoyé par la méthode fs.open().

callback - fonction de rappel, aucun paramètre.

7. fs.mkdir()

Cette méthode consiste à créer un répertoire. Le format est : fs.mkdir(path[, mode], callback).

chemin :chemin.

mode : autorisations du répertoire, par défaut 0777.

callback : rappel, aucun paramètre.

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

8. fs.rmdir()

Supprimer le répertoire, format de syntaxe : fs.rmdir(path,callback)

9. 🎜>

Cette méthode consiste à lire le répertoire, le format de syntaxe est : fs.readdir(path, callback), la fonction de rappel a deux paramètres, le premier est err et le second est le tableau de fichiers du répertoire .

10. fs.unlink()

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

Cette méthode est utilisée pour supprimer des fichiers, format : 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. Introduction aux types de flux et aux événements

1. Stream : Stream est une interface abstraite. Il existe quatre types de flux :

lisible : lisible. ;
inscriptible : opération inscriptible ;
duplex : opération lisible et inscriptible
transformation ; : L'opération écrit les données puis lit le résultat.
Tous les objets de flux sont des instances d'EventEmitter. Les événements courants sont :

données : déclenchées lorsqu'il y a des données lisibles,
1. <🎜. >
   fin : déclenché lorsqu'aucune donnée n'est lisible,

2. erreur : déclenché lorsqu'une erreur se produit,

3. terminer : Déclenchement complet.

4. 2. Lire les données du flux

3. Écrire dans le flux :

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

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("程序执行完毕");

5. Flux chaîné

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("程序执行完毕");

Le chaînage est un mécanisme qui connecte un flux de sortie à un autre flux et crée plusieurs chaînes d'opérations de flux. Les flux chaînés sont généralement utilisés pour les opérations de pipeline.

Ensuite, nous utiliserons des tuyaux et des chaînes pour compresser et décompresser des fichiers.

J'ai compilé ce qui précède pour vous, j'espère que cela vous sera utile à l'avenir.

//压缩
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("文件解压完成。");

Articles connexes :

Comment implémenter la navigation Panda TV à l'aide de jquery+css3

Comment implémenter des boîtes de dialogue de masquage chronométré dans jQuery

Comment implémenter un délai DIV de quelques secondes avant de disparaître ou de s'afficher dans JS/jQuery

Utilisez JS natif pour obtenir une liaison à trois niveaux de provinces et municipalités

Utilisez les bases de vue pour créer des ajouts, des suppressions, des modifications et des vérifications

Réponses détaillées au presse-papiers des opérations JS

Pratique du projet vue-router (tutoriel détaillé)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!