In diesem Kapitel erwartet Sie eine Herausforderung: die Entwicklung einer fortgeschrittenen Konsolenanwendung namens DirInspect Pro. Mit dieser Anwendung 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 Ihnen 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 Anwendung stellt Ihnen wichtige Informationen bereit, 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 der einzelnen Dateinamen und -größen.

Zwei Wege zur Auswahl

Es stehen zwei Wege offen.

• Der erste besteht darin, diese Herausforderung eigenständig anzugehen und dabei die eigenen Fähigkeiten ohne Anleitung zu schärfen;
• Der zweite besteht darin, 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 den Beginn dieses Vorhabens werden die passenden Werkzeuge benötigt. Importieren Sie zunächst zwei zentrale Module: 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;
• Im Fehlerfall wird eine Fehlermeldung ausgegeben 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 Dateinamen (ermittelt mit path.basename) und der Dateigröß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 nimmt einen Verzeichnispfad als Argument und analysiert dessen Inhalt umfassend.

• Zunächst werden die Elemente im Verzeichnis mit fs.readdir gelesen und anschließend jedes Element durchlaufen;
• Für jedes Element wird der vollständige Pfad mit path.join erstellt und dessen Statistiken mit der Funktion getStats abgerufen;
• Wenn die stats anzeigen, dass es sich um eine Datei handelt, werden dateibezogene Statistiken aktualisiert;
• Handelt es sich um ein Unterverzeichnis, wird die Funktion analyzeDirectory rekursiv aufgerufen, um dessen Inhalt zu analysieren und die Statistiken zu aggregieren.

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: Hauptfunktion definieren und aufrufen

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