In diesem Kapitel erwartet Sie eine Herausforderung: die Entwicklung einer fortgeschrittenen Konsolenanwendung namens DirInspect Pro. Mit dieser App können Sie jedes Verzeichnis umfassend analysieren und aufschlussreiche Statistiken über dessen Dateien und Unterverzeichnisse erhalten.

Herausforderung

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 Begleiter auf dieser Reise und liefert umfassende Einblicke in die Struktur und den Inhalt des Verzeichnisses.

Die resultierende Anwendung

Bereiten Sie sich darauf vor, die Funktionen von DirInspect Pro zu nutzen. Die App stellt Ihnen wichtige Informationen bereit, wie zum Beispiel

• Die Gesamtanzahl der Elemente;
• Die Gesamtspeichergröße aller Elemente;
• Der Name und die Größe der größten Datei;
• Die detaillierte Liste der einzelnen Dateinamen und -größen.

Zwei Wege zur Auswahl

Es stehen zwei Wege offen.

• Der erste besteht darin, diese Herausforderung direkt anzugehen und die eigenen Fähigkeiten ohne Anleitung zu schärfen;
• Der zweite ist, einer hilfreichen Anleitung zu folgen, die den 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 App-Code.

Schritt 1: Erforderliche Module importieren

Für dieses Vorhaben werden die passenden Werkzeuge benötigt. Beginnen Sie mit dem Import von zwei wichtigen 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: Definition der Funktion getStats

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

• Bei Erfolg gibt sie die Statistiken zurück;
• Bei einem Fehler 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: Definition der Funktion analyzeFile

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

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

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

Schritt 4: Definition der Funktion analyzeDirectory

Die Funktion analyzeDirectory durchsucht ein Verzeichnis und sammelt vollständige Statistiken über dessen Inhalt. Funktionsweise: Sie liest alle Elemente im Verzeichnis mit fs.readdir aus. Für jedes Element:

• Erstellt sie den vollständigen Pfad mit path.join;
• Verwendet getStats, um zu erkennen, ob es sich um eine Datei oder einen Ordner handelt;
• Handelt es sich um eine Datei:
  • Ruft analyzeFile auf, um { name, size } zu erhalten;
  • Aktualisiert Summen, größte Datei und die Dateiliste.
• Handelt es sich um ein Verzeichnis:
  • Ruft rekursiv analyzeDirectory auf;
  • Führt die Ergebnisse mit den aktuellen Statistiken zusammen.

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

Schritt 5: Hauptfunktion definieren und aufrufen

Die main-Funktion ist der Einstiegspunkt des Skripts. Sie legt den zu analysierenden Verzeichnispfad fest (in diesem Fall ./docs), ruft die Funktion analyzeDirectory auf, um die Statistiken des Verzeichnisses und seiner Inhalte 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();

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