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

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

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

Plan directeur

• Étape 1 : Importation des modules requis ;
• Étape 2 : Définition de la fonction getStats ;
• Étape 3 : Définition de la fonction analyzeFile ;
• Étape 4 : Définition de la fonction analyzeDirectory ;
• Étape 5 : Définition et appel de la fonction main ;
• Conclusion ;
• Code complet de l'application.

Étape 1 : Importation des modules requis

Pour commencer cette aventure, il vous faut les bons outils. Commencez par importer deux modules clés : 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 analyse un répertoire et collecte des statistiques complètes sur son contenu. Fonctionnement : elle lit tous les éléments du répertoire à l'aide de fs.readdir. Pour chaque élément :

• Construit le chemin complet avec path.join ;
• Utilise getStats pour détecter s'il s'agit d'un fichier ou d'un dossier ;
• Si c'est un fichier :
  • Appelle analyzeFile pour obtenir { name, size } ;
  • Met à jour les totaux, le plus gros fichier et la liste des fichiers.
• Si c'est un répertoire :
  • Appelle récursivement analyzeDirectory ;
  • Fusionne les résultats dans les statistiques courantes.

async function analyzeDirectory(directoryPath) {
  let totalItems = 0;
  let totalFiles = 0;
  let totalSize = 0;
  let largestFile = { name: "", size: 0 };
  let fileList = [];

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

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

      totalItems++;

      if (stats.isFile()) {
        const fileInfo = await analyzeFile(itemPath);
        if (!fileInfo) continue;

        totalFiles++;
        totalSize += fileInfo.size;

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

        fileList.push(fileInfo);
      } 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();

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) {
  let totalItems = 0;
  let totalFiles = 0;
  let totalSize = 0;
  let largestFile = { name: "", size: 0 };
  let fileList = [];

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

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

      totalItems++;

      if (stats.isFile()) {
        const fileInfo = await analyzeFile(itemPath);
        if (!fileInfo) continue;

        totalFiles++;
        totalSize += fileInfo.size;

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

        fileList.push(fileInfo);
      } 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();