Créer un backend en Javascript (partie 3) : Manipulation de fichiers et dossiers avec NodeJS
Tags: javascript, node, express, beginners
Published: 2021-10-04 09:44:48

---
title: Créer un backend en Javascript (partie 3) : Manipulation de fichiers et dossiers avec NodeJS
description: 
published: true
tags: javascript, nodejs, express, beginner
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/f1qn7uw1ymkntxsgx3tu.png
series: node101
---

Voici une série d'articles qui vous permettra créer des applications backend en Javascript.

Node.js est aujourd'hui un incontournable, il est donc essentiel pour un développeur de le maitriser.

Je vais donc publier un nouvel article environ au deux jours et petit à petit vous apprendrez tout ce qu'il y a à savoir sur Node.js

Pour ne rien manquer suivez moi sur twitter : https://twitter.com/EricLeCodeur
<hr>

## Modules inclut avec NodeJS
NodeJS est livré avec plusieurs modules avec des fonctions qui vous permettent d'exécuter facilement les tâches les plus courantes.

Vous verrez plus tard qu'il est également possible d'ajouter d'autres modules créé par la communauté et d'étendre les fonctionnalités de votre application de façon presque illimité.

Ici je vais vous présenter seulement quelques exemples de modules NodeJS. Vous pouvez consulter la documentation de NodeJS pour le détails complets des modules et de leurs fonctionnements. [https://nodejs.org/en/docs/](https://nodejs.org/en/docs/)

## Le module Path
Le module 'path' contient des fonctions qui permettent de traiter adéquatement les emplacements de dossier et fichiers

Pour référencer un module, il suffit d'utiliser son nom

```jsx
const path = require('path')

products_path = '/data/products/products.json'
products_file = path.basename(products_path)

console.log(products_file) // products.json
```

La fonction path.basename() permet de retourner le nom du fichier seulement donc dans ce cas-ci 'products.json'

Une autre fonction pratique est path.join(). Cette fonction permet de joindre ensemble un ou plusieurs dossier et fichier. exemple :

```jsx
const path = require('path')

data_folder = '/data/'
products_folder  = '/products'
products_file = 'products.json'

const full_path = path.join(data_folder, products_folder, products_file)

console.log(full_path) // /data/products/products.json
```
path.join() concatène tous les segments de chemin donnés en utilisant le séparateur spécifique à la plate-forme comme délimiteur, puis normalise le chemin résultant

Enfin, parfois vous aimeriez avoir la path absolue sur le serveur

```jsx
const path = require('path')

data_folder = '/data/'
products_folder  = '/products'
products_file = 'products.json'

const full_path = path.join(data_folder, products_folder, products_file)

const abs_path = path.resolve(__dirname, 'data', 'products', 'products.json')

console.log(abs_path)
// /Users/username/Documents/dev/learn_node/data/products/products.json
```
path.resolve() traite la séquence de chemins de droite à gauche, chaque chemin suivant étant ajouté jusqu'à ce qu'un chemin absolu soit construit.

## Le module File System
Sans doute un des module les plus utilisé, ce module permet de manipuler les fichiers et dossiers sur le serveur

Le module FS permet la manipulation des fichiers et dossiers de deux façon différentes. Vous pouvez le faire en mode synchrone ou asynchrone.

### Fonctions **synchrones**

Cela signifie que cette fonction est bloquante, NodeJS attendra le retour de la fonction  avant de continuer l'exécution de l'application.

### Fonctions **asynchrones**

Cela signifie que NodeJS n'attendra pas que la fonction retourne une valeur, il va continuer l'exécution de votre application et quand la fonction sera terminé, il traitera le résultat.

### Quelle méthode utiliser ?

Ça dépend du type d'application que vous désirez développer. Si par exemple vous développer un serveur web et bien dans ce cas il est préférable, pour ne pas dire essentiel, d'utiliser une fonction asynchrone. Une fonction synchrone bloquerait l'exécution du serveur non seulement pour l'usager en cours mais également bloquerait tous les autres usager. 

Par contre dans certain cas très précis l'utilisation d'une fonction synchrone peut être justifié. Par exemple, avant de lancer un serveur web, si vous devez lire un fichier contenant la configuration de ce serveur, dans ce cas, une fonction synchrone vous garantie la lecture du fichier avant le lancement du serveur.

Bref, de façon général, utilisé toujours une fonction asynchrone et seulement au besoin, une fonction synchrone.

### Voyons un exemple d'utilisation du module 'fs' avec les deux types de fonctions :

Fonction synchrone

```jsx
// app.js

const fs = require('fs')

const data = fs.readFileSync('info.txt', 'utf-8')
console.log(data) // file content
console.log('Le fichier a été lu')
```

Ici c'est simple, le code s'exécutera ligne par ligne. 

Fonction asynchrone

```jsx
const fs = require('fs')

const info = fs.readFile('info.txt', 'utf-8', (err, data) => {
    console.log(data)
})
console.log('Le fichier a été lu')
```

Ici la fonction readFile sers lancé en mode asynchrone, donc NodeJS n'attendra pas le retour de la fonction pour continuer l'exécution. 

Ce qui aura comme conséquence d'afficher 'le fichier à été lu' en premier et seulement lorsque la fonction readFile aura terminé sont travail, NodeJS exécutera la fonction callback soit console.log(data)

### Lecture et création d'un fichier

Á noter que pour le suite de ce tutoriel nous allons utiliser seulement les fonctions asynchrones. 

D'abord nous allons créer un fichier text. Pour ce faire nous allons utiliser la fonction writeFile

```jsx
const fs = require('fs')

const data = 'This is my Hello World file'

fs.writeFile('info.txt', data, 'utf-8', (err) => {
    console.log('File created')
})
```

La fonction writeFile() est assez auto-descriptive. Vous devez spécifier le nom du fichier, les données et l'option d'encodage. (utf-8 pour le texte)

Si vous exécuté ce code, le fichier info.txt sera créer dans le dossier en cours.

Ensuite il sera possible de lire ce fichier avec la fonction readFile

```jsx
const fs = require('fs')

const info = fs.readFile('info.txt', 'utf-8', (err, data) => {
    console.log(data)
})
```

Si le fichier n'existe pas vous pouvez retourner une erreur

```jsx
const info = fs.readFile('info.txt', 'utf-8', (err, data) => {
    if (err) 
        console.log(err)
    else
        console.log(data)
})
```

Il est également possible de lire un fichier avec readFile mais en utilisant les promesses.

```jsx
const fs = require('fs').promises

const start = async () => {
    const data = await fs.readFile('info.txt', 'utf8')
    console.log(data)
}

start()
```

Différente syntaxe, même résultat

### Copier un fichier

Pour copier un fichier nous utilisons la fonction copyFile

```jsx
fs.copyFile('info.txt', 'info2.txt', (err) => {
      if (err) return console.error(err)
	    console.log('File copied')
})
```

### Créer un dossier

Pour créer un dossier nous utilisons la fonction mkdir

```jsx
fs.mkdir('data', (err) => {
    console.log('Data folder created')
})
```

Le dossier est créer à l'intérieur du dossier en cours

### Lecture des fichiers d'un dossier

Il est possible d'obtenir la liste des fichiers d'un dossier

```jsx
fs.readdir('.', (err, files) => {
    console.log(files)
})
```

'.' représente le dossier en cours

### Renommer un fichier

Pour renommer un fichier nous utilisons la fonction rename

```jsx
fs.rename('info.txt', 'data.txt', (err) => {
    if (err) return console.log(err)
    console.log('File renamed')
})
```

### Les possibilité sont presque infini !

Vous avez maintenant une base avec le module 'fs' si vous désirez connaitre toutes les fonctions disponible, consulter le site de NodeJS pour tous les détails:

[https://nodejs.org/api/fs.html](https://nodejs.org/api/fs.html)


## Conclusion
C'est tout pour aujourd'hui, suivez moi sur twitter : https://twitter.com/EricLeCodeur afin d'être avisé de la parution du prochain article (d'ici deux jours).