Este capítulo te presenta un desafío: crear una aplicación de consola avanzada llamada DirInspect Pro. Esta aplicación te permitirá analizar a fondo cualquier directorio y obtener estadísticas detalladas sobre sus archivos y subdirectorios.

🏆 Desafío en Espera

Imagina un escenario en el que debes navegar por un laberinto de carpetas que contienen archivos y datos cruciales. DirInspect Pro es tu aliado en este recorrido, proporcionando información completa sobre la estructura y el contenido del directorio.

🚀 La Aplicación Resultante

Prepárate para aprovechar las capacidades de DirInspect Pro. La aplicación te proporcionará información crítica, como:

• El número total de elementos;
• El tamaño total de todos los elementos;
• El nombre y tamaño del archivo más grande;
• La lista detallada de nombres y tamaños de archivos individuales.

Dos Caminos a Elegir

Tienes dos caminos por delante.

• El primero es afrontar este desafío directamente, perfeccionando tus habilidades sin ayuda;
• El segundo es seguir una guía útil que garantiza tu éxito.

Elijas el camino que elijas, te espera una experiencia gratificante que culmina en la creación de una aplicación de consola atractiva y funcional.

Plan Maestro

• 👉 Paso 1: Importar los módulos requeridos;
• 👉 Paso 2: Definir la función getStats;
• 👉 Paso 3: Definir la función analyzeFile;
• 👉 Paso 4: Definir la función analyzeDirectory;
• 👉 Paso 5: Definir e invocar la función main;
• 🎉 Conclusión;
• 🏁 Código completo de la aplicación.

Paso 1: Importar los módulos requeridos

Para comenzar esta tarea, necesitarás las herramientas adecuadas. Empieza importando dos módulos clave: fs.promises para gestionar el sistema de archivos de manera asíncrona y path para manejar rutas de archivos de forma eficiente.

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

Paso 2: Definir la función getStats

La función asíncrona getStats recibe como argumento la ruta de un archivo o directorio e intenta obtener sus estadísticas utilizando fs.stat.

• Si tiene éxito, devuelve las estadísticas;
• Si ocurre un error, muestra un mensaje de error y retorna 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;
  }
}

Paso 3: Definir la función analyzeFile

La función analyzeFile utiliza la función getStats para obtener las estadísticas de un archivo. Si las estadísticas están disponibles (no son null), retorna un objeto que contiene el nombre del archivo (extraído usando path.basename) y su tamaño.

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

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

Paso 4: Definir la función analyzeDirectory

La función analyzeDirectory recibe una ruta de directorio como argumento y analiza de manera integral su contenido.

• Comienza leyendo los elementos dentro del directorio usando fs.readdir y luego itera sobre cada elemento;
• Para cada elemento, construye la ruta completa utilizando path.join y obtiene sus estadísticas mediante la función getStats;
• Si las stats indican que el elemento es un archivo, actualiza las estadísticas relacionadas con archivos;
• Si el elemento es un subdirectorio, llama recursivamente a la función analyzeDirectory para analizar su contenido y luego agrega las estadísticas.

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

Paso 5: Definir la función main e invocarla

La función main es el punto de entrada del script. Especifica la ruta del directorio a analizar (en este caso, ./docs), llama a la función analyzeDirectory para obtener las estadísticas del directorio y su contenido, y luego muestra la información recopilada. La función imprime

• El número total de elementos;
• El número total de archivos;
• El tamaño total;
• Los detalles sobre el archivo más grande;
• La lista de archivos en el directorio.

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

🎉 Conclusión: Habilidades dominadas

Con DirInspect Pro, se ha dominado el arte de analizar directorios como un profesional. Esta aplicación de consola demuestra la capacidad para extraer estadísticas de archivos, gestionar errores de manera eficiente y revelar información relevante sobre archivos y subdirectorios dentro de un directorio específico.

👨‍💻 Código Completo de la Aplicación

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