Sveip for å vise menyen

Dette kapittelet gir deg en utfordring: å lage en avansert konsollapplikasjon kalt DirInspect Pro. Denne appen gir deg muligheten til å grundig analysere enhver katalog og få innsiktsfulle statistikker om filer og undermapper.

Utfordring

Se for deg et scenario der du må navigere gjennom en labyrint av mapper som inneholder viktige filer og data. DirInspect Pro er din hjelper på denne reisen, og gir deg omfattende innsikt i katalogens struktur og innhold.

Den ferdige applikasjonen

Gjør deg klar til å bruke DirInspect Pro sine funksjoner. Appen gir deg viktig informasjon, som

Totalt antall elementer;
Samlet størrelse på alle elementer;
Navn og størrelse på den største filen;
Detaljert liste over individuelle filnavn og størrelser.

To veier å velge

Du har to veier foran deg.

Den første er å ta utfordringen direkte, og skjerpe ferdighetene dine uten veiledning;
Den andre er å følge en nyttig guide som garanterer suksess.

Uansett hvilken vei du velger, venter en givende reise som ender med å lage en engasjerende og funksjonell konsollapplikasjon.

Masterplan

Steg 1: Importer nødvendige moduler;
Steg 2: Definer getStats-funksjonen;
Steg 3: Definer analyzeFile-funksjonen;
Steg 4: Definer analyzeDirectory-funksjonen;
Steg 5: Definer main-funksjonen og kall den;
Konklusjon;
Full programkode.

Steg 1: Importer nødvendige moduler

For å starte denne oppgaven trenger du de riktige verktøyene. Begynn med å importere to sentrale moduler: fs.promises for å håndtere filsystemet asynkront og path for effektiv håndtering av filbaner.

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

Kodebeskrivelse

Linje 1: importerer den innebygde fs-modulen. .promises-egenskapen gir tilgang til API-et basert på promises, slik at asynkrone filoperasjoner kan skrives med async/await;
Linje 2: importerer den innebygde path-modulen. Denne modulen tilbyr verktøy for å arbeide med fil- og mappestier, inkludert manipulering og normalisering av stier.

Steg 2: Definer getStats-funksjonen

Den asynkrone funksjonen getStats tar en fil- eller katalogsti som argument og forsøker å hente statistikk ved hjelp av fs.stat.

Ved suksess returneres statistikken;
Ved feil logges en feilmelding og funksjonen returnerer null.

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

Kodebeskrivelse

Linje 1: erklærer en asynkron funksjon kalt getStats som aksepterer en parameter filePath;
Linje 2, 5: oppretter en try...catch-blokk for feilbehandling under den asynkrone operasjonen;
Linje 3: bruker await fs.stat(filePath) for å hente informasjon om den angitte filen, som størrelse, opprettelsestidspunkt og annen metadata;
Linje 4: returnerer stats-objektet hvis fs.stat()-operasjonen fullføres uten feil;
Linje 6: logger en feilmelding til konsollen med console.error() hvis operasjonen feiler;
Linje 7: returnerer null for å indikere at filstatistikken ikke kunne hentes.

Steg 3: Definer analyzeFile-funksjonen

Funksjonen analyzeFile bruker getStats-funksjonen for å hente statistikk for en fil. Hvis statistikken er tilgjengelig (ikke null), returneres et objekt som inneholder filnavnet (hentet med path.basename) og størrelsen.

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

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

Kodebeskrivelse

Linje 1: erklærer en asynkron funksjon kalt analyzeFile som tar imot en filePath-parameter;
Linje 2: bruker await getStats(filePath) for å hente filstatistikk for den angitte stien;
Linje 3: sjekker om stats er falsk. Hvis statistikken ikke kunne hentes, returnerer funksjonen null;
Linje 5-8: oppretter og returnerer et objekt som inneholder filnavn og filstørrelse. Filnavnet hentes med path.basename(filePath), mens størrelsen hentes fra stats.size.

Steg 4: Definer analyzeDirectory-funksjon

Funksjonen analyzeDirectory skanner en katalog og samler fullstendig statistikk om innholdet. Slik fungerer det: Den leser alle elementer i katalogen ved hjelp av fs.readdir. For hvert element:

Bygger full sti med path.join;
Bruker getStats for å avgjøre om det er en fil eller mappe;
Hvis det er en fil:
- Kaller analyzeFile for å hente { name, size };
- Oppdaterer totaler, største fil og filliste.
Hvis det er en mappe:
- Kaller rekursivt analyzeDirectory;
- Slår sammen resultatene med gjeldende statistikk.

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

Kodebeskrivelse

Linje 1: erklærer en asynkron funksjon kalt analyzeDirectory som tar imot en directoryPath-parameter;
Linje 2-6: initialiserer variabler som brukes til å lagre katalogstatistikk, inkludert totalt antall elementer, totalt antall filer, total størrelse, største fil og en liste over analyserte filer;
Linje 8: starter en try-blokk for å håndtere potensielle filsystemfeil;
Linje 9: leser innholdet i katalogen med fs.readdir() og lagrer resultatet i items-arrayet;
Linje 11: starter en for...of-løkke for å iterere gjennom hvert element i katalogen;
Linje 12: oppretter full sti for gjeldende element med path.join();
Linje 13: henter statistikk for gjeldende element med getStats();
Linje 14: hopper over gjeldende element hvis statistikken ikke kunne hentes;
Linje 16: øker totalItems for hver fil eller mappe som behandles;
Linje 18-29: håndterer filbehandling:
Linje 19: kaller analyzeFile() for å hente filnavn og størrelse;
Linje 20: hopper over filen hvis analysen feiler;
- Linje 22-23: oppdaterer totalt antall filer og akkumulert filstørrelse;
- Linje 25-27: oppdaterer largestFile hvis gjeldende fil er større enn den tidligere registrerte;
Linje 29: legger til filinformasjonen i fileList;
Linje 30-42: håndterer mappebehandling:
Linje 31: kaller rekursivt analyzeDirectory() for undermappen;
- Linje 33-35: slår sammen undermappens statistikk med gjeldende totaler;
- Linje 37-39: oppdaterer largestFile hvis undermappen inneholder en større fil;
Linje 41: slår sammen fillister med concat();
Linje 45-50: returnerer et objekt som inneholder endelig katalogstatistikk;
Linje 52-62: håndterer feil ved å logge en melding og returnere et standard statistikkobjekt.

Steg 5: Definer main-funksjonen og kall den

main-funksjonen er startpunktet for skriptet. Den angir katalogstien som skal analyseres (i dette tilfellet ./docs), kaller funksjonen analyzeDirectory for å hente statistikk om katalogen og innholdet, og skriver deretter ut den innsamlede informasjonen. Funksjonen skriver ut

Totalt antall elementer;
Totalt antall filer;
Total størrelse;
Detaljer om den største filen;
Liste over 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();

Kodebeskrivelse

Linje 1: erklærer en asynkron funksjon kalt main;
Linje 2: definerer variabelen directoryPath, som lagrer stien til katalogen som skal analyseres;
Linje 3: kaller analyzeDirectory() med den angitte directoryPath og lagrer resultatet i variabelen directoryStats ved bruk av await;
Linje 5-17: viser de beregnede katalogstatistikkene ved hjelp av console.log(), inkludert totalt antall elementer, totalt antall filer, total størrelse og informasjon om den største filen;
Linje 18-20: itererer gjennom fileList-arrayet som er lagret i directoryStats;
logger navnet og størrelsen til hver fil i katalogen;
Linje 23: kaller funksjonen main() for å starte analyseprosessen.

Fullstendig appkode

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

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 2. Kapittel 10

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Seksjon 2. Kapittel 10

Verktøy for Kataloginspeksjon

Utfordring

Den ferdige applikasjonen

To veier å velge

Masterplan

Steg 1: Importer nødvendige moduler

Steg 2: Definer getStats-funksjonen

Steg 3: Definer analyzeFile-funksjonen

Steg 4: Definer analyzeDirectory-funksjon

Steg 5: Definer main-funksjonen og kall den

Fullstendig appkode