Detta kapitel presenterar en utmaning: att skapa en avancerad konsolapplikation vid namn DirInspect Pro. Denna applikation ger dig möjlighet att noggrant analysera valfri katalog och erhålla insiktsfull statistik om dess filer och underkataloger.

Utmaning

Föreställ dig ett scenario där du måste navigera genom en labyrint av mappar som innehåller viktiga filer och data. DirInspect Pro är din följeslagare på denna resa och tillhandahåller omfattande insikter om katalogens struktur och innehåll.

Den färdiga applikationen

Förbered dig på att använda DirInspect Pros funktioner. Applikationen kommer att tillhandahålla viktig information, såsom

• Det totala antalet objekt;
• Den sammanlagda storleken av alla objekt;
• Namnet och storleken på den största filen;
• En detaljerad lista över individuella filnamn och storlekar.

Två vägar att välja

Du har två vägar framför dig.

• Den första är att anta denna utmaning direkt och finslipa dina färdigheter utan vägledning;
• Den andra är att följa en hjälpsam guide som garanterar din framgång.

Oavsett vilken väg du väljer väntar en givande resa som kulminerar i skapandet av en fängslande och funktionell konsolapplikation.

Huvudplan

• Steg 1: Importera nödvändiga moduler;
• Steg 2: Definiera getStats-funktion;
• Steg 3: Definiera analyzeFile-funktion;
• Steg 4: Definiera analyzeDirectory-funktion;
• Steg 5: Definiera och anropa main-funktion;
• Slutsats;
• Komplett appkod.

Steg 1: Importera nödvändiga moduler

För att påbörja detta äventyr behöver du rätt verktyg. Börja med att importera två viktiga moduler: fs.promises för att hantera filsystemet asynkront och path för att effektivt hantera filsökvägar.

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

Steg 2: Definiera getStats-funktionen

Den asynkrona funktionen getStats tar en fil- eller katalogsökväg som argument och försöker hämta dess statistik med hjälp av fs.stat.

• Om det lyckas returneras statistiken;
• Om ett fel uppstår loggas ett felmeddelande och null returneras.

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

Steg 3: Definiera analyzeFile-funktionen

Funktionen analyzeFile använder funktionen getStats för att hämta statistik för en fil. Om statistik finns tillgänglig (inte null), returneras ett objekt som innehåller filens namn (extraherat med path.basename) och dess storlek.

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

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

Steg 4: Definiera analyzeDirectory-funktionen

Funktionen analyzeDirectory tar en katalogsökväg som argument och analyserar dess innehåll grundligt.

• Den börjar med att läsa objekten i katalogen med fs.readdir och itererar sedan genom varje objekt;
• För varje objekt konstrueras den fullständiga sökvägen med path.join och dess statistik hämtas med funktionen getStats;
• Om stats indikerar att objektet är en fil uppdateras filrelaterad statistik;
• Om objektet är en underkatalog anropas funktionen analyzeDirectory rekursivt för att analysera dess innehåll och statistiken summeras.

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

Steg 5: Definiera main-funktionen och anropa

Funktionen main är skriptets startpunkt. Den anger sökvägen till katalogen som ska analyseras (i detta fall ./docs), anropar funktionen analyzeDirectory för att erhålla statistik över katalogen och dess innehåll, och skriver sedan ut den insamlade informationen. Funktionen skriver ut

• Totalt antal objekt;
• Totalt antal filer;
• Total storlek;
• Detaljer om den största filen;
• Lista över filer i katalogen.

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

Fullständig applikationskod

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