Système de fichiers (FS) de Node.js

Node.js FS

Node FS est un module intégré de Node.js qui peut vous aider à gérer et à manipuler les fichiers.

Opérations de fichier NodeJs FS

En utilisant Node FS, vous pouvez effectuer les opérations suivantes sur le fichier :

• Lire le fichier

• Créer ou remplacer un fichier

• Mettre à jour un fichier

• 以下为删除文件的语法格式：

• Renommer un fichier

Node.js fournit un ensemble d'API de manipulation de fichiers similaires aux standards UNIX (POSIX). La syntaxe d'importation du module système de fichiers (fs) de Node est présentée comme suit :

var fs = require("fs")

Asynchrone et synchrone

Les méthodes du module système de fichiers Node.js (module fs) ont des versions asynchrones et synchrones, par exemple, les fonctions de lecture du contenu du fichier ont la lecture asynchrone fs.readFile() et la lecture synchrone fs.readFileSync().

Le dernier paramètre de la fonction de méthode asynchrone est la fonction de rappel, le premier paramètre de la fonction de rappel contient les informations d'erreur (error).

Il est recommandé d'utiliser la méthode asynchrone, car elle est plus performante et plus rapide que la méthode synchrone, et ne bloque pas.

Instance

Créer un fichier input.txt, le contenu est le suivant :

Adresse du site Web du tutoriel de base : fr.oldtoolbag.com
Exemple de lecture de fichier

Créer un fichier file.js, le code est le suivant :

var fs = require("fs");
//　Lecture asynchrone
fs.readFile('input.txt', function(err, data) {
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Lecture asynchrone : "　+　data.toString());
});
//　Lecture synchrone
var data = fs.readFileSync('input.txt');
console.log("Lecture synchrone : "　+　data.toString());
console.log("L'exécution du programme est terminée.");

Les résultats de l'exécution du code ci-dessus sont les suivants :

$ node file.js　
Lecture synchrone : adresse du site officiel du tutoriel de base : fr.oldtoolbag.com
Exemple de lecture de fichier
L'exécution du programme est terminée.
Lecture asynchrone : adresse du site officiel du tutoriel de base : fr.oldtoolbag.com
Exemple de lecture de fichier

Passons maintenant à une compréhension plus détaillée des méthodes du système de fichiers Node.js.

Ouvrir un fichier

Syntaxe

Le format de syntaxe pour ouvrir un fichier en mode asynchrone est le suivant :

fs.open(path, flags[, mode], callback)

Paramètres

Instructions d'utilisation des paramètres suivantes :

• path - Chemin du fichier.

• flags - Comportement d'ouverture de fichier. Les valeurs spécifiques sont détaillées ci-dessous.

• 设置目录权限，默认为 0 - Définir le mode de fichier (droits), les droits par défaut de création de fichier sont 0666(lisible, writable).

• callback - La fonction de rappel contient deux paramètres, par exemple : callback(err, fd).

Les valeurs du paramètre flags peuvent être les suivantes :

Instance

Nous allons créer un fichier file.js et ouvrir le fichier input.txt pour lecture/écriture, le code est le suivant :

var fs = require("fs");
//　Ouvrir un fichier de manière asynchrone
console.log("Préparation à ouvrir le fichier !");
fs.open('input.txt', 'r+', function(err, fd) {
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　console.log("Le fichier a été ouvert avec succès !");　　　　　
});

Les résultats de l'exécution du code ci-dessus sont les suivants :

$ node file.js　
准备打开文件！
文件打开成功！

Obtenir des informations sur le fichier

Syntaxe

Voici le format syntaxique pour obtenir des informations sur le fichier de manière asynchrone :

fs.stat(path,　callback)

Paramètres

Instructions d'utilisation des paramètres suivantes :

• path - Chemin du fichier.

• callback - La fonction de rappel contient deux paramètres, par exemple : (err, stats), stats est un objet fs.Stats.

Après l'exécution de fs.stat(path), l'instance de la classe stats sera renvoyée à la fonction de rappel. Vous pouvez utiliser les méthodes fournies par la classe stats pour juger des attributs relatifs aux fichiers. Par exemple, pour juger s'il s'agit d'un fichier :

var　fs　=　require('fs');
fs.stat('/Users/liuht/code/itbilu/demo/fs.js',　function　(err,　stats)　{
　　　　console.log(stats.isFile());　　　　　　　　　//true
)

Les méthodes de la classe stats incluent :

Instance

Créons le fichier file.js, voici le code :

var fs = require("fs");
console.log("Préparation à ouvrir le fichier !");
fs.stat('input.txt', function(err, stats) {
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log(stats);
　　　console.log("Succès de la lecture des informations de fichier !");
　　　
　　　//　Détection du type de fichier
　　　console.log("Est-ce un fichier (isFile) ? ")　+　stats.isFile());
　　　console.log("Est-ce un répertoire (isDirectory) ? ")　+　stats.isDirectory());　　　　
});

Les résultats de l'exécution du code ci-dessus sont les suivants :

$ node file.js　
准备打开文件！
{ dev:　16777220 ,
　　mode:　33188,
　　nlink:　1,
　　uid:　501,
　　gid:　20 ,
　　rdev: 0 ,
　　blksize:　4096,
　　ino:　40333161,
　　size:　61,
　　blocks:　8,
　　atime: Lun Mer 07　2015　17:43:55　GMT+0800 (CST),
　　mtime: Lun Mer 07　2015　17:22:35　GMT+0800 (CST),
　　ctime: Lun Mer 07　2015　17:22:35　GMT+0800 (CST)}
Succès de la lecture des informations de fichier !
Est-ce un fichier (isFile) ? true
Est-ce un répertoire (isDirectory) ? false

Écrire dans le fichier

Syntaxe

Le format de syntaxe pour écrire un fichier en mode asynchrone est le suivant :

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

fs.writeFile ouvre directement le fichier par défaut est w mode, donc si le fichier existe, le contenu écrit par cette méthode couvrira le contenu ancien du fichier.

Paramètres

Instructions d'utilisation des paramètres suivantes :

• file - Nom de fichier ou descripteur de fichier.

• data - Les données à écrire dans le fichier, qui peuvent être un objet String (chaîne) ou un objet Buffer (tampon).

• options - Ce paramètre est un objet, contenant {encoding, mode, flag}. L'encodage par défaut est utf8, le mode est 0666 ，flag est 'w'

• callback - La fonction de rappel, la fonction de rappel ne contient que le paramètre d'erreur (err), elle est retournée lorsque l'écriture échoue.

Instance

Créons le fichier file.js, voici le code :

var fs = require("fs");
console.log("Préparation à l'écriture de fichier");
fs.writeFile('input.txt', 'Je suis passé par fs.writeFile pour écrire le contenu du fichier', function(err) {
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Les données ont été écrites avec succès !");
　　　console.log("--------Je suis une ligne de séparation-------------")
　　　console.log("Lire les données écrites !");
　　　fs.readFile('input.txt', function(err, data) {
　　　　　　if (err) {
　　　　　　　　　return console.error(err);
　　　　　　}
　　　　　　console.log("Lecture asynchrone des données du fichier : ",　+　data.toString());
　　　});
});

Les résultats de l'exécution du code ci-dessus sont les suivants :

$ node file.js　
Préparation à écrire dans le fichier
Les données ont été écrites avec succès !
--------Je suis une ligne de séparation-------------
Lire les données écrites !
Lecture asynchrone des données du fichier : Je suis passé par fs.writeFile pour écrire le contenu du fichier

Lire le fichier

Syntaxe

Voici le format de syntaxe pour lire le fichier en mode asynchrone :

fs.read(fd, buffer, offset, length, position, callback)

Cette méthode utilise le descripteur de fichier pour lire le fichier.

Paramètres

Instructions d'utilisation des paramètres suivantes :

• fd - Le descripteur de fichier renvoyé par la méthode fs.open().

• buffer - Le tampon d'écriture des données.

• offset - Le décalage d'écriture dans le tampon.

• length - Le nombre d'octets à lire à partir du fichier.

• position - La position de démarrage de la lecture du fichier, si la valeur de position est null, elle lit à partir de la position actuelle du pointeur de fichier.

• callback - La fonction de rappel, avec trois paramètres err, bytesRead, buffer, err pour les informations d'erreur, bytesRead pour le nombre d'octets lus, buffer pour l'objet de tampon.

Instance

site:www.w

Adresse du site Web du tutoriel de base : fr.oldtoolbag.com

Créons le fichier file.js, voici le code :

var fs = require("fs");
var buf = new Buffer.alloc(1024);
console.log("Préparation à ouvrir le fichier existant !");
fs.open('input.txt', 'r+', function(err, fd) {
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Le fichier a été ouvert avec succès !");
　　　console.log("Préparation à lire le fichier :");
　　　fs.read(fd, buf, 0, buf.length, 0, function(err, bytes) {
　　　　　　if (err) {
　　　　　　　　　console.log(err);
　　　　　　}
　　　　　　console.log(bytes　+　" 	Les octets ont été lus");
　　　　　　
　　　　　　//　仅输出读取的字节
　　　　　　if (bytes > 0) {
　　　　　　　　　console.log(buf.slice(0, bytes).toString());
　　　　　　}
　　　});
});

Les résultats de l'exécution du code ci-dessus sont les suivants :

$ node file.js　
Préparation à ouvrir le fichier existant !
文件打开成功！
Préparation à lire le fichier :
42　　Les octets ont été lus
Adresse du site Web du tutoriel de base : fr.oldtoolbag.com

关闭文件

Syntaxe

Voici le format de syntaxe pour fermer le fichier en mode asynchrone :

fs.close(fd, callback)

Cette méthode utilise le descripteur de fichier pour lire le fichier.

Paramètres

Instructions d'utilisation des paramètres suivantes :

• fd - Le descripteur de fichier renvoyé par la méthode fs.open().

• callback - Fonction callback, sans paramètres.

Instance

site:www.w

Adresse du site Web du tutoriel de base : fr.oldtoolbag.com

Créons le fichier file.js, voici le code :

var fs = require("fs");
var buf = new Buffer.alloc(1024);
console.log("Préparation à ouvrir le fichier !");
fs.open('input.txt', 'r+', function(err, fd) {
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Le fichier a été ouvert avec succès !");
　　　console.log("Préparation à lire le fichier !");
　　　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());
　　　　　　}
　　　　　　//　关闭文件
　　　　　　fs.close(fd, function(err) {
　　　　　　　　　if (err) {
　　　　　　　　　　　　console.log(err);
　　　　　　　　　}　
　　　　　　　　　console.log("Le fichier a été fermé avec succès");
　　　　　　});
　　　});
});

Les résultats de l'exécution du code ci-dessus sont les suivants :

$ node file.js　
准备打开文件！
文件打开成功！
Préparation à lire le fichier !
Adresse du site Web du tutoriel de base : fr.oldtoolbag.com
删除文件

截取文件

Syntaxe

Voici le format de syntaxe pour couper le fichier en mode asynchrone :

fs.ftruncate(fd, len, callback)

Cette méthode utilise le descripteur de fichier pour lire le fichier.

Paramètres

Instructions d'utilisation des paramètres suivantes :

• fd - Le descripteur de fichier renvoyé par la méthode fs.open().

• len - La longueur de la section de contenu du fichier.

• callback - Fonction callback, sans paramètres.

Instance

site:www.w

console.log("准备删除文件！");3codebox.com

Créons le fichier file.js, voici le code :

var fs = require("fs");
var buf = new Buffer.alloc(1024);
console.log("Préparation à ouvrir le fichier !");
fs.open('input.txt', 'r+', function(err, fd) {
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Le fichier a été ouvert avec succès !");
　　　console.log("截取"}10字节内的文件内容，超出部分将被去除。
　　　
　　　//　截取文件
　　　fs.ftruncate(fd,　10, function(err) {
　　　　　　if (err) {
　　　　　　　　　console.log(err);
　　　　　　}　
　　　　　　console.log("文件截取成功。");
　　　　　　console.log("读取相同的文件");　
　　　　　　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());
　　　　　　　　　}
　　　　　　　　　//　关闭文件
　　　　　　　　　fs.close(fd, function(err) {
　　　　　　　　　　　　if (err) {
　　　　　　　　　　　　　　　console.log(err);
　　　　　　　　　　　　}　
　　　　　　　　　　　　console.log("文件关闭成功！");
　　　　　　　　　});
　　　　　　});
　　　});
});

Les résultats de l'exécution du code ci-dessus sont les suivants :

$ node file.js　
准备打开文件！
文件打开成功！
截取10字节内的文件内容，超出部分将被去除。
文件截取成功。
读取相同的文件
site:www.r
删除文件

以下为删除文件的语法格式：

Syntaxe

fs.unlink(path, callback)

input.txt 文件内容为：

Paramètres

Instructions d'utilisation des paramètres suivantes :

• path - Chemin du fichier.

• callback - Fonction callback, sans paramètres.

Instance

site:www.w

console.log("准备删除文件！");3codebox.com

Créons le fichier file.js, voici le code :

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

Les résultats de l'exécution du code ci-dessus sont les suivants :

$ node file.js　
文件删除成功！
再去查看 input.txt 文件，发现已经不存在了。

以下为创建目录的语法格式：

创建目录

Syntaxe

fs.mkdir(path[,　options],　callback)

options 参数可以是：

Paramètres

Instructions d'utilisation des paramètres suivantes :

• path - Chemin du fichier.

• recursive

• 是否以递归的方式创建目录，默认为 false。 - mode

• 设置目录权限，默认为 0 - tmp　目录必须存在777.

• callback - Fonction callback, sans paramètres.

Instance

Créons le fichier file.js, voici le code :

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

Les résultats de l'exécution du code ci-dessus sont les suivants :

$ node file.js　
创建目录　/tmp/test/
目录创建成功。

可以添加 　recursive: true 参数，不管创建的目录 　/tmp 和 /tmp/a 是否存在：

fs.mkdir('/tmp/a/apple', { recursive: true }, (err) => {
　　if (err) throw err;
});

Lecture du répertoire

Syntaxe

Voici le format syntaxique de la lecture du répertoire :

fs.readdir(path, callback)

Paramètres

Instructions d'utilisation des paramètres suivantes :

• path - Chemin du fichier.

• callback - Fonction callback, la fonction callback contient deux paramètres err, files, err est l'information d'erreur, files est la liste des fichiers du répertoire.

Instance

Créons le fichier file.js, voici le code :

var fs = require("fs");
console.log("Voir　/Répertoire tmp
fs.readdir("/tmp/",function(err, files){
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　files.forEach(function(file){
　　　　　　　console.log(file);
　　　});
});

Les résultats de l'exécution du code ci-dessus sont les suivants :

$ node file.js　
Voir　/Répertoire tmp
input.out
output.out
test
test.txt

Suppression de répertoire

Syntaxe

Voici le format syntaxique de la suppression de répertoire :

fs.rmdir(path, callback)

Paramètres

Instructions d'utilisation des paramètres suivantes :

• path - Chemin du fichier.

• callback - Fonction callback, sans paramètres.

Instance

Créons le fichier file.js, voici le code :

var fs = require("fs");
//　Créer un répertoire vide avant l'exécution　/tmp/Répertoire test
console.log("Préparer à supprimer le répertoire　/tmp/test");
fs.rmdir("/tmp/test", function(err){
　　　if (err) {
　　　　　　　return console.error(err);
　　　}
　　　console.log("Lecture　/Répertoire tmp
　　　fs.readdir("/tmp/",function(err, files){
　　　　　　if (err) {
　　　　　　　　　　return console.error(err);
　　　　　　}
　　　　　　files.forEach(function(file){
　　　　　　　　　　console.log(file);
　　　　　　});
　　　});
});

Les résultats de l'exécution du code ci-dessus sont les suivants :

$ node file.js　
Préparer à supprimer le répertoire　/tmp/test
Lecture　/Répertoire tmp
……

Manuel de référence des méthodes du module fichier

Voici la liste des méthodes équivalentes du module fichier de Node.js :

Pour plus de détails, consultez la description du module de fichiers sur le site officiel :Système de fichiers.