Dit hoofdstuk presenteert een uitdaging: het creëren van een geavanceerde console-app genaamd DirInspect Pro. Deze app stelt je in staat om elke directory grondig te analyseren en waardevolle statistieken te verkrijgen over de bestanden en submappen.

Uitdaging

Stel je een scenario voor waarin je door een doolhof van mappen met cruciale bestanden en data moet navigeren. DirInspect Pro is je bondgenoot tijdens deze reis en biedt uitgebreide inzichten in de structuur en inhoud van de directory.

De Resulterende App

Maak je klaar om de mogelijkheden van DirInspect Pro te benutten. De app voorziet je van essentiële informatie, zoals

• Het totale aantal items;
• De totale grootte van alle items;
• De naam en grootte van het grootste bestand;
• De gedetailleerde lijst van individuele bestandsnamen en groottes.

Twee paden om te kiezen

Er liggen twee paden voor je.

• Het eerste pad is om deze uitdaging direct aan te gaan en je vaardigheden zonder begeleiding te verfijnen;
• Het tweede pad is om een behulpzame gids te volgen die succes garandeert.

Welk pad je ook kiest, je staat een waardevolle reis te wachten die eindigt met het creëren van een boeiende en functionele console-app.

Masterplan

• Stap 1: Vereiste modules importeren;
• Stap 2: Functie getStats definiëren;
• Stap 3: Functie analyzeFile definiëren;
• Stap 4: Functie analyzeDirectory definiëren;
• Stap 5: Hoofdfunctie definiëren en aanroepen;
• Conclusie;
• Volledige app-code.

Stap 1: Vereiste modules importeren

Om aan dit avontuur te beginnen, heb je de juiste tools nodig. Begin met het importeren van twee belangrijke modules: fs.promises voor het asynchroon beheren van het bestandssysteem en path voor het effectief verwerken van bestands­paden.

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

Stap 2: Definieer de functie getStats

De asynchrone functie, getStats, neemt een bestand- of map-pad als argument en probeert de statistieken ervan op te halen met behulp van fs.stat.

• Indien succesvol, retourneert het de statistieken;
• Bij een fout wordt een foutmelding gelogd en retourneert de functie 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;
  }
}

Stap 3: Definieer de functie analyzeFile

De functie analyzeFile gebruikt de functie getStats om statistieken voor een bestand op te halen. Als de statistieken beschikbaar zijn (niet null), retourneert het een object met de bestandsnaam (verkregen via path.basename) en de bestandsgrootte.

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

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

Stap 4: Definieer de functie analyzeDirectory

De functie analyzeDirectory neemt een map-pad als argument en analyseert de inhoud ervan uitgebreid.

• Het begint met het lezen van de items in de map met fs.readdir en doorloopt vervolgens elk item;
• Voor elk item wordt het volledige pad opgebouwd met path.join en worden de statistieken opgehaald met de functie getStats;
• Als de stats aangeven dat het item een bestand is, worden de bestand-gerelateerde statistieken bijgewerkt;
• Als het item een submap is, wordt de functie analyzeDirectory recursief aangeroepen om de inhoud ervan te analyseren en worden de statistieken samengevoegd.

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: [],
    };
  }
}

Stap 5: Definieer de hoofd Functie en Roep deze aan

De main functie is het startpunt van het script. Deze specificeert het te analyseren directorypad (in dit geval, ./docs), roept de functie analyzeDirectory aan om de statistieken van de directory en de inhoud ervan te verkrijgen, en geeft vervolgens de verzamelde informatie weer. De functie drukt het volgende af:

• Het totaal aantal items;
• Het totaal aantal bestanden;
• De totale grootte;
• De details over het grootste bestand;
• De lijst van bestanden in de directory.

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();

Volledige App Code

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();