In diesem Kapitel erwartet Sie eine Herausforderung: die Entwicklung einer fortgeschrittenen Konsolenanwendung namens DirInspect Pro. Diese Anwendung ermöglicht es Ihnen, jedes Verzeichnis umfassend zu analysieren und aufschlussreiche Statistiken über dessen Dateien und Unterverzeichnisse zu erhalten.

🏆 Herausforderung erwartet Sie

Stellen Sie sich ein Szenario vor, in dem Sie ein Labyrinth aus Ordnern mit wichtigen Dateien und Daten durchqueren müssen. DirInspect Pro ist Ihr Verbündeter auf dieser Reise und liefert umfassende Einblicke in die Struktur und den Inhalt des Verzeichnisses.

🚀 Die Ergebnisanwendung

Nutzen Sie die Möglichkeiten von DirInspect Pro. Die Anwendung liefert Ihnen wichtige Informationen, wie zum Beispiel

• Die Gesamtanzahl der Elemente;
• Die Gesamtspeichergröße aller Elemente;
• Den Namen und die Größe der größten Datei;
• Die detaillierte Liste einzelner Dateinamen und -größen.

Zwei Wege zur Auswahl

Es stehen zwei Wege offen.

• Der erste besteht darin, diese Herausforderung eigenständig anzugehen und Ihre Fähigkeiten ohne Anleitung zu schärfen;
• Der zweite ist, einer hilfreichen Anleitung zu folgen, die Ihren Erfolg garantiert.

Unabhängig davon, welchen Weg Sie wählen, erwartet Sie eine lohnende Reise, die in der Erstellung einer ansprechenden und funktionalen Konsolenanwendung gipfelt.

Masterplan

• 👉 Schritt 1: Erforderliche Module importieren;
• 👉 Schritt 2: Funktion getStats definieren;
• 👉 Schritt 3: Funktion analyzeFile definieren;
• 👉 Schritt 4: Funktion analyzeDirectory definieren;
• 👉 Schritt 5: Hauptfunktion definieren und aufrufen;
• 🎉 Fazit;
• 🏁 Vollständiger Anwendungscode.

Schritt 1: Erforderliche Module importieren

Für den Einstieg in dieses Vorhaben werden die passenden Werkzeuge benötigt. Beginnen Sie mit dem Import von zwei zentralen Modulen: fs.promises zur asynchronen Verwaltung des Dateisystems und path zur effektiven Handhabung von Dateipfaden.

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

Schritt 2: Funktion getStats definieren

Die asynchrone Funktion getStats nimmt einen Datei- oder Verzeichnispfad als Argument und versucht, dessen Statistiken mit fs.stat abzurufen.

• Bei Erfolg werden die Statistiken zurückgegeben;
• Im Fehlerfall wird eine Fehlermeldung protokolliert und null zurückgegeben.

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

Schritt 3: Funktion analyzeFile definieren

Die Funktion analyzeFile verwendet die Funktion getStats, um Statistiken für eine Datei zu erhalten. Sind Statistiken verfügbar (nicht null), wird ein Objekt mit dem Namen der Datei (ermittelt mit path.basename) und deren Größe zurückgegeben.

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

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

Schritt 4: Funktion analyzeDirectory definieren

Die Funktion analyzeDirectory nimmt einen Verzeichnispfad als Argument und analysiert dessen Inhalt umfassend.

• Sie beginnt damit, die Elemente im Verzeichnis mit fs.readdir auszulesen und iteriert anschließend durch jedes Element;
• Für jedes Element wird der vollständige Pfad mit path.join erstellt und die Statistiken mit der Funktion getStats abgerufen;
• Wenn die stats anzeigen, dass es sich um eine Datei handelt, werden die dateibezogenen Statistiken aktualisiert;
• Handelt es sich um ein Unterverzeichnis, wird die Funktion analyzeDirectory rekursiv aufgerufen, um dessen Inhalt zu analysieren, und die Statistiken werden aggregiert.

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

Schritt 5: main-Funktion definieren und aufrufen

Die Funktion main ist der Einstiegspunkt des Skripts. Sie gibt den zu analysierenden Verzeichnispfad an (in diesem Fall ./docs), ruft die Funktion analyzeDirectory auf, um die Statistiken des Verzeichnisses und seines Inhalts zu erhalten, und gibt anschließend die gesammelten Informationen aus. Die Funktion gibt aus:

• Die Gesamtanzahl der Elemente;
• Die Gesamtanzahl der Dateien;
• Die Gesamtgröße;
• Die Details zur größten Datei;
• Die Liste der Dateien im Verzeichnis.

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

🎉 Fazit: Erlernte Fähigkeiten

Mit DirInspect Pro hast du die Kunst der Verzeichnisanalyse wie ein Profi gemeistert. Diese Konsolenanwendung demonstriert deine Fähigkeit, Dateistatistiken zu extrahieren, Fehler nahtlos zu behandeln und aussagekräftige Einblicke über Dateien und Unterverzeichnisse innerhalb eines angegebenen Verzeichnisses zu gewinnen.

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