Guide Node.js, partie 9: Utilisation du système de fichiers

Aujourd'hui, dans la neuvième partie de la traduction du didacticiel Node.js, nous parlerons de l'utilisation des fichiers. En particulier, nous parlerons des modules fs et path - des descripteurs de fichiers, des chemins de fichiers, de l'obtention d'informations sur les fichiers, de leur lecture et de leur écriture, de l'utilisation des répertoires.

Utilisation des descripteurs de fichiers dans Node.js

Avant de pouvoir interagir avec des fichiers situés dans le système de fichiers de votre serveur, vous devez obtenir un descripteur de fichier.

Le descripteur peut être obtenu en utilisant la méthode asynchrone open() du module fs pour ouvrir le fichier:

 const fs = require('fs') fs.open('/Users/flavio/test.txt', 'r', (err, fd) => { //fd -    }) 

Notez le deuxième paramètre, r , utilisé lors de l'appel de la méthode fs.open() . Il s'agit d'un indicateur qui indique au système que le fichier est en cours de lecture. Voici quelques autres indicateurs qui sont souvent utilisés lors de l'utilisation de cette méthode et d'autres méthodes:

• r+ - ouvre le fichier en lecture et en écriture.
• w+ - ouvrez le fichier pour la lecture et l'écriture en positionnant le pointeur de flux au début du fichier. Si le fichier n'existe pas, il est créé.
• a - ouvrez le fichier pour l'écriture en plaçant le pointeur de flux à la fin du fichier. Si le fichier n'existe pas, il est créé.
• a+ - ouvrez le fichier en lecture et en écriture en positionnant le pointeur de flux à la fin du fichier. Si le fichier n'existe pas, il est créé.

Les fichiers peuvent être ouverts à l'aide de la méthode synchrone fs.openSync() qui, au lieu de fournir un descripteur de fichier dans le rappel, le renvoie:

 const fs = require('fs') try { const fd = fs.openSync('/Users/flavio/test.txt', 'r') } catch (err) { console.error(err) } 

Après avoir reçu le descripteur à l'aide de l'une des méthodes ci-dessus, vous pouvez effectuer les opérations nécessaires avec lui.

Données de fichier

Chaque fichier est associé à un ensemble de données; vous pouvez examiner ces données à l'aide de Node.js. En particulier, cela peut être fait en utilisant la méthode stat() du module fs .

Cette méthode est appelée, en lui passant le chemin d'accès au fichier, et après que Node.js ait reçu les informations nécessaires sur le fichier, il appellera le rappel passé à la méthode stat() . Voici à quoi ça ressemble:

 const fs = require('fs') fs.stat('/Users/flavio/test.txt', (err, stats) => { if (err) {   console.error(err)   return } //      `stats` }) 

Node.js a la capacité de récupérer de manière synchrone les informations de fichier. Avec cette approche, le thread principal est bloqué jusqu'à ce que les propriétés du fichier soient obtenues:

 const fs = require('fs') try { const stats = fs.statSync ('/Users/flavio/test.txt') } catch (err) { console.error(err) } 

Les informations sur le fichier tomberont dans la constante des stats . Quelle est cette information? En fait, l'objet correspondant nous fournit un grand nombre de propriétés et de méthodes utiles:

• Les .isFile() et .isDirectory() permettent respectivement de savoir si le fichier étudié est un fichier ou un répertoire normal.
• La méthode .isSymbolicLink() vous permet de savoir si un fichier est un lien symbolique.
• La taille du fichier peut être trouvée à l'aide de la propriété .size .

Il existe d'autres méthodes ici, mais ce sont les plus utilisées. Voici comment les utiliser:

 const fs = require('fs') fs.stat('/Users/flavio/test.txt', (err, stats) => { if (err) {   console.error(err)   return } stats.isFile() //true stats.isDirectory() //false stats.isSymbolicLink() //false stats.size //1024000 //= 1MB }) 

Chemins de fichiers dans Node.js et le module de chemin

Le chemin d'accès au fichier est l'adresse de l'endroit dans le système de fichiers où il se trouve.

Sous Linux et macOS, le chemin pourrait ressembler à ceci:

 /users/flavio/file.txt 

Sous Windows, les chemins semblent un peu différents:

 C:\users\flavio\file.txt 

Il convient de noter les différences de formats d'enregistrement de chemin lors de l'utilisation de différents systèmes d'exploitation, compte tenu du système d'exploitation utilisé pour déployer le serveur Node.js.

Node.js dispose d'un module de path standard conçu pour fonctionner avec les chemins de fichiers. Avant d'utiliser ce module dans un programme, il doit être connecté:

 const path = require('path') 

▍ Obtention des informations sur le chemin du fichier

Si vous avez un chemin d'accès au fichier, puis en utilisant les capacités du module de path , vous pouvez, sous une forme pratique pour la perception et le traitement ultérieur, trouver des détails sur ce chemin d'accès. Cela ressemble à ceci:

 const notes = '/users/flavio/notes.txt' path.dirname(notes) // /users/flavio path.basename(notes) // notes.txt path.extname(notes) // .txt 

Ici, dans la ligne des notes , le chemin du fichier est stocké. Les méthodes suivantes du module de path ont été utilisées pour analyser le path :

• dirname() - retourne le répertoire parent du fichier.
• basename() - renvoie le nom du fichier.
• extname() - renvoie l'extension du fichier.

Vous pouvez trouver le nom du fichier sans l'extension en appelant la méthode .basename() et en lui passant le deuxième argument représentant l'extension:

 path.basename(notes, path.extname(notes)) //notes 

▍Travailler avec des chemins de fichiers

Plusieurs parties du chemin peuvent être combinées à l'aide de la méthode path.join() :

 const name = 'flavio' path.join('/', 'users', name, 'notes.txt') //'/users/flavio/notes.txt' 

Vous pouvez trouver le chemin absolu du fichier en fonction du chemin d'accès relatif à celui-ci à l'aide de la méthode path.resolve() :

 path.resolve('flavio.txt') //'/Users/flavio/flavio.txt'       

Dans ce cas, Node.js ajoute simplement /flavio.txt au chemin menant au répertoire de travail actuel. Si, lors de l'appel de cette méthode, vous passez un autre paramètre représentant le chemin d'accès au dossier, la méthode l'utilise comme base pour déterminer le chemin absolu:

 path.resolve('tmp', 'flavio.txt') // '/Users/flavio/tmp/flavio.txt'       

Si le chemin d'accès passé en tant que premier paramètre commence par une barre oblique, cela signifie qu'il s'agit d'un chemin absolu.

 path.resolve('/etc', 'flavio.txt') // '/etc/flavio.txt' 

Voici une autre méthode utile - path.normalize() . Il vous permet de trouver le vrai chemin d'accès au fichier en utilisant le chemin d'accès qui contient les qualificatifs de chemin d'accès relatifs comme un point ( . ), Deux points ( .. ) ou deux barres obliques:

 path.normalize('/users/flavio/..//test.txt') // /users/test.txt 

Les méthodes resolve() et normalize() ne vérifient pas l'existence d'un répertoire. Ils trouvent simplement le chemin en fonction des données qui leur sont transmises.

Lecture de fichiers dans Node.js

La façon la plus simple de lire des fichiers dans Node.js est d'utiliser la méthode fs.readFile() , en lui passant le chemin d'accès au fichier et le rappel, qui sera appelé avec le transfert des données du fichier (ou l'objet d'erreur):

 fs.readFile('/Users/flavio/test.txt', (err, data) => { if (err) {   console.error(err)   return } console.log(data) }) 

Si nécessaire, vous pouvez utiliser la version synchrone de cette méthode - fs.readFileSync() :

 const fs = require('fs') try { const data = fs.readFileSync('/Users/flavio/test.txt') console.log(data) } catch (err) { console.error(err) } 

Par défaut, le codage utf8 est utilisé lors de la lecture des fichiers, mais le codage peut également être défini indépendamment en passant le paramètre approprié à la méthode.

Les fs.readFile() et fs.readFileSync() lisent l'intégralité du contenu du fichier en mémoire. Cela signifie que travailler avec des fichiers volumineux à l'aide de ces méthodes affectera sérieusement la consommation de mémoire de votre application et affectera ses performances. Si vous devez travailler avec de tels fichiers, il est préférable d'utiliser des flux.

Écriture de fichiers dans Node.js

Dans Node.js, il est plus facile d'écrire des fichiers en utilisant la méthode fs.writeFile() :

 const fs = require('fs') const content = 'Some content!' fs.writeFile('/Users/flavio/test.txt', content, (err) => { if (err) {   console.error(err)   return } //   }) 

Il existe également une version synchrone de la même méthode - fs.writeFileSync() :

 const fs = require('fs') const content = 'Some content!' try { const data = fs.writeFileSync('/Users/flavio/test.txt', content) //   } catch (err) { console.error(err) } 

Ces méthodes, par défaut, remplacent le contenu des fichiers existants. Vous pouvez modifier leur comportement standard en utilisant l'indicateur approprié:

 fs.writeFile('/Users/flavio/test.txt', content, { flag: 'a+' }, (err) => {}) 

Les drapeaux peuvent être utilisés ici, que nous avons déjà énumérés dans la section sur les descripteurs. Des détails sur les drapeaux peuvent être trouvés ici .

Joindre des données à un fichier

La méthode fs.appendFile() (et sa version synchrone, fs.appendFileSync() ) est commodément utilisée pour attacher des données à la fin du fichier:

 const content = 'Some content!' fs.appendFile('file.log', content, (err) => { if (err) {   console.error(err)   return } //! }) 

À propos de l'utilisation des threads

Ci-dessus, nous avons décrit des méthodes qui, lors de l'écriture dans un fichier, écrivent la totalité des données qui y sont transférées, après quoi, si leurs versions synchrones sont utilisées, elles renvoient le contrôle au programme, et si des versions asynchrones sont utilisées, elles appellent des rappels. Si cet état de fait ne vous convient pas, il serait préférable d'utiliser des flux.

Utilisation de répertoires dans Node.js

Le module fs fournit au développeur de nombreuses méthodes pratiques qui peuvent être utilisées pour travailler avec des répertoires.

▍Vérifiez l'existence du dossier

Afin de vérifier si le répertoire existe et si Node.js peut y accéder, compte tenu des autorisations, vous pouvez utiliser la méthode fs.access() .

▍Créer un nouveau dossier

Pour créer de nouveaux dossiers, vous pouvez utiliser les fs.mkdir() et fs.mkdirSync() :

 const fs = require('fs') const folderName = '/Users/flavio/test' try { if (!fs.existsSync(dir)){   fs.mkdirSync(dir) } } catch (err) { console.error(err) } 

▍Lire le contenu du dossier

Pour lire le contenu d'un dossier, vous pouvez utiliser les fs.readdir() et fs.readdirSync() . Cet exemple lit le contenu du dossier, c'est-à-dire les informations sur les fichiers et les sous-répertoires qu'il contient et renvoie leurs chemins d'accès relatifs:

 const fs = require('fs') const path = require('path') const folderPath = '/Users/flavio' fs.readdirSync(folderPath) 

Voici comment obtenir le chemin d'accès complet au fichier:

 fs.readdirSync(folderPath).map(fileName => { return path.join(folderPath, fileName) } 

Les résultats peuvent être filtrés afin d'obtenir uniquement les fichiers et les exclure de la sortie du répertoire:

 const isFile = fileName => { return fs.lstatSync(fileName).isFile() } fs.readdirSync(folderPath).map(fileName => { return path.join(folderPath, fileName)).filter(isFile) } 

▍ Renommer le dossier

Vous pouvez utiliser les fs.rename() et fs.renameSync() pour renommer le dossier. Le premier paramètre est le chemin du dossier actuel, le second est un nouveau:

 const fs = require('fs') fs.rename('/Users/flavio', '/Users/roger', (err) => { if (err) {   console.error(err)   return } // }) 

Vous pouvez renommer le dossier à l'aide de la méthode synchrone fs.renameSync() :

 const fs = require('fs') try { fs.renameSync('/Users/flavio', '/Users/roger') } catch (err) { console.error(err) } 

▍ Supprimer le dossier

Pour supprimer un dossier, vous pouvez utiliser les fs.rmdir() ou fs.rmdirSync() . Il convient de noter que la suppression d'un dossier dans lequel se trouve quelque chose est une tâche un peu plus compliquée que la suppression d'un dossier vide. Si vous devez supprimer de tels dossiers, utilisez le package fs-extra , qui est très populaire et bien pris en charge. Il remplace le module fs , élargissant ses capacités.

La méthode remove() du package fs-extra peut supprimer des dossiers qui ont déjà quelque chose.

Vous pouvez installer ce module comme suit:

 npm install fs-extra 

Voici un exemple de son utilisation:

 const fs = require('fs-extra') const folder = '/Users/flavio' fs.remove(folder, err => { console.error(err) }) 

Ses méthodes peuvent être utilisées sous forme de promesses:

 fs.remove(folder).then(() => { // }).catch(err => { console.error(err) }) 

La construction async / wait est également acceptable:

 async function removeFolder(folder) { try {   await fs.remove(folder)   // } catch (err) {   console.error(err) } } const folder = '/Users/flavio' removeFolder(folder) 

Module Fs

Ci-dessus, nous avons déjà rencontré quelques méthodes du module fs qui sont utilisées lors de l'utilisation du système de fichiers. En fait, il contient beaucoup plus de choses utiles. Rappelons qu'il n'a pas besoin d'être installé, pour l'utiliser dans le programme, il suffit de le connecter:

 const fs = require('fs') 

Après cela, vous aurez accès à ses méthodes, parmi lesquelles on note les suivantes, dont certaines que vous connaissez déjà:

• fs.access() : vérifie l'existence d'un fichier et la possibilité d'y accéder en fonction des autorisations.
• fs.appendFile() : fs.appendFile() données à un fichier. Si le fichier n'existe pas, il sera créé.
• fs.chmod() : modifie les autorisations pour un fichier donné. Méthodes similaires: fs.lchmod() , fs.fchmod() .
• fs.chown() : change le propriétaire et le groupe pour le fichier donné. Méthodes similaires: fs.fchown() , fs.lchown() .
• fs.close() : ferme le descripteur de fichier.
• fs.copyFile() : copie le fichier.
• fs.createReadStream() : crée un flux pour lire un fichier.
• fs.createWriteStream() : crée un flux d'écriture de fichier.
• fs.link() : crée un nouveau lien dur vers le fichier.
• fs.mkdir() : crée un nouveau répertoire.
• fs.mkdtemp() : crée un répertoire temporaire.
• fs.open() : ouvre un fichier.
• fs.readdir() : lit le contenu d'un répertoire.
• fs.readFile() : lit le contenu d'un fichier. Méthode similaire: fs.read() .
• fs.readlink() : lit la valeur d'un lien symbolique.
• fs.realpath() : résout le chemin relatif du fichier construit à l'aide de caractères . et .. , sur le chemin complet.
• fs.rename() : renomme un fichier ou un dossier.
• fs.rmdir() : supprime le dossier.
• fs.stat() : retourne les informations du fichier. Méthodes similaires: fs.fstat() , fs.lstat() .
• fs.symlink() : crée un nouveau lien symbolique vers le fichier.
• fs.truncate() : tronque le fichier à la longueur spécifiée. Méthode similaire: fs.ftruncate() .
• fs.unlink() : supprime un fichier ou un lien symbolique.
• fs.unwatchFile() : désactive la surveillance des modifications de fichiers.
• fs.utimes() : modifie l'horodatage d'un fichier. Méthode similaire: fs.futimes() .
• fs.watchFile() : permet de surveiller les modifications des fichiers. Méthode similaire: fs.watch() .
• fs.writeFile() : écrit des données dans un fichier. Méthode similaire: fs.write() .

Une caractéristique intéressante du module fs est le fait que toutes ses méthodes, par défaut, sont asynchrones, mais il existe également des versions synchrones d'entre elles, dont les noms sont obtenus en ajoutant le mot Sync aux noms des méthodes asynchrones.

Par exemple:

• fs.rename()
• fs.renameSync()
• fs.write()
• fs.writeSync()

L'utilisation de méthodes synchrones affecte sérieusement le fonctionnement du programme.

Node.js 10 fournit un support expérimental pour ces API basées sur des promesses.

Explorez la méthode fs.rename() . Voici une version asynchrone de cette méthode utilisant des rappels:

 const fs = require('fs') fs.rename('before.json', 'after.json', (err) => { if (err) {   return console.error(err) } // }) 

Lors de l'utilisation de sa version synchrone, la construction try/catch est utilisée pour gérer les erreurs:

 const fs = require('fs') try { fs.renameSync('before.json', 'after.json') // } catch (err) { console.error(err) } 

La principale différence entre ces options d'utilisation de cette méthode est que dans le second cas, le script sera bloqué jusqu'à la fin de l'opération de fichier.

Module de chemin

Le module de chemin, dont nous avons également parlé de certaines de ses fonctionnalités, contient de nombreux outils utiles qui vous permettent d'interagir avec le système de fichiers. Comme déjà mentionné, vous n'avez pas besoin de l'installer, car il fait partie de Node.js. Pour l'utiliser, il suffit de le connecter:

 const path = require('path') 

La propriété path.sep de ce module fournit le caractère utilisé pour séparer les segments de chemin ( \ sous Windows et / sous Linux et macOS), et la propriété path.delimiter donne le caractère utilisé pour séparer plusieurs chemins ( ; sous Windows et : sous Linux et macOS).

Considérons et illustrons quelques méthodes du module de path .

▍path.basename ()

Renvoie le dernier fragment du chemin. En passant le deuxième paramètre à cette méthode, vous pouvez supprimer l'extension de fichier.

 require('path').basename('/test/something') //something require('path').basename('/test/something.txt') //something.txt require('path').basename('/test/something.txt', '.txt') //something 

▍path.dirname ()

Renvoie la partie du chemin qui représente le nom du répertoire:

 require('path').dirname('/test/something') // /test require('path').dirname('/test/something/file.txt') // /test/something 

▍path.extname ()

Renvoie la partie du chemin qui représente l'extension du fichier:

 require('path').extname('/test/something') // '' require('path').extname('/test/something/file.txt') // '.txt' 

▍path.isAbsolute ()

Renvoie vrai si le chemin est absolu:

 require('path').isAbsolute('/test/something') // true require('path').isAbsolute('./test/something') // false 

▍path.join ()

Connecte plusieurs parties du chemin:

 const name = 'flavio' require('path').join('/', 'users', name, 'notes.txt') //'/users/flavio/notes.txt' 

▍path.normalize ()

Essayer de comprendre le vrai chemin en fonction du chemin qui contient les caractères utilisés pour construire des chemins relatifs comme . , .. et // :

 require('path').normalize('/users/flavio/..//test.txt') ///users/test.txt 

▍path.parse ()

Convertit un chemin d'accès en un objet dont les propriétés représentent des parties individuelles du chemin d'accès:

• root : le répertoire racine.
• dir : chemin du fichier à partir du répertoire racine
• base : nom et extension du fichier.
• name : name fichier.
• ext : extension de fichier.

Voici un exemple utilisant cette méthode:

 require('path').parse('/users/test.txt') 

À la suite de son travail, l'objet suivant est obtenu:

 { root: '/', dir: '/users', base: 'test.txt', ext: '.txt', name: 'test' } 

▍path.relative ()

Prend, comme arguments, 2 façons. Renvoie le chemin relatif du premier chemin au second, en fonction du répertoire de travail actuel:

 require('path').relative('/Users/flavio', '/Users/flavio/test.txt') //'test.txt' require('path').relative('/Users/flavio', '/Users/flavio/something/test.txt') //'something/test.txt' 

▍path.resolve ()

Recherche le chemin absolu en fonction du chemin relatif qui lui a été transmis:

 path.resolve('flavio.txt') //'/Users/flavio/flavio.txt'      . 

Résumé

Aujourd'hui, nous avons examiné les modules fs et path Node.js qui sont utilisés pour travailler avec le système de fichiers. Dans la prochaine partie de cette série, sur laquelle elle se termine, nous discuterons du système d'exploitation, des events , des modules http , parlerons de l'utilisation des flux et des systèmes de gestion de base de données dans Node.js.

Chers lecteurs! Quels packages npm utilisez-vous lorsque vous travaillez avec le système de fichiers dans Node.js?