{"id":59501,"date":"2022-07-12T08:20:15","date_gmt":"2022-07-12T07:20:15","guid":{"rendered":"https:\/\/kinsta.com\/fr\/?p=59501&post_type=knowledgebase&preview_id=59501"},"modified":"2025-10-01T20:45:51","modified_gmt":"2025-10-01T19:45:51","slug":"nodejs-fs","status":"publish","type":"post","link":"https:\/\/kinsta.com\/fr\/blog\/nodejs-fs\/","title":{"rendered":"Comprendre le module de syst\u00e8me de fichiers (FS) de Node.js"},"content":{"rendered":"

JavaScript est depuis longtemps l’un des langages de script les plus populaires, mais pendant une longue p\u00e9riode, il n’\u00e9tait pas un excellent choix pour le d\u00e9veloppement d’applications backend c\u00f4t\u00e9 serveur. Puis est apparu Node.js, qui permet de cr\u00e9er des applications l\u00e9g\u00e8res c\u00f4t\u00e9 serveur, pilot\u00e9es par les \u00e9v\u00e9nements et construites \u00e0 l’aide du langage de programmation JavaScript.<\/p>\n

Node.js est un moteur d’ex\u00e9cution JavaScript \u00e0 code source ouvert<\/a> qui peut \u00eatre t\u00e9l\u00e9charg\u00e9 et install\u00e9 gratuitement sur tous les principaux syst\u00e8mes d’exploitation (Windows, Mac, Linux). Il est devenu de plus en plus populaire aupr\u00e8s des cr\u00e9ateurs d’applications<\/a> ces derni\u00e8res ann\u00e9es, et il a fourni de nombreuses nouvelles opportunit\u00e9s d’emploi<\/a> pour les d\u00e9veloppeurs JavaScript \u00e0 la recherche d’une sp\u00e9cialit\u00e9.<\/p>\n\n

Dans cet article, nous allons apprendre \u00e0 g\u00e9rer le syst\u00e8me de fichiers \u00e0 l’aide de Node.js. Il est facile d’utiliser les API de Node.js pour interagir avec le syst\u00e8me de fichiers et effectuer de nombreuses op\u00e9rations complexes, et savoir comment les man\u0153uvrer stimulera votre productivit\u00e9.<\/p>\n

Plongeons !<\/p>\n

<\/div><\/kinsta-auto-toc>\n

Pr\u00e9-requis pour la compr\u00e9hension du syst\u00e8me de fichiers de Node.js<\/h2>\n

Le premier pr\u00e9-requis est l’installation de Node.js sur votre syst\u00e8me d’exploitation. Node.js ne n\u00e9cessite aucun mat\u00e9riel complexe pour fonctionner, ce qui rend facile le t\u00e9l\u00e9chargement et l’installation de Node.js<\/a> sur votre ordinateur.<\/p>\n

Il serait utile que vous ayez \u00e9galement une connaissance de base de JavaScript<\/a> pour travailler sur des modules Node.js comme les syst\u00e8mes de fichiers (\u00e9galement connus sous le nom de \u00ab File System ou FS \u00bb). Une compr\u00e9hension de haut niveau des fonctions JavaScript, des fonctions de rappel et des promesses vous aidera \u00e0 ma\u00eetriser ce sujet<\/a> encore plus rapidement.<\/p>\n

Module de syst\u00e8me de fichiers de Node.js<\/h2>\n

Travailler avec des fichiers et des r\u00e9pertoires est l’un des besoins fondamentaux d’une application full-stack. Vos utilisateurs peuvent vouloir t\u00e9l\u00e9verser des images, des CV ou d’autres fichiers vers un serveur. En m\u00eame temps, votre application peut avoir besoin de lire des fichiers de configuration, de d\u00e9placer des fichiers, ou m\u00eame de changer leurs permissions de mani\u00e8re programmatique.<\/p>\n

Le module de syst\u00e8me de fichiers de Node.js a tout pr\u00e9vu. Il fournit plusieurs API pour interagir avec les syst\u00e8mes de fichiers de mani\u00e8re transparente. La plupart des API sont personnalisables avec des options et des drapeaux. Vous pouvez \u00e9galement les utiliser pour effectuer des op\u00e9rations de fichiers synchrones et asynchrones.<\/p>\n

Avant de nous plonger dans le module de syst\u00e8me de fichiers, jetons un coup d’\u0153il \u00e0 ce qu’est le module Node.js.<\/p>\n

Modules Node.js<\/h3>\n

Les modules Node.js sont un ensemble de fonctionnalit\u00e9s disponibles sous forme d’API qu’un programme consommateur peut utiliser. Par exemple, vous avez le module fs<\/code> pour interagir avec le syst\u00e8me de fichiers. De m\u00eame, un module http<\/code> utilise ses fonctions pour cr\u00e9er un serveur et bien d’autres op\u00e9rations. Node.js offre de nombreux modules pour abstraire de nombreuses fonctionnalit\u00e9s de bas niveau pour vous.<\/p>\n

Vous pouvez \u00e9galement cr\u00e9er vos propres modules. \u00c0 partir de la version 14 de Node.js, vous pouvez cr\u00e9er et utiliser des modules Node.js de deux mani\u00e8res : Les modules CommonJS (CJS) et ESM (MJS). Tous les exemples que nous verrons dans cet article sont dans le style CJS.<\/p>\n

Travailler avec des fichiers dans Node.js<\/h2>\n

Travailler avec des fichiers implique diverses op\u00e9rations avec des fichiers et des r\u00e9pertoires (dossiers). Nous allons maintenant apprendre chacune de ces op\u00e9rations \u00e0 l’aide d’un exemple de code source. Veuillez ouvrir votre \u00e9diteur de code source<\/a> pr\u00e9f\u00e9r\u00e9 et essayez-les au fur et \u00e0 mesure de votre lecture.<\/p>\n

Tout d’abord, importez le module fs<\/code> dans votre fichier source pour commencer \u00e0 travailler avec les m\u00e9thodes du syst\u00e8me de fichiers. Dans le style CJS, nous utilisons la m\u00e9thode require<\/code> pour importer une m\u00e9thode d’un module. Ainsi, pour importer et utiliser les m\u00e9thodes du module fs, vous devez proc\u00e9der comme ceci :<\/p>\n

const { writeFile } = require('fs\/promises');<\/code><\/pre>\n
Notez \u00e9galement que nous importons la m\u00e9thode writeFile<\/code> du module fs\/promises<\/code>. Nous voulons utiliser les m\u00e9thodes promises car elles sont les plus r\u00e9centes, et elles sont faciles \u00e0 utiliser avec les mots-cl\u00e9s async\/await et moins de code. Les autres alternatives sont les m\u00e9thodes synchrones et les fonctions de rappel que nous verrons plus tard.<\/p>\n
Comment cr\u00e9er et \u00e9crire dans un fichier<\/h3>\n
Vous pouvez cr\u00e9er et \u00e9crire dans un fichier de trois fa\u00e7ons :<\/p>\n
    \n
  1. Utilisation de la m\u00e9thode writeFile<\/code><\/li>\n
  2. Utilisation de la m\u00e9thode appendFile<\/code><\/li>\n
  3. Utilisation de la m\u00e9thode openFile<\/code><\/li>\n<\/ol>\n
    Ces m\u00e9thodes acceptent un chemin de fichier et les donn\u00e9es comme contenu \u00e0 \u00e9crire dans le fichier. Si le fichier existe, elles remplacent le contenu dans le fichier. Sinon, elles cr\u00e9ent un nouveau fichier avec le contenu.<\/p>\n
    1. Utilisation de la m\u00e9thode writeFile<\/h4>\n
    L’extrait de code ci-dessous montre l’utilisation de la m\u00e9thode writeFile<\/code>. Commencez par cr\u00e9er un fichier appel\u00e9 createFile.js<\/strong> \u00e0 l’aide de l’extrait de code ci-dessous :<\/p>\n
    const { writeFile } = require('fs\/promises');\nasync function writeToFile(fileName, data) {\n  try {\n    await writeFile(fileName, data);\n    console.log(`Wrote data to ${fileName}`);\n  } catch (error) {\n    console.error(`Got an error trying to write the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Notez que nous utilisons le mot-cl\u00e9 await<\/code> pour invoquer la m\u00e9thode car elle renvoie une promesse JavaScript. Une promesse r\u00e9ussie cr\u00e9era\/\u00e9crira dans le fichier. Nous avons un bloc try-catch pour g\u00e9rer les erreurs en cas de rejet de la promesse.<\/p>\n
    Nous pouvons maintenant invoquer la fonction writeToFile<\/code>:<\/p>\n
    writeToFile('friends.txt', 'Bob');<\/code><\/pre>\n
    Ensuite, ouvrez une invite de commande ou un terminal et ex\u00e9cutez le programme ci-dessus en utilisant la commande suivante :<\/p>\n
    node createFile.js<\/code><\/pre>\n
    Cela cr\u00e9era un nouveau fichier appel\u00e9 friends.txt<\/strong> avec une ligne qui dit simplement :<\/p>\n
    Bob<\/code><\/pre>\n
    2. Utilisation de la m\u00e9thode appendFile<\/h4>\n
    Comme son nom l’indique, l’utilisation principale de cette m\u00e9thode est d’ajouter et de modifier un fichier. Toutefois, vous pouvez \u00e9galement utiliser la m\u00eame m\u00e9thode pour cr\u00e9er un fichier.<\/p>\n
    Jetez un coup d’\u0153il \u00e0 la fonction ci-dessous. Nous utilisons la m\u00e9thode appendFile<\/code> avec l’indicateur w<\/code> pour \u00e9crire un fichier. L’indicateur par d\u00e9faut pour l’ajout \u00e0 un fichier est a<\/code>:<\/p>\n
    const { appendFile} = require('fs\/promises');\n\nasync function appendToFile(fileName, data) {\n  try {\n    await appendFile(fileName, data, { flag: 'w' });\n    console.log(`Appended data to ${fileName}`);\n  } catch (error) {\n    console.error(`Got an error trying to append the file: {error.message}`);\n  }\n}<\/code><\/pre>\n
    Maintenant, vous pouvez invoquer la fonction ci-dessus comme ceci :<\/p>\n
    appendToFile('activities.txt', 'Skiing');<\/code><\/pre>\n
    Ensuite, vous pouvez ex\u00e9cuter le code dans l’environnement Node.js en utilisant la commande node, comme nous l’avons vu pr\u00e9c\u00e9demment. Cela cr\u00e9era un fichier appel\u00e9 activities.txt<\/strong> avec le contenu Skiing<\/code> dedans.<\/p>\n
    3. Utilisation de la m\u00e9thode open<\/h4>\n
    La derni\u00e8re m\u00e9thode que nous allons apprendre pour cr\u00e9er et \u00e9crire dans un fichier est la m\u00e9thode open<\/code>. Vous pouvez ouvrir un fichier en utilisant l’indicateur w<\/code> (pour \u00ab write \u00bb) :<\/p>\n
    const { open} = require('fs\/promises');\n\nasync function openFile(fileName, data) {\n  try {\n    const file = await open(fileName, 'w');\n    await file.write(data);\n    console.log(`Opened file ${fileName}`);\n  } catch (error) {\n    console.error(`Got an error trying to open the file: {error.message}`);\n  }\n}<\/code><\/pre>\n
    Appelez maintenant la fonction openFile<\/code> avec :<\/p>\n
    openFile('tasks.txt', 'Do homework');<\/code><\/pre>\n
    Lorsque vous ex\u00e9cutez le script \u00e0 l’aide de la commande node, vous aurez un fichier nomm\u00e9 tasks.txt<\/strong> cr\u00e9\u00e9 avec le contenu initial :<\/p>\n
    Do homework<\/code><\/pre>\n
    Comment lire un fichier<\/h3>\n
    Maintenant que nous savons comment cr\u00e9er et \u00e9crire dans un fichier, apprenons \u00e0 lire le contenu d’un fichier. Pour ce faire, nous utiliserons la m\u00e9thode readFile<\/code> du module de syst\u00e8me de fichiers.<\/p>\n
    Cr\u00e9ez un fichier appel\u00e9 readThisFile.js<\/strong> avec le code suivant :<\/p>\n
    \/\/ readThisFile.js\nconst { readFile } = require('fs\/promises');\nasync function readThisFile(filePath) {\n  try {\n    const data = await readFile(filePath);\n    console.log(data.toString());\n  } catch (error) {\n    console.error(`Got an error trying to read the file: {error.message}`);\n }\n}<\/code><\/pre>\n
    Lisons maintenant les trois fichiers que nous avons cr\u00e9\u00e9s en invoquant la fonction readThisFile<\/code>:<\/p>\n
    readThisFile('activities.txt');\nreadThisFile('friends.txt');\nreadThisFile('tasks.txt');<\/code><\/pre>\n
    Enfin, ex\u00e9cutez le script \u00e0 l’aide de la commande node suivante :<\/p>\n
    node readThisFile.js<\/code><\/pre>\n
    Vous devriez voir la sortie suivante dans la console :<\/p>\n
    Skiing\nDo homework\nBob<\/code><\/pre>\n
    Un point \u00e0 noter ici : La m\u00e9thode readFile<\/code> lit le fichier de mani\u00e8re asynchrone. Cela signifie que l’ordre dans lequel vous lisez le fichier et l’ordre dans lequel vous obtenez une r\u00e9ponse \u00e0 afficher dans la console peuvent ne pas \u00eatre les m\u00eames. Vous devez utiliser la version synchrone de la m\u00e9thode readFile<\/code> pour obtenir l’ordre. Nous verrons cela ici dans un petit moment.<\/p>\n
    Comment renommer un fichier<\/h3>\n
    Pour renommer un fichier, utilisez la m\u00e9thode rename du module fs. Cr\u00e9ons un fichier appel\u00e9 rename-me.txt<\/strong>. Nous renommerons ce fichier de mani\u00e8re programmatique.<\/p>\n
    Cr\u00e9ez un fichier appel\u00e9 renameFile.js<\/strong> avec le code suivant :<\/p>\n
    const { rename } = require('fs\/promises');\n\nasync function renameFile(from, to) {\n  try {\n    await rename(from, to);\n    console.log(`Renamed ${from} to ${to}`);\n  } catch (error) {\n    console.error(`Got an error trying to rename the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Comme vous l’avez peut-\u00eatre remarqu\u00e9, la m\u00e9thode rename prend deux arguments. L’un est le fichier avec le nom source, et l’autre est le nom cible.<\/p>\n
    Invoquons maintenant la fonction ci-dessus pour renommer le fichier :<\/p>\n
    const oldName = \"rename-me.txt\";\nconst newName = \"renamed.txt\";\nrenameFile(oldName, newName);<\/code><\/pre>\n
    Comme pr\u00e9c\u00e9demment, ex\u00e9cutez le fichier script en utilisant la commande node pour renommer le fichier :<\/p>\n
    node renameFile.js<\/code><\/pre>\n
    Comment d\u00e9placer un fichier<\/h3>\n
    D\u00e9placer un fichier d’un r\u00e9pertoire \u00e0 un autre est similaire au fait de renommer son chemin. Nous pouvons donc utiliser la m\u00e9thode rename<\/code> elle-m\u00eame pour d\u00e9placer des fichiers.<\/p>\n
    Cr\u00e9ons deux dossiers, from<\/strong> et to<\/strong>. Puis nous cr\u00e9erons un fichier appel\u00e9 move-me.txt <\/strong>\u00e0 l’int\u00e9rieur du dossier from<\/strong>.<\/p>\n
    Ensuite, nous allons \u00e9crire le code pour d\u00e9placer le fichier move-me.txt<\/strong>. Cr\u00e9ez un fichier appel\u00e9 moveFile.js<\/strong> avec l’extrait de code suivant :<\/p>\n
    const { rename } = require('fs\/promises');\nconst { join } = require('path');\nasync function moveFile(from, to) {\n  try {\n    await rename(from, to);\n    console.log(`Moved ${from} to ${to}`);\n  } catch (error) {\n    console.error(`Got an error trying to move the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Comme vous pouvez le voir, nous utilisons la m\u00e9thode rename<\/code> comme auparavant. Mais pourquoi devons-nous importer la m\u00e9thode join<\/code> du module path<\/code> (oui, le chemin est un autre module crucial de Node.js) ?<\/p>\n
    La m\u00e9thode join<\/code> est utilis\u00e9e pour joindre plusieurs segments de chemin sp\u00e9cifi\u00e9s pour former un chemin. Nous allons l’utiliser pour former le chemin des noms de fichiers source et destination :<\/p>\n
    const fromPath = join(__dirname, \"from\", \"move-me.txt\");\nconst destPath = join(__dirname, \"to\", \"move-me.txt\");\nmoveFile(fromPath, destPath);<\/code><\/pre>\n
    Et c’est tout ! Si vous ex\u00e9cutez le script moveFile.js<\/strong>, vous verrez le fichier move-me.txt<\/strong> d\u00e9plac\u00e9 vers le dossier to<\/strong>.<\/p>\n
    Comment copier un fichier<\/h3>\n
    Nous utilisons la m\u00e9thode copyFile<\/code> du module fs<\/code> pour copier un fichier de la source vers la destination.<\/p>\n
    Jetez un coup d’\u0153il \u00e0 l’extrait de code ci-dessous :<\/p>\n
    const { copyFile } = require('fs\/promises');\nconst { join } = require('path');\nasync function copyAFile(from, to) {\n  try {\n    await copyFile(from, to);\n    console.log(`Copied ${from} to ${to}`);\n  } catch (err) {\n    console.error(`Got an error trying to copy the file: ${err.message}`);\n  }\n}<\/code><\/pre>\n
    Vous pouvez maintenant invoquer la fonction ci-dessus avec :<\/p>\n
    copyAFile('friends.txt', 'friends-copy.txt');<\/code><\/pre>\n
    Elle copiera le contenu du fichier friends.txt<\/strong> dans le fichier friends-copy.txt<\/strong>.<\/p>\n
    Maintenant, c’est g\u00e9nial, mais comment copier plusieurs fichiers ?<\/p>\n
    Vous pouvez utiliser l’API Promise.all<\/code> pour ex\u00e9cuter plusieurs promesses en parall\u00e8le :<\/p>\n
    async function copyAll(fromDir, toDir, filePaths) {\n  return Promise.all(filePaths.map(filePath => {\n   return copyAFile(join(fromDir, filePath), join(toDir, filePath));\n  }));\n}<\/code><\/pre>\n
    Vous pouvez maintenant fournir tous les chemins de fichiers \u00e0 copier d’un r\u00e9pertoire \u00e0 un autre :<\/p>\n
    copyFiles('from', 'to', ['copyA.txt', 'copyB.txt']);<\/code><\/pre>\n
    Vous pouvez \u00e9galement utiliser cette approche pour effectuer d’autres op\u00e9rations comme le d\u00e9placement, l’\u00e9criture et la lecture de fichiers en parall\u00e8le.<\/p>\n
    Comment supprimer un fichier<\/h3>\n
    Nous utilisons la m\u00e9thode unlink<\/code> pour supprimer un fichier :<\/p>\n
    const { unlink } = require('fs\/promises');\nasync function deleteFile(filePath) {\n  try {\n    await unlink(filePath);\n    console.log(`Deleted ${filePath}`);\n  } catch (error) {\n    console.error(`Got an error trying to delete the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    N’oubliez pas que vous devez fournir le chemin d’acc\u00e8s au fichier pour le supprimer :<\/p>\n
    deleteFile('delete-me.txt');<\/code><\/pre>\n
    Notez que si le chemin d’acc\u00e8s est un lien symbolique vers un autre fichier, la m\u00e9thode unlink annulera le lien symbolique, mais le fichier original ne sera pas touch\u00e9. Nous parlerons davantage des liens symboliques plus tard.<\/p>\n
    Comment modifier les permissions et la propri\u00e9t\u00e9 des fichiers<\/h3>\n
    Il se peut que vous souhaitiez \u00e0 un moment donn\u00e9 modifier les autorisations de fichiers de mani\u00e8re programmatique. Cela peut s’av\u00e9rer tr\u00e8s utile pour rendre un fichier en lecture seule ou enti\u00e8rement accessible.<\/p>\n
    Nous allons utiliser la m\u00e9thode chmod<\/code> pour modifier l’autorisation d’un fichier :<\/p>\n
    const { chmod } = require('fs\/promises');\nasync function changePermission(filePath, permission) {\n  try {\n    await chmod(filePath, permission);\n    console.log(`Changed permission to ${permission} for ${filePath}`);\n  } catch (error) {\n    console.error(`Got an error trying to change permission: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Nous pouvons passer le chemin du fichier et le bitmask de permission pour changer la permission.<\/p>\n
    Voici l’appel de fonction pour changer la permission d’un fichier en lecture seule :<\/p>\n
    changePermission('permission.txt', 0o400);<\/code><\/pre>\n
    De fa\u00e7on similaire \u00e0 la permission, vous pouvez \u00e9galement changer la propri\u00e9t\u00e9 d’un fichier de fa\u00e7on programmatique. Nous utilisons la m\u00e9thode chown<\/code> pour ce faire :<\/p>\n
    const { chown } = require('fs\/promises');\n\nasync function changeOwnership(filePath, userId, groupId) {\n  try {\n    await chown(filePath, userId, groupId);\n    console.log(`Changed ownership to ${userId}:${groupId} for ${filePath}`);\n  } catch (error) {\n    console.error(`Got an error trying to change ownership: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Nous appelons ensuite la fonction avec le chemin du fichier, l’ID de l’utilisateur et l’ID du groupe :<\/p>\n
    changeOwnership('ownership.txt', 1000, 1010);<\/code><\/pre>\n
    Comment cr\u00e9er un lien symbolique<\/h3>\n
    Le lien symbolique (\u00e9galement appel\u00e9 symlink)<\/a> est un concept du syst\u00e8me de fichiers permettant de cr\u00e9er un lien vers un fichier ou un dossier. Nous cr\u00e9ons des liens symboliques pour cr\u00e9er des raccourcis vers un fichier\/dossier cible dans le syst\u00e8me de fichiers. Le module Node.js filesystem<\/code> fournit la m\u00e9thode symlink<\/code> pour cr\u00e9er un lien symbolique.<\/p>\n
    Pour cr\u00e9er le lien symbolique, nous devons passer le chemin du fichier cible, le chemin du fichier r\u00e9el et le type :<\/p>\n
    const { symlink } = require('fs\/promises');\nconst { join } = require('path');\nasync function createSymlink(target, path, type) {\n  try {\n    await symlink(target, path, type);\n    console.log(`Created symlink to ${target} at ${path}`);\n  } catch (error) {\n    console.error(`Got an error trying to create the symlink: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Nous pouvons invoquer la fonction avec :<\/p>\n
    createSymlink('join(__dirname, from, symMe.txt)', 'symToFile', 'file');<\/code><\/pre>\n
    Ici, nous avons cr\u00e9\u00e9 un lien symbolique appel\u00e9 symToFile<\/code>.<\/p>\n
    Comment observer les modifications d’un fichier<\/h3>\n
    Saviez-vous que vous pouvez observer les modifications apport\u00e9es \u00e0 un fichier ? C’est un excellent moyen de surveiller les alt\u00e9rations et les \u00e9v\u00e9nements, surtout lorsque vous ne vous y attendez pas. Vous pouvez les capturer et les auditer pour les examiner ult\u00e9rieurement.<\/p>\n
    La m\u00e9thode watch<\/code> est la meilleure fa\u00e7on de surveiller les modifications de fichiers. Il existe une autre m\u00e9thode appel\u00e9e watchFile<\/code>, mais elle n’est pas aussi performante que la m\u00e9thode watch<\/code>.<\/p>\n
    Jusqu’\u00e0 pr\u00e9sent, nous avons utilis\u00e9 la m\u00e9thode du module de syst\u00e8me de fichiers avec les mots-cl\u00e9s async\/await. Voyons les utilisations de la fonction callback avec cet exemple.<\/p>\n
    La m\u00e9thode watch<\/code> accepte le chemin du fichier et une fonction de rappel comme arguments. Chaque fois qu’une activit\u00e9 a lieu sur le fichier, la fonction callback<\/code> est appel\u00e9e.<\/p>\n
    Nous pouvons tirer parti du param\u00e8tre event<\/code> pour obtenir plus d’informations sur les activit\u00e9s :<\/p>\n
    const fs = require('fs');\nfunction watchAFile(file) {\n  fs.watch(file, (event, filename) => {\n    console.log(`${filename} file Changed`);\n  });\n}<\/code><\/pre>\n
    Appelez la fonction en passant un nom de fichier \u00e0 watch<\/code>:<\/p>\n
    watchAFile('friends.txt');<\/code><\/pre>\n
    Maintenant, nous capturons automatiquement toute activit\u00e9 sur le fichier friends.txt<\/strong>.<\/p>\n
    Travailler avec des r\u00e9pertoires (dossiers) dans Node.js<\/h2>\n
    Passons maintenant \u00e0 l’apprentissage de la mani\u00e8re d’effectuer des op\u00e9rations sur des r\u00e9pertoires ou des dossiers. La plupart des op\u00e9rations telles que renommer, d\u00e9placer et copier sont similaires \u00e0 ce que nous avons vu pour les fichiers. Cependant, certaines m\u00e9thodes et op\u00e9rations sp\u00e9cifiques ne sont utilisables que sur les r\u00e9pertoires.<\/p>\n
    Comment cr\u00e9er un r\u00e9pertoire<\/h3>\n
    Nous utilisons la m\u00e9thode mkdir<\/code> pour cr\u00e9er un r\u00e9pertoire. Vous devez passer le nom du r\u00e9pertoire comme argument :<\/p>\n
    const { mkdir } = require('fs\/promises');\nasync function createDirectory(path) {\n  try {\n    await mkdir(path);\n    console.log(`Created directory ${path}`);\n  } catch (error) {\n    console.error(`Got an error trying to create the directory: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Maintenant, nous pouvons invoquer la fonction createDirectory<\/code> avec un chemin de r\u00e9pertoire :<\/p>\n
    createDirectory('new-directory');<\/code><\/pre>\n
    Cela cr\u00e9era un r\u00e9pertoire nomm\u00e9 new-directory<\/strong>.<\/p>\n
    Comment cr\u00e9er un r\u00e9pertoire temporaire<\/h3>\n
    Les r\u00e9pertoires temporaires ne sont pas des r\u00e9pertoires ordinaires. Ils ont une signification particuli\u00e8re pour le syst\u00e8me d’exploitation. Vous pouvez cr\u00e9er un r\u00e9pertoire temporaire \u00e0 l’aide de la m\u00e9thode mkdtemp()<\/code>.<\/p>\n
    Cr\u00e9ons un dossier temporaire dans le r\u00e9pertoire temporaire de votre syst\u00e8me d’exploitation. Nous obtenons les informations relatives \u00e0 l’emplacement du r\u00e9pertoire temporaire \u00e0 partir de la m\u00e9thode tmpdir()<\/code> du module os<\/code>:<\/p>\n
    const { mkdtemp } = require('fs\/promises');\nconst { join } = require('path');\nconst { tmpdir } = require('os');\nasync function createTemporaryDirectory(fileName) {\n  try {\n    const tempDirectory = await mkdtemp(join(tmpdir(), fileName));\n    console.log(`Created temporary directory ${tempDirectory}`);\n  } catch (error) {\n    console.error(`Got an error trying to create the temporary directory: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Maintenant, appelons la fonction avec le nom du r\u00e9pertoire pour le cr\u00e9er :<\/p>\n
    createTemporaryDirectory('node-temp-file-');<\/code><\/pre>\n
    Notez que Node.js ajoutera six caract\u00e8res al\u00e9atoires \u00e0 la fin du nom du r\u00e9pertoire temporaire cr\u00e9\u00e9 pour le garder unique.<\/p>\n
    Comment supprimer un r\u00e9pertoire<\/h3>\n
    Vous devez utiliser la m\u00e9thode rmdir()<\/code> pour supprimer\/effacer un r\u00e9pertoire :<\/p>\n
    const { rmdir } = require('fs\/promises');\nasync function deleteDirectory(path) {\n  try {\n    await rmdir(path);\n    console.log(`Deleted directory ${path}`);\n  } catch (error) {\n    console.error(`Got an error trying to delete the directory: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Ensuite, appelez la fonction ci-dessus en passant le chemin du dossier que vous voulez supprimer :<\/p>\n
    deleteDirectory('new-directory-renamed');<\/code><\/pre>\n
    API synchrones vs asynchrones<\/h2>\n
    Jusqu’\u00e0 pr\u00e9sent, nous avons vu de nombreux exemples de m\u00e9thodes de syst\u00e8me de fichiers, et tous sont avec des utilisations asynchrones. Cependant, vous pouvez avoir besoin de traiter certaines op\u00e9rations de mani\u00e8re synchrone.<\/p>\n
    Un exemple d’op\u00e9ration synchrone est la lecture de plusieurs fichiers l’un apr\u00e8s l’autre. Le module fs<\/code> poss\u00e8de une m\u00e9thode appel\u00e9e readFileSync()<\/code> pour y parvenir :<\/p>\n
    const { readFileSync } = require('fs');\nfunction readFileSynchronously(path) {\n  try {\n    const data = readFileSync(path);\n    console.log(data.toString());\n  } catch (error) {\n    console.error(error);\n  }\n}<\/code><\/pre>\n
    Notez que la m\u00e9thode readFileSync()<\/code> n’est pas requise du paquet \u00ab fs\/promesses \u00bb. Ceci est d\u00fb au fait que la m\u00e9thode n’est pas asynchrone. Ainsi, vous pouvez appeler la fonction ci-dessus avec :<\/p>\n
    readFileSynchronously('activities.txt');\nreadFileSynchronously('friends.txt');\nreadFileSynchronously('tasks.txt');<\/code><\/pre>\n
    Dans ce cas, tous les fichiers ci-dessus seront lus dans l’ordre o\u00f9 les fonctions ont \u00e9t\u00e9 appel\u00e9es.<\/p>\n
    Le module de syst\u00e8me de fichiers Node.js offre une m\u00e9thode synchrone pour d’autres op\u00e9rations comme l’op\u00e9ration de lecture. Utilisez-les \u00e0 bon escient et uniquement en cas de besoin. Les m\u00e9thodes asynchrones sont bien plus utiles pour l’ex\u00e9cution parall\u00e8le.<\/p>\n
    Gestion des erreurs<\/h2>\n
    Comme tout codeur le sait, vous devez vous attendre \u00e0 des erreurs et \u00eatre pr\u00eat \u00e0 les g\u00e9rer<\/a> lorsque vous effectuez une op\u00e9ration sur un fichier ou un r\u00e9pertoire. Que se passe-t-il si le fichier n’est pas trouv\u00e9, ou si vous n’avez pas la permission d’\u00e9crire dans un fichier ? Il peut y avoir (et il y aura probablement) de nombreux cas o\u00f9 vous pourriez rencontrer une erreur.<\/p>\n
    Vous devriez toujours entourer vos appels de m\u00e9thode d’un bloc try-catch. De cette fa\u00e7on, si une erreur se produit, le contr\u00f4le passera au bloc catch, o\u00f9 vous pourrez examiner et traiter l’erreur. Comme vous l’avez peut-\u00eatre remarqu\u00e9 dans tous les exemples ci-dessus, nous avons utilis\u00e9 le bloc try-catch pour traiter les erreurs que nous avons rencontr\u00e9es.<\/p>\n\n
    R\u00e9sum\u00e9<\/h2>\n
    Passons en revue les points cl\u00e9s que nous avons abord\u00e9s dans ce tutoriel :<\/p>\n