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

🏆 Sfida in Arrivo

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, offrendo una panoramica completa sulla struttura e sui contenuti della directory.

🚀 L'applicazione finale

Preparati a sfruttare le potenzialità di DirInspect Pro. L'applicazione 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 nomi e delle dimensioni dei singoli file.

Due percorsi tra cui scegliere

Hai due percorsi davanti a te.

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

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

Piano principale

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

Passo 1: Importazione dei Moduli Necessari

Per iniziare questa attività, sono necessari gli strumenti adeguati. Importare innanzitutto 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");

Passo 2: Definizione della Funzione getStats

La funzione asincrona getStats accetta come argomento il percorso di un file o di una directory e tenta di recuperarne le 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;
  }
}

Passo 3: Definizione della Funzione analyzeFile

La funzione analyzeFile utilizza la funzione getStats per ottenere le statistiche di un file. Se le statistiche sono disponibili (non 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 un percorso di directory e ne analizza in modo completo il contenuto.

• Inizia leggendo gli elementi presenti nella directory utilizzando fs.readdir e poi itera su ciascun elemento;
• Per ogni elemento, costruisce il percorso completo tramite path.join e ne recupera le statistiche usando 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 il contenuto 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 del suo contenuto, e poi 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();

🎉 Conclusione: Competenze acquisite

Con DirInspect Pro, hai acquisito la capacità di analizzare le directory in modo professionale. Questa applicazione da console dimostra la tua abilità nell'estrarre statistiche sui file, gestire gli errori in modo efficiente e ricavare informazioni significative su file e sottodirectory all'interno di una directory specificata.

👨‍💻 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();