Points forts du concept :

1. Node.js Globals
2. Modules Node.js
3. Le module chemin
4. L'objet processus
5. Gestion des entrées et des sorties
6. Gestion de fichiers et flux

1. Node.js Globals

Node.js est livré avec plusieurs objets et fonctions globaux disponibles n'importe où dans une application sans avoir besoin de les require(). Certains des objets globaux clés incluent :

• __dirname : Le nom du répertoire du module actuel.
• __filename : Le chemin complet du fichier actuel.
• setTimeout(), clearTimeout(), setInterval(), clearInterval() : Fonctions de gestion du timing asynchrone.

par exemple)

console.log(__dirname); // outputs the current directory
console.log(__filename); // outputs the full path of the current file 

2. Modules Node.js

Node.js suit une structure modulaire, où le code est divisé en modules plus petits et réutilisables. Vous pouvez charger des modules intégrés ou personnalisés à l'aide de la fonction require().

par exemple) Il existe trois types de modules dans Node.js :

1. Modules de base : fournis par Node.js comme fs, http et path.
2. Modules tiers : installés via npm tel que express ou lodash.
3. Modules personnalisés : créés par vous pour organiser votre code.

const fs = require('fs'); // Require the built-in file system module

3. Le module chemin

Le module path de Node.js fournit des utilitaires pour travailler avec les chemins de fichiers et de répertoires. C'est particulièrement utile pour rendre votre code indépendant de la plate-forme, car les séparateurs de chemin (\ sous Windows) peuvent varier selon les systèmes d'exploitation.

e.g.) Méthodes clés dans le module path :

• path.join() joint plusieurs segments de chemin en un seul.
• path.basename() renvoie la dernière partie d'un chemin (généralement le nom du fichier).
• paht.extname() renvoie l'extension du fichier.

const path = require('path');

const filePath = path.join(__dirname, 'folder', 'file.txt');
console.log(filePath); // Combines the paths to create a full file path

4. L'objet du processus

L'objet de processus dans Node.js fournit des informations et un contrôle sur le processus Node.js actuel. Il s'agit d'un objet global qui vous permet d'accéder à Internet avec l'environnement d'exécution.

par exemple) Certaines propriétés et méthodes de traitement utiles incluent :

• process.argv :  arguments transmis au processus Node.js.
• process.env : variables d'environnement.
• process.exit() : termine le processus.

console.log(process.argv); // Returns an array of command-line arguments
console.log(process.env); // Accesses environment variables

5. Gestion des entrées et des sorties

Node.js fournit des moyens simples de gérer les entrées et les sorties, notamment via son objet de processus permettant de travailler avec les entrées et sorties standard.

e.g.) Cet exemple écoute les entrées de l'utilisateur et les enregistre sur la console. Pour une gestion plus avancée des E/S, vous pouvez également utiliser des flux, qui vous permettent de traiter les données pièce par pièce au lieu de charger l'intégralité des E/S en mémoire d'un coup.

process.stdin.on('data', (data) => {
  console.log(`You typed: ${data}`);
});

6. Gestion des fichiers et flux

La gestion des fichiers est un élément essentiel de nombreuses applications Node.js, et le module fs (système de fichiers) de Node fournit une gamme de méthodes pour travailler avec le système de fichiers. Vous pouvez lire, écrire et gérer des fichiers à l'aide des API asynchrones ou synchrones.

par exemple)

const fs = require('fs');

// Asynchronous file reading
fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

// Writing to a file
fs.writeFile('output.txt', 'This is some content', (err) => {
  if (err) throw err;
  console.log('File written successfully');
});

Node.js dispose également d'un système puissant pour travailler avec des flux, qui sont utilisés pour gérer efficacement de grandes quantités de données. Les flux sont souvent utilisés pour lire/écrire des fichiers ou gérer la communication réseau.

const fs = require('fs');

const readStream = fs.createReadStream('example.txt');
const writeStream = fs.createWriteStream('output.txt');

readStream.pipe(writeStream); // Piping data from one file to another