Dieses Kapitel stellt Ihnen eine Herausforderung: die Erstellung einer fortgeschrittenen Konsolenanwendung namens DirInspect Pro. Diese App wird Sie in die Lage versetzen, ein beliebiges Verzeichnis gründlich zu analysieren und aufschlussreiche Statistiken über dessen Dateien und Unterverzeichnisse zu erhalten.

🏆 Herausforderung erwartet

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

🚀 Die resultierende App

Machen Sie sich bereit, die Fähigkeiten von DirInspect Pro zu nutzen. Die App wird Ihnen wichtige Informationen liefern, wie z.B.

• Die Gesamtanzahl der Elemente;
• Die Gesamtgröß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

Du hast zwei Wege vor dir.

• Der erste ist, diese Herausforderung direkt anzugehen und deine Fähigkeiten ohne Anleitung zu schärfen;
• Der zweite ist, einem hilfreichen Leitfaden zu folgen, der deinen Erfolg garantiert.

Welchen Weg du auch wählst, du bist auf einer lohnenden Reise, die in der Erstellung einer faszinierenden und funktionalen Konsolenanwendung gipfelt.

Masterplan

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

Schritt 1: Erforderliche Module importieren

Um dieses Abenteuer zu beginnen, benötigen Sie die richtigen Werkzeuge. Beginnen Sie mit dem Importieren von zwei wichtigen Modulen: fs.promises, um das Dateisystem asynchron zu verwalten, und path, um Dateipfade effektiv zu handhaben.

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

Schritt 2: Definiere die 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;
• Wenn ein Fehler auftritt, 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: Definiere die 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 zurück, das den Namen der Datei (extrahiert mit path.basename) und ihre Größe enthält.

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

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

Schritt 4: Definiere die Funktion analyzeDirectory

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

• Sie beginnt damit, die Elemente im Verzeichnis mit fs.readdir zu lesen und iteriert dann durch jedes Element;
• Für jedes Element konstruiert sie den vollständigen Pfad mit path.join und ruft dessen Statistiken mit der Funktion getStats ab;
• Wenn die stats anzeigen, dass das Element eine Datei ist, werden dateibezogene Statistiken aktualisiert;
• Wenn das Element ein Unterverzeichnis ist, ruft sie rekursiv die Funktion analyzeDirectory auf, um dessen Inhalte zu analysieren und aggregiert dann die Statistiken.

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 dessen Inhalte zu erhalten, und gibt dann die gesammelten Informationen aus. Die Funktion gibt aus

• Die Gesamtanzahl der Elemente;
• Die Gesamtanzahl der Dateien;
• Die Gesamtgröße;
• Die Details über die größte 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: Beherrschte Fähigkeiten

Mit DirInspect Pro hast du die Kunst gemeistert, Verzeichnisse wie ein Profi zu analysieren. Diese Konsolenanwendung zeigt deine Fähigkeit, Dateistatistiken zu extrahieren, Fehler nahtlos zu handhaben und bedeutungsvolle Einblicke in 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();