Questo capitolo ti propone una sfida: creare un'applicazione console avanzata chiamata DirInspect Pro. Questa applicazione ti permetterà di analizzare a fondo qualsiasi directory e ottenere statistiche dettagliate sui suoi file e sottodirectory.

Sfida

Immagina uno scenario in cui devi orientarti in un labirinto di cartelle contenenti file e dati cruciali. DirInspect Pro è il tuo alleato in questo percorso, fornendoti una panoramica completa della struttura e dei contenuti della directory.

L'applicazione finale

Preparati a sfruttare le funzionalità di DirInspect Pro. L'applicazione ti fornirà informazioni fondamentali, come:

• Il numero totale di elementi;
• La dimensione complessiva di tutti gli elementi;
• Il nome e la dimensione del file più grande;
• L'elenco dettagliato dei singoli nomi di file e delle rispettive dimensioni.

Due percorsi tra cui scegliere

Hai davanti a te due percorsi.

• Il primo consiste nell'affrontare questa sfida direttamente, perfezionando le tue competenze senza alcuna guida;
• Il secondo consiste nel seguire una guida utile che garantisce il successo.

Qualunque percorso tu scelga, ti attende un viaggio gratificante che culminerà nella creazione di un'app console coinvolgente e funzionale.

Piano principale

• Passaggio 1: Importazione dei moduli necessari;
• Passaggio 2: Definizione della funzione getStats;
• Passaggio 3: Definizione della funzione analyzeFile;
• Passaggio 4: Definizione della funzione analyzeDirectory;
• Passaggio 5: Definizione e invocazione della funzione main;
• Conclusione;
• Codice completo dell'app.

Passaggio 1: Importazione dei moduli necessari

Per intraprendere questa avventura, sono necessari gli strumenti giusti. Inizia importando due moduli fondamentali: fs.promises per gestire il file system in modo asincrono e path per gestire efficacemente i percorsi dei file.

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

Passaggio 2: Definizione della funzione getStats

La funzione asincrona getStats accetta come argomento il percorso di un file o di una directory e tenta di recuperare le sue statistiche utilizzando fs.stat.

• In caso di successo, restituisce le statistiche;
• In caso di errore, registra un messaggio di errore e restituisce 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;
  }
}

Passaggio 3: Definizione della funzione analyzeFile

La funzione analyzeFile utilizza la funzione getStats per ottenere le statistiche di un file. Se le statistiche sono disponibili (diverse da null), restituisce un oggetto contenente il nome del file (estratto tramite path.basename) e la sua dimensione.

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

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

Passaggio 4: Definizione della funzione analyzeDirectory

La funzione analyzeDirectory accetta come argomento il percorso di una directory e analizza in modo completo i suoi contenuti.

• Inizia leggendo gli elementi presenti nella directory tramite fs.readdir e poi itera su ciascun elemento;
• Per ogni elemento, costruisce il percorso completo utilizzando path.join e recupera le sue statistiche tramite la funzione getStats;
• Se le stats indicano che l'elemento è un file, aggiorna le statistiche relative ai file;
• Se l'elemento è una sottodirectory, richiama ricorsivamente la funzione analyzeDirectory per analizzarne i contenuti e poi aggrega le statistiche.

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

Passaggio 5: Definizione e Invocazione della Funzione main

La funzione main rappresenta il punto di ingresso dello script. Specifica il percorso della directory da analizzare (in questo caso, ./docs), richiama la funzione analyzeDirectory per ottenere le statistiche della directory e dei suoi contenuti, e infine visualizza le informazioni raccolte. La funzione stampa:

• Il numero totale di elementi;
• Il numero totale di file;
• La dimensione totale;
• I dettagli sul file più grande;
• L'elenco dei file nella directory.

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

Codice Completo dell'Applicazione

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