Ce chapitre vous propose un défi : créer une application console avancée nommée DirInspect Pro. Cette application vous permettra d’analyser en profondeur n’importe quel répertoire et d’obtenir des statistiques pertinentes sur ses fichiers et sous-répertoires.

Défi

Imaginez un scénario où vous devez naviguer dans un labyrinthe de dossiers contenant des fichiers et des données essentiels. DirInspect Pro est votre allié dans cette exploration, fournissant une analyse complète de la structure et du contenu du répertoire.

Application obtenue

Préparez-vous à exploiter les fonctionnalités de DirInspect Pro. L’application vous fournira des informations essentielles, telles que :

• Le nombre total d’éléments ;
• La taille totale de tous les éléments ;
• Le nom et la taille du plus grand fichier ;
• La liste détaillée des noms et tailles de chaque fichier.

Deux chemins à choisir

Deux options s’offrent à vous.

• La première consiste à relever ce défi par vous-même, perfectionnant ainsi vos compétences sans assistance ;
• La seconde consiste à suivre un guide utile qui garantit votre réussite.

Quel que soit le chemin choisi, cette expérience aboutira à la création d’une application console captivante et fonctionnelle.

Plan directeur

• Étape 1 : Importer les modules requis ;
• Étape 2 : Définir la fonction getStats ;
• Étape 3 : Définir la fonction analyzeFile ;
• Étape 4 : Définir la fonction analyzeDirectory ;
• Étape 5 : Définir et invoquer la fonction main ;
• Conclusion ;
• Code complet de l’application.

Étape 1 : Importer les modules requis

Pour débuter cette aventure, il est nécessaire de disposer des bons outils. Commencez par importer deux modules essentiels : fs.promises pour gérer le système de fichiers de manière asynchrone et path pour manipuler efficacement les chemins de fichiers.

const fs = require("fs").promises;
const path = require("path");

Étape 2 : Définir la fonction getStats

La fonction asynchrone getStats prend en argument le chemin d’un fichier ou d’un répertoire et tente d’en récupérer les statistiques à l’aide de fs.stat.

• En cas de succès, elle retourne les statistiques ;
• En cas d’erreur, elle affiche un message d’erreur et retourne null.

async function getStats(filePath) {
  try {
    const stats = await fs.stat(filePath);
    return stats;
  } catch (err) {
    console.error("Error getting stats:", err.message);
    return null;
  }
}

Étape 3 : Définir la fonction analyzeFile

La fonction analyzeFile utilise la fonction getStats pour obtenir les statistiques d’un fichier. Si les statistiques sont disponibles (différentes de null), elle retourne un objet contenant le nom du fichier (extrait avec path.basename) et sa taille.

async function analyzeFile(filePath) {
  const stats = await getStats(filePath);
  if (!stats) return null;

  return {
    name: path.basename(filePath),
    size: stats.size,
  };
}

Étape 4 : Définir la fonction analyzeDirectory

La fonction analyzeDirectory prend en argument le chemin d’un répertoire et analyse de manière exhaustive son contenu.

• Elle commence par lire les éléments du répertoire à l’aide de fs.readdir, puis parcourt chaque élément ;
• Pour chaque élément, elle construit le chemin complet avec path.join et récupère ses statistiques via la fonction getStats ;
• Si stats indique que l’élément est un fichier, elle met à jour les statistiques relatives aux fichiers ;
• Si l’élément est un sous-répertoire, elle appelle récursivement la fonction analyzeDirectory pour analyser son contenu, puis agrège les statistiques.

async function analyzeDirectory(directoryPath) {
  try {
    const items = await fs.readdir(directoryPath);
    let totalItems = 0;
    let totalFiles = 0;
    let totalSize = 0;
    let largestFile = { name: "", size: 0 };
    let fileList = [];

    for (const item of items) {
      const itemPath = path.join(directoryPath, item);
      const stats = await getStats(itemPath);
      if (!stats) continue;

      totalItems++;

      if (stats.isFile()) {
        totalFiles++;
        totalSize += stats.size;

        if (stats.size > largestFile.size) {
          largestFile = { name: item, size: stats.size };
        }

        fileList.push({ name: item, size: stats.size });
      } else if (stats.isDirectory()) {
        const subDirectoryStats = await analyzeDirectory(itemPath);
        totalItems += subDirectoryStats.totalItems;
        totalFiles += subDirectoryStats.totalFiles;
        totalSize += subDirectoryStats.totalSize;

        if (subDirectoryStats.largestFile.size > largestFile.size) {
          largestFile = subDirectoryStats.largestFile;
        }

        fileList = fileList.concat(subDirectoryStats.fileList);
      }
    }

    return {
      totalItems,
      totalFiles,
      totalSize,
      largestFile,
      fileList,
    };
  } catch (err) {
    console.error("Error analyzing directory contents:", err.message);
    return {
      totalItems: 0,
      totalFiles: 0,
      totalSize: 0,
      largestFile: { name: "", size: 0 },
      fileList: [],
    };
  }
}

Étape 5 : Définir la fonction main et l'invoquer

La fonction main constitue le point d'entrée du script. Elle spécifie le chemin du répertoire à analyser (dans ce cas, ./docs), appelle la fonction analyzeDirectory pour obtenir les statistiques du répertoire et de son contenu, puis affiche les informations collectées. La fonction affiche :

• Le nombre total d'éléments ;
• Le nombre total de fichiers ;
• La taille totale ;
• Les détails concernant le plus grand fichier ;
• La liste des fichiers dans le répertoire.

async function main() {
  const directoryPath = "./docs";
  const directoryStats = await analyzeDirectory(directoryPath);

  console.log("Directory Analysis:");
  console.log("Total items:", directoryStats.totalItems);
  console.log("Total files:", directoryStats.totalFiles);
  console.log("Total size (bytes):", directoryStats.totalSize);
  console.log(
    "Largest file:",
    directoryStats.largestFile.name,
    "Size:",
    directoryStats.largestFile.size,
    "bytes"
  );

  console.log("\nFile List:");
  for (const file of directoryStats.fileList) {
    console.log(file.name, "Size:", file.size, "bytes");
  }
}

main();

Code complet de l'application

const fs = require("fs").promises;
const path = require("path");

async function getStats(filePath) {
  try {
    const stats = await fs.stat(filePath);
    return stats;
  } catch (err) {
    console.error("Error getting stats:", err.message);
    return null;
  }
}

async function analyzeFile(filePath) {
  const stats = await getStats(filePath);
  if (!stats) return null;

  return {
    name: path.basename(filePath),
    size: stats.size,
  };
}

async function analyzeDirectory(directoryPath) {
  try {
    const items = await fs.readdir(directoryPath);

    let totalItems = 0;
    let totalFiles = 0;
    let totalSize = 0;
    let largestFile = { name: "", size: 0 };
    let fileList = [];

    for (const item of items) {
      const itemPath = path.join(directoryPath, item);
      const stats = await getStats(itemPath);
      if (!stats) continue;

      totalItems++;

      if (stats.isFile()) {
        totalFiles++;
        totalSize += stats.size;

        if (stats.size > largestFile.size) {
          largestFile = { name: item, size: stats.size };
        }

        fileList.push({ name: item, size: stats.size });
      } else if (stats.isDirectory()) {
        const subDirectoryStats = await analyzeDirectory(itemPath);
        totalItems += subDirectoryStats.totalItems;
        totalFiles += subDirectoryStats.totalFiles;
        totalSize += subDirectoryStats.totalSize;

        if (subDirectoryStats.largestFile.size > largestFile.size) {
          largestFile = subDirectoryStats.largestFile;
        }

        fileList = fileList.concat(subDirectoryStats.fileList);
      }
    }

    return {
      totalItems,
      totalFiles,
      totalSize,
      largestFile,
      fileList,
    };
  } catch (err) {
    console.error("Error analyzing directory contents:", err.message);
    return {
      totalItems: 0,
      totalFiles: 0,
      totalSize: 0,
      largestFile: { name: "", size: 0 },
      fileList: [],
    };
  }
}

async function main() {
  const directoryPath = "./docs";

  const directoryStats = await analyzeDirectory(directoryPath);

  console.log("Directory Analysis:");
  console.log("Total items:", directoryStats.totalItems);
  console.log("Total files:", directoryStats.totalFiles);
  console.log("Total size (bytes):", directoryStats.totalSize);
  console.log(
    "Largest file:",
    directoryStats.largestFile.name,
    "Size:",
    directoryStats.largestFile.size,
    "bytes"
  );

  console.log("\nFile List:");
  for (const file of directoryStats.fileList) {
    console.log(file.name, "Size:", file.size, "bytes");
  }
}

main();