Dit hoofdstuk presenteert een uitdaging: het ontwikkelen van een geavanceerde console-app genaamd DirInspect Pro. Met deze app kun je elke directory grondig analyseren en waardevolle statistieken verkrijgen over de bestanden en submappen.

🏆 Uitdaging in het vooruitzicht

Stel je een situatie 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 Keuzes

Er liggen twee paden voor je open.

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

Welke weg je ook kiest, je staat een waardevolle reis te wachten die eindigt met het maken 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: Functie main definiëren en aanroepen;
• 🎉 Conclusie;
• 🏁 Volledige app-code.

Stap 1: Vereiste modules importeren

Voor deze taak zijn de juiste hulpmiddelen 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 fs.stat.

• Bij succes worden de statistieken geretourneerd;
• Bij een fout wordt een foutmelding gelogd en null geretourneerd.

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 van een bestand op te halen. Als de statistieken beschikbaar zijn (niet null), retourneert deze 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 analyzeDirectory-functie

De functie analyzeDirectory neemt een pad naar een directory als argument en analyseert de inhoud ervan grondig.

• Begint met het lezen van de items in de directory met behulp van fs.readdir en doorloopt vervolgens elk item;
• Voor elk item wordt het volledige pad geconstrueerd met path.join en worden de statistieken opgehaald via de functie getStats;
• Als de stats aangeven dat het item een bestand is, worden de bestand-gerelateerde statistieken bijgewerkt;
• Als het item een subdirectory 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 main-functie en roep deze aan

De functie main is het startpunt van het script. Deze specificeert het pad van de te analyseren directory (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 toont:

• Het totaal aantal items;
• Het totaal aantal bestanden;
• De totale grootte;
• De details van 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();

🎉 Conclusie: Beheersde Vaardigheden

Met DirInspect Pro zijn de vaardigheden voor het analyseren van directories als een professional beheerst. Deze console-app toont het vermogen om bestandsstatistieken te extraheren, fouten moeiteloos af te handelen en waardevolle inzichten te verkrijgen over bestanden en subdirectories binnen een opgegeven directory.

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