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 détaillées sur ses fichiers et sous-répertoires.

🏆 Défi à relever

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

🚀 Application Résultante

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 de front, perfectionnant vos compétences sans assistance ;
• La seconde consiste à suivre un guide utile qui garantit votre réussite.

Quel que soit le chemin choisi, vous vivrez une expérience enrichissante menant à la création d’une application console captivante et fonctionnelle.

Plan Directeur

• 👉 Étape 1 : Importer les modules nécessaires ;
• 👉 É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 commencer cette exploration, 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 un chemin de 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 à l'aide de la fonction getStats ;
• Si les stats indiquent 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 du 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();

🎉 Conclusion : Compétences maîtrisées

Avec DirInspect Pro, maîtrise de l'analyse de répertoires de manière professionnelle. Cette application console démontre la capacité à extraire des statistiques sur les fichiers, à gérer les erreurs de façon transparente et à révéler des informations pertinentes sur les fichiers et sous-répertoires d'un répertoire spécifié.

👨‍💻 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();