Système de fichiers de Node.js

Le module de système de fichiers de Node.js (modulefs) fournit une API riche pour lire, écrire, supprimer des fichiers et effectuer d'autres opérations sur le système de fichiers.

Le module fs prend en charge les méthodes synchrones et asynchrones, permettant aux développeurs de choisir l'approche appropriée pour les opérations sur les fichiers en fonction de besoins spécifiques.

Importer le module fs

Tout d'abord, vous devez importer le module fs :

var fs = require("fs")

Asynchrone et synchrone

Les méthodes du système de fichiers Node.js (module fs) ont à la fois des versions asynchrones et synchrones. Par exemple, les fonctions de lecture du contenu d'un fichier incluent la méthode asynchrone fs.readFile() et la méthode synchrone fs.readFileSync().

Pour les méthodes asynchrones, le dernier paramètre est une fonction de rappel, et le premier paramètre de la fonction de rappel contient les informations d'erreur (error).

Il est recommandé d'utiliser les méthodes asynchrones. Comparées aux méthodes synchrones, les méthodes asynchrones offrent de meilleures performances, une vitesse plus rapide et aucun blocage.

Exemple

Créez un fichier example.txt avec le contenu suivant :

Example官网地址：www.example.com
文件读取实例

Créez un fichier file.js avec le code suivant :

Exemple

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('example.txt');
console.log("Lecture synchrone : " + data.toString());

console.log("Exécution du programme terminée.");

La sortie du code ci-dessus est la suivante :

$ node file.js 
同步读取: Example官网地址：www.example.com
文件读取实例

程序执行完毕。
异步读取: Example官网地址：www.example.com
文件读取实例

Écrire dans le fichier

Écriture asynchrone dans un fichier :

fs.writeFile('example.txt', 'Hello, World!', (err) => {
    if (err) {
        console.error('Error writing file:', err);
        return;
    }
    console.log('File written successfully');
});

Écriture synchrone dans un fichier :

try {
    fs.writeFileSync('example.txt', 'Hello, World!');
    console.log('File written successfully');
} catch (err) {
    console.error('Error writing file:', err);
}

Ajouter du contenu à un fichier

Ajout asynchrone :

fs.appendFile('example.txt', '\nAppending some text', (err) => {
    if (err) {
        console.error('Error appending to file:', err);
        return;
    }
    console.log('Text appended successfully');
});

Ajout synchrone :

try {
    fs.appendFileSync('example.txt', '\nAppending some text');
    console.log('Text appended successfully');
} catch (err) {
    console.error('Error appending to file:', err);
}

Supprimer un fichier

Suppression asynchrone de fichier :

fs.unlink('example.txt', (err) => {
    if (err) {
        console.error('Error deleting file:', err);
        return;
    }
    console.log('File deleted successfully');
});

Suppression synchrone de fichier :

try {
    fs.unlinkSync('example.txt');
    console.log('File deleted successfully');
} catch (err) {
    console.error('Error deleting file:', err);
}

Créer un répertoire

Création asynchrone de répertoire :

fs.mkdir('new_directory', (err) => {
    if (err) {
        console.error('Error creating directory:', err);
        return;
    }
    console.log('Directory created successfully');
});

Création synchrone de répertoire :

try {
    fs.mkdirSync('new_directory');
    console.log('Directory created successfully');
} catch (err) {
    console.error('Error creating directory:', err);
}

Lire le contenu du répertoire

Lecture asynchrone du contenu d'un répertoire :

fs.readdir('new_directory', (err, files) => {
    if (err) {
        console.error('Error reading directory:', err);
        return;
    }
    console.log('Directory contents:', files);
});

Lecture synchrone du contenu d’un répertoire :

try {
    const files = fs.readdirSync('new_directory');
    console.log('Directory contents:', files);
} catch (err) {
    console.error('Error reading directory:', err);
}

Vérifier si un fichier ou un répertoire existe

Vérification asynchrone :

fs.access('example.txt', fs.constants.F_OK, (err) => {
    if (err) {
        console.log('File does not exist');
    } else {
        console.log('File exists');
    }
});

Vérification synchrone :

try {
    fs.accessSync('example.txt', fs.constants.F_OK);
    console.log('File exists');
} catch (err) {
    console.log('File does not exist');
}

Utilisation avancée

1. Flux de fichiers

Les flux de fichiers peuvent être utilisés pour lire et écrire efficacement des fichiers volumineux sans charger l’intégralité du fichier en mémoire d’un seul coup.

Flux de lecture de fichier :

const fs = require('fs');

const readableStream = fs.createReadStream('large_file.txt', 'utf8');

readableStream.on('data', (chunk) => {
    console.log('Received chunk:', chunk);
});

readableStream.on('end', () => {
    console.log('No more data.');
});

Flux d’écriture de fichier :

const fs = require('fs');

const writableStream = fs.createWriteStream('output.txt');

writableStream.write('Hello, ');
writableStream.write('World!\n');

writableStream.end();

writableStream.on('finish', () => {
    console.log('All writes are now complete.');
});

2. Statistiques du système de fichiers

Vous pouvez utiliserfs.statoufs.lstatpour obtenir des statistiques sur un fichier ou un répertoire.

Obtenir des statistiques de manière asynchrone :

fs.stat('example.txt', (err, stats) => {
    if (err) {
        console.error('Error getting stats:', err);
        return;
    }
    console.log('Is file?', stats.isFile());
    console.log('Is directory?', stats.isDirectory());
    console.log('Size:', stats.size);
});

Obtenir des statistiques de manière synchrone :

try {
    const stats = fs.statSync('example.txt');
    console.log('Is file?', stats.isFile());
    console.log('Is directory?', stats.isDirectory());
    console.log('Size:', stats.size);
} catch (err) {
    console.error('Error getting stats:', err);
}

Ensuite, examinons de plus près les méthodes du système de fichiers Node.js.

Ouvrir un fichier

Syntaxe

Voici la syntaxe pour ouvrir un fichier en mode asynchrone :

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

Parameters

Les paramètres sont décrits comme suit :

path- path : Le chemin du fichier.
flags- flags : Le comportement d'ouverture du fichier. Voir ci-dessous pour les valeurs spécifiques.
mode- mode : Définit le mode du fichier (les permissions). La permission par défaut pour la création de fichier est 0666 (lisible et inscriptible).
callback- callback : La fonction de rappel, avec deux paramètres tels que : callback(err, fd).

Le paramètre flags peut prendre les valeurs suivantes :

Option	Description
r	Ouvrez le fichier en mode lecture seule. Le fichier doit exister. Si le fichier n'existe pas, une exception est levée.
r+	Ouvrez le fichier en mode lecture-écriture. Le fichier doit exister.
rs	Ouvrez le fichier de manière synchrone en mode lecture seule. Il s'agit d'une opération bloquante, mais elle peut offrir une meilleure stabilité sur certains systèmes d'exploitation.
rs+	Ouvrir le fichier de manière synchrone en mode lecture-écriture. Il s'agit d'une opération bloquante, mais elle peut offrir une meilleure stabilité sur certains systèmes d'exploitation.
w	Ouvrir le fichier en mode écriture seule. Si le fichier n'existe pas, il est créé ; s'il existe, il est tronqué.
wx	Semblable à 'w', mais échoue si le chemin existe.
w+	Ouvrir le fichier en mode lecture-écriture. Si le fichier n'existe pas, il est créé ; s'il existe, il est tronqué.
wx+	Semblable à 'w+', mais échoue si le chemin existe.
a	Ouvrir le fichier en mode ajout. Si le fichier n'existe pas, il est créé.
ax	Semblable à 'a', mais échoue si le chemin existe.
a+	Ouvrir le fichier en mode lecture et ajout. Si le fichier n'existe pas, il est créé.
ax+	Semblable à 'a+', mais échoue si le chemin existe.

Exemple

Ensuite, nous créons un fichier file.js et ouvrons input.txt en lecture et en écriture. Le code est le suivant :

var fs = require("fs");

// 异步打开文件
console.log("准备打开文件！");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
       return console.error(err);
   }
  console.log("文件打开成功！");     
});

La sortie du code ci-dessus est la suivante :

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

Obtenir les informations sur le fichier

Syntaxe

Voici la syntaxe pour obtenir les informations d'un fichier en mode asynchrone :

fs.stat(path, callback)

Parameters

Les paramètres sont décrits comme suit :

path- path : Le chemin du fichier.
callback- callback : La fonction de rappel, avec deux paramètres tels que : (err, stats),statsstats est un objet fs.Stats.

Après l'exécution de fs.stat(path), une instance de la classe Stats est renvoyée à sa fonction de rappel. Vous pouvez utiliser les méthodes fournies par la classe Stats pour déterminer les attributs du fichier. Par exemple, pour vérifier 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 sont :

Méthode	Description
stats.isFile()	Renvoie true s'il s'agit d'un fichier, sinon renvoie false.
stats.isDirectory()	Renvoie true s'il s'agit d'un répertoire, sinon renvoie false.
stats.isBlockDevice()	Renvoie true s'il s'agit d'un périphérique bloc, sinon renvoie false.
stats.isCharacterDevice()	Renvoie true s'il s'agit d'un périphérique caractère, sinon renvoie false.
stats.isSymbolicLink()	Renvoie true s'il s'agit d'un lien symbolique, sinon renvoie false.
stats.isFIFO()	Renvoie true s'il s'agit d'un FIFO, sinon renvoie false. FIFO est un type spécial de tube de commande sous UNIX.
stats.isSocket()	Renvoie true s'il s'agit d'un socket, sinon renvoie false.

Exemple

Ensuite, nous créons un fichier file.js. Le code est le suivant :

var fs = require("fs");

console.log("准备打开文件！");
fs.stat('input.txt', function (err, stats) {
   if (err) {
       return console.error(err);
   }
   console.log(stats);
   console.log("读取文件信息成功！");
   
   // 检测文件类型
   console.log("是否为文件(isFile) ? " + stats.isFile());
   console.log("是否为目录(isDirectory) ? " + stats.isDirectory());    
});

La sortie du code ci-dessus est la suivante :

$ node file.js 
准备打开文件！
{ dev: 16777220,
  mode: 33188,
  nlink: 1,
  uid: 501,
  gid: 20,
  rdev: 0,
  blksize: 4096,
  ino: 40333161,
  size: 61,
  blocks: 8,
  atime: Mon Sep 07 2015 17:43:55 GMT+0800 (CST),
  mtime: Mon Sep 07 2015 17:22:35 GMT+0800 (CST),
  ctime: Mon Sep 07 2015 17:22:35 GMT+0800 (CST) }
读取文件信息成功！
是否为文件(isFile) ? true
是否为目录(isDirectory) ? false

Écrire dans le fichier

Syntaxe

Voici la syntaxe pour écrire dans un fichier en mode asynchrone :

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

writeFile ouvre directement le fichier avec le flag par défaut dewmode, donc si le fichier existe, le contenu écrit par cette méthode écrasera l'ancien contenu du fichier.

Parameters

Les paramètres sont décrits comme suit :

file- file: Le nom de fichier ou le descripteur de fichier.
data- data: Les données à écrire dans le fichier, qui peuvent être un objet String ou Buffer.
options- options: Ce paramètre est un objet contenant {encoding, mode, flag}. L'encodage par défaut est utf8, mode vaut 0666, et flag vaut 'w'.
callback- callback: La fonction de rappel contient uniquement le paramètre d'erreur (err), qui est renvoyé en cas d'échec d'écriture.

Exemple

Ensuite, nous créons un fichier file.js. Le code est le suivant :

var fs = require("fs");

console.log("准备写入文件");
fs.writeFile('input.txt', '我是通 过fs.writeFile 写入文件的内容',  function(err) {
   if (err) {
       return console.error(err);
   }
   console.log("数据写入成功！");
   console.log("--------我是分割线-------------")
   console.log("读取写入的数据！");
   fs.readFile('input.txt', function (err, data) {
      if (err) {
         return console.error(err);
      }
      console.log("异步读取文件数据: " + data.toString());
   });
});

La sortie du code ci-dessus est la suivante :

$ node file.js 
准备写入文件
数据写入成功！
--------我是分割线-------------
读取写入的数据！
异步读取文件数据: 我是通 过fs.writeFile 写入文件的内容

Lire le fichier

Syntaxe

Voici la syntaxe pour lire des fichiers en mode asynchrone :

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

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

Parameters

Les instructions d'utilisation des paramètres sont les suivantes :

fd- Le descripteur de fichier renvoyé par la méthode fs.open().
buffer- Le buffer dans lequel les données seront écrites.
offset- Le décalage d'écriture dans le buffer.
length- Le nombre d'octets à lire depuis le fichier.
position- Position de départ pour la lecture du fichier. Si la valeur de position est null, la lecture commencera à partir de la position actuelle du pointeur de fichier.
callback- Fonction de rappel, avec trois paramètres err, bytesRead, buffer. err est le message d'erreur, bytesRead indique le nombre d'octets lus, et buffer est l'objet buffer.

Exemple

Le contenu du fichier input.txt est :

Example官网地址：www.example.com

Ensuite, nous créons le fichier file.js, avec le code comme suit :

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

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

Le résultat d'exécution du code ci-dessus est le suivant :

$ node file.js 
准备打开已存在的文件！
文件打开成功！
准备读取文件：
42  字节被读取
Example官网地址：www.example.com

Fermer le fichier

Syntaxe

Voici la syntaxe pour fermer un fichier en mode asynchrone :

fs.close(fd, callback)

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

Parameters

Les instructions d'utilisation des paramètres sont les suivantes :

fd- Le descripteur de fichier renvoyé par la méthode fs.open().
callback- Fonction de rappel, sans paramètres.

Exemple

Le contenu du fichier input.txt est :

Example官网地址：www.example.com

Ensuite, nous créons le fichier file.js, avec le code comme suit :

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

console.log("准备打开文件！");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
       return console.error(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("文件关闭成功");
      });
   });
});

Le résultat d'exécution du code ci-dessus est le suivant :

$ node file.js 
准备打开文件！
文件打开成功！
准备读取文件！
Example官网地址：www.example.com
文件关闭成功

Tronquer un fichier

Syntaxe

Voici la syntaxe pour tronquer un fichier en mode asynchrone :

fs.ftruncate(fd, len, callback)

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

Parameters

Les instructions d'utilisation des paramètres sont les suivantes :

fd- Le descripteur de fichier renvoyé par la méthode fs.open().
len- La longueur à laquelle le contenu du fichier est tronqué.
callback- Fonction de rappel, sans paramètres.

Exemple

Le contenu du fichier input.txt est :

site:www.example.com

Ensuite, nous créons le fichier file.js, avec le code comme suit :

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

console.log("准备打开文件！");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
       return console.error(err);
   }
   console.log("文件打开成功！");
   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("文件关闭成功！");
         });
      });
   });
});

Le résultat d'exécution du code ci-dessus est le suivant :

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

Supprimer un fichier

Syntaxe

Voici la syntaxe pour supprimer un fichier :

fs.unlink(path, callback)

Parameters

Les instructions d'utilisation des paramètres sont les suivantes :

path- Chemin du fichier.
callback- Fonction de rappel, sans paramètres.

Exemple

Le contenu du fichier input.txt est :

site:www.example.com

Ensuite, nous créons le fichier file.js, avec le code comme suit :

var fs = require("fs");

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

Le résultat d'exécution du code ci-dessus est le suivant :

$ node file.js 
准备删除文件！
文件删除成功！

Ensuite, vérifiez à nouveau le fichier input.txt et constatez qu'il n'existe plus.

Créer un répertoire

Syntaxe

Voici la syntaxe pour créer un répertoire :

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

Parameters

Les instructions d'utilisation des paramètres sont les suivantes :

path- Chemin du fichier.
Le paramètre options peut être :
- recursive - Indique s'il faut créer le répertoire de manière récursive, la valeur par défaut étant false.
- mode- Définit les autorisations du répertoire, la valeur par défaut étant 0777.
callback- Fonction de rappel, sans paramètres.

Exemple

Ensuite, nous créons le fichier file.js, avec le code comme suit :

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

Le résultat d'exécution du code ci-dessus est le suivant :

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

Vous pouvez ajouter le paramètre recursive: true, que les répertoires /tmp et /tmp/a à créer existent déjà ou non :

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

Lire un répertoire

Syntaxe

Voici la syntaxe pour lire un répertoire :

fs.readdir(path, callback)

Parameters

Les instructions d'utilisation des paramètres sont les suivantes :

path- Chemin du fichier.
callback- Fonction de rappel, qui a deux paramètres err, files. err est le message d'erreur, et files est un tableau listant les fichiers du répertoire.

Exemple

Ensuite, nous créons le fichier file.js, avec le code comme suit :

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

Le résultat d'exécution du code ci-dessus est le suivant :

$ node file.js 
查看 /tmp 目录
input.out
output.out
test
test.txt

Supprimer le répertoire

Syntaxe

Voici la syntaxe pour supprimer un répertoire :

fs.rmdir(path, callback)

Parameters

Les instructions d'utilisation des paramètres sont les suivantes :

path- Chemin du fichier.
callback- Fonction de rappel, sans paramètres.

Exemple

Ensuite, nous créons le fichier file.js, avec le code comme suit :

var fs = require("fs");
// 执行前创建一个空的 /tmp/test 目录
console.log("准备删除目录 /tmp/test");
fs.rmdir("/tmp/test",function(err){
   if (err) {
       return console.error(err);
   }
   console.log("读取 /tmp 目录");
   fs.readdir("/tmp/",function(err, files){
      if (err) {
          return console.error(err);
      }
      files.forEach( function (file){
          console.log( file );
      });
   });
});

Le résultat d'exécution du code ci-dessus est le suivant :

$ node file.js 
准备删除目录 /tmp/test
读取 /tmp 目录
……

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

Voici une liste des méthodes du module de fichiers Node.js :

Numéro de série	Metode & Deskripsi
1	fs.rename(oldPath, newPath, callback) rename() asynchrone. La fonction de rappel n'a pas de paramètres, mais peut lever une exception.
2	fs.ftruncate(fd, len, callback) ftruncate() asynchrone. La fonction de rappel n'a pas de paramètres, mais peut lever une exception.
3	fs.ftruncateSync(fd, len) ftruncate() synchrone
4	fs.truncate(path, len, callback) truncate() asynchrone. La fonction de rappel n'a pas de paramètres, mais peut lever une exception.
5	fs.truncateSync(path, len) truncate() synchrone
6	fs.chown(path, uid, gid, callback) chown() asynchrone. La fonction de rappel n'a pas de paramètres, mais peut lever une exception.
7	fs.chownSync(path, uid, gid) Synchrone chown()
8	fs.fchown(fd, uid, gid, callback) Asynchrone fchown(). La fonction de rappel n'a pas de paramètres, mais peut lever une exception.
9	fs.fchownSync(fd, uid, gid) Synchrone fchown()
10	fs.lchown(path, uid, gid, callback) Asynchrone lchown(). La fonction de rappel n'a pas de paramètres, mais peut lever une exception.
11	fs.lchownSync(path, uid, gid) Synchrone lchown()
12	fs.chmod(path, mode, callback) Asynchrone chmod(). La fonction de rappel n'a pas de paramètres, mais peut lever une exception.
13	fs.chmodSync(path, mode) chmod() synchrone.
14	fs.fchmod(fd, mode, callback) fchmod() asynchrone. La fonction de rappel n'a pas de paramètres, mais peut lever une exception.
15	fs.fchmodSync(fd, mode) fchmod() synchrone.
16	fs.lchmod(path, mode, callback) lchmod() asynchrone. La fonction de rappel n'a pas de paramètres, mais peut lever une exception. Disponible uniquement sur Mac OS X.
17	fs.lchmodSync(path, mode) lchmod() synchrone.
18	fs.stat(path, callback) stat() asynchrone. La fonction de rappel a deux paramètres err, stats. stats est un objet fs.Stats.
19	fs.lstat(path, callback) lstat() asynchrone. La fonction de rappel a deux paramètres err, stats. stats est un objet fs.Stats.
20	fs.fstat(fd, callback) fstat() asynchrone. La fonction de rappel a deux paramètres err, stats. stats est un objet fs.Stats.
21	fs.statSync(path) stat() synchrone. Renvoie une instance de fs.Stats.
22	fs.lstatSync(path) lstat() synchrone. Renvoie une instance de fs.Stats.
23	fs.fstatSync(fd) fstat() synchrone. Renvoie une instance de fs.Stats.
24	fs.link(srcpath, dstpath, callback) link() asynchrone. La fonction de rappel n'a aucun paramètre, mais peut lever une exception.
25	fs.linkSync(srcpath, dstpath) link() synchrone.
26	fs.symlink(srcpath, dstpath[, type], callback) symlink() asynchrone. La fonction de rappel n'a aucun paramètre, mais peut lever une exception. Le paramètre type peut être défini sur 'dir', 'file' ou 'junction' (par défaut 'file').
27	fs.symlinkSync(srcpath, dstpath[, type]) symlink() synchrone.
28	fs.readlink(path, callback) readlink() asynchrone. La fonction de rappel a deux paramètres err, linkString.
29	fs.realpath(path[, cache], callback) realpath() asynchrone. La fonction de rappel a deux paramètres err, resolvedPath.
30	fs.realpathSync(path[, cache]) realpath() synchrone. Renvoie le chemin absolu.
31	fs.unlink(path, callback) unlink() asynchrone. La fonction de rappel n'a pas de paramètres, mais peut lever une exception.
32	fs.unlinkSync(path) unlink() synchrone.
33	fs.rmdir(path, callback) rmdir() asynchrone. La fonction de rappel n'a pas de paramètres, mais peut lever une exception.
34	fs.rmdirSync(path) rmdir() synchrone.
35	fs.mkdir(path[, mode], callback) mkdir(2) asynchrone. La fonction de rappel n'a pas de paramètres, mais peut lever une exception. Les permissions d'accès ont par défaut la valeur 0777.
36	fs.mkdirSync(path[, mode]) mkdir() synchrone.
37	fs.readdir(path, callback) readdir(3) asynchrone. Lit le contenu d'un répertoire.
38	fs.readdirSync(path) readdir() synchrone. Renvoie un tableau listant les fichiers.
39	fs.close(fd, callback) close() asynchrone. La fonction de rappel n'a aucun paramètre, mais peut lever une exception.
40	fs.closeSync(fd) close() synchrone.
41	fs.open(path, flags[, mode], callback) Ouvre un fichier de manière asynchrone.
42	fs.openSync(path, flags[, mode]) Version synchrone de fs.open().
43	fs.utimes(path, atime, mtime, callback)
44	fs.utimesSync(path, atime, mtime) Modifier les horodatages du fichier spécifié par le chemin de fichier donné.
45	fs.futimes(fd, atime, mtime, callback)
46	fs.futimesSync(fd, atime, mtime) Modifier les horodatages du fichier spécifié par le descripteur de fichier.
47	fs.fsync(fd, callback) fsync asynchrone. La fonction de rappel n'a pas de paramètres, mais peut lever une exception.
48	fs.fsyncSync(fd) fsync synchrone.
49	fs.write(fd, buffer, offset, length[, position], callback) Écrire le contenu du tampon dans le fichier spécifié par le descripteur de fichier.
50	fs.write(fd, data[, position[, encoding]], callback) Écrire le contenu du fichier via le descripteur de fichier fd.
51	fs.writeSync(fd, buffer, offset, length[, position]) Version synchrone de fs.write().
52	fs.writeSync(fd, data[, position[, encoding]]) Version synchrone de fs.write().
53	fs.read(fd, buffer, offset, length, position, callback) Lire le contenu du fichier via le descripteur de fichier fd.
54	fs.readSync(fd, buffer, offset, length, position) Version synchrone de fs.read.
55	fs.readFile(filename[, options], callback) Lire le contenu d’un fichier de manière asynchrone.
56	fs.readFileSync(filename[, options])
57	fs.writeFile(filename, data[, options], callback) Écrit le contenu d'un fichier de manière asynchrone.
58	fs.writeFileSync(filename, data[, options]) Version synchrone de fs.writeFile.
59	fs.appendFile(filename, data[, options], callback) Ajoute de manière asynchrone au contenu d'un fichier.
60	fs.appendFileSync(filename, data[, options]) Version synchrone de fs.appendFile.
61	fs.watchFile(filename[, options], listener) Surveille les modifications de fichier.
62	fs.unwatchFile(filename[, listener]) Arrête de surveiller les modifications de filename.
63	fs.watch(filename[, options][, listener]) Surveille les modifications de filename, qui peut être un fichier ou un répertoire. Renvoie un objet fs.FSWatcher.
64	fs.exists(path, callback) Vérifie si le chemin donné existe.
65	fs.existsSync(path) Version synchrone de fs.exists.
66	fs.access(path[, mode], callback) Teste les permissions utilisateur pour le chemin spécifié.
67	fs.accessSync(path[, mode]) Version synchrone de fs.access.
68	fs.createReadStream(path[, options]) Renvoie un objet ReadStream.
69	fs.createWriteStream(path[, options]) Renvoie un objet WriteStream.
70	fs.symlink(srcpath, dstpath[, type], callback) symlink() asynchrone. La fonction de rappel n'a pas de paramètres, mais peut lever une exception.

Pour plus d'informations, veuillez consulter la description du module de fichiers du site officiel :Système de fichiers。

Autres extensions

Node.js Application

Système de fichiers de Node.js

Importer le module fs

Asynchrone et synchrone

Exemple

Exemple

Écrire dans le fichier

Ajouter du contenu à un fichier

Supprimer un fichier

Créer un répertoire

Lire le contenu du répertoire

Vérifier si un fichier ou un répertoire existe

Utilisation avancée

Ouvrir un fichier

Syntaxe

Parameters

Exemple

Obtenir les informations sur le fichier

Syntaxe

Parameters

Exemple

Écrire dans le fichier

Syntaxe

Parameters

Exemple

Lire le fichier

Syntaxe

Parameters

Exemple

Fermer le fichier

Syntaxe

Parameters

Exemple

Tronquer un fichier

Syntaxe

Parameters

Exemple

Supprimer un fichier

Syntaxe

Parameters

Exemple

Créer un répertoire

Syntaxe

Parameters

Exemple

Lire un répertoire

Syntaxe

Parameters

Exemple

Supprimer le répertoire

Syntaxe

Parameters

Exemple

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