Sistema de Archivos (fs) en Node.js

// CommonJS const fs = require('fs'); const fsPromises = require('fs').promises; // ES Modules import fs from 'fs'; import { promises as fsPromises } from 'fs'; 

const fs = require('fs'); try { // Bloquea el Event Loop hasta completar const data = fs.readFileSync('archivo.txt', 'utf8'); console.log('Contenido:', data); console.log('Esta línea se ejecuta después'); } catch (error) { console.error('Error:', error.message); } 

const fs = require('fs'); // No bloquea el Event Loop fs.readFile('archivo.txt', 'utf8', (err, data) => { if (err) { console.error('Error:', err.message); return; } console.log('Contenido:', data); }); console.log('Esta línea se ejecuta primero'); 

const fs = require('fs').promises; // Con .then()/.catch() fs.readFile('archivo.txt', 'utf8') .then(data => { console.log('Contenido:', data); }) .catch(err => { console.error('Error:', err.message); }); // Con async/await async function leerArchivo() { try { const data = await fs.readFile('archivo.txt', 'utf8'); console.log('Contenido:', data); } catch (error) { console.error('Error:', error.message); } } 

const fs = require('fs'); // ❌ SÍNCRONO - Bloquea todo function leerArchivosSincrono() { console.time('sincrono'); for (let i = 0; i < 5; i++) { const data = fs.readFileSync(`archivo${i}.txt`, 'utf8'); console.log(`Archivo ${i} leído`); } console.timeEnd('sincrono'); // ~500ms (suma de todos) } // ✅ ASÍNCRONO - Paralelo async function leerArchivosAsincrono() { console.time('asincrono'); const promesas = []; for (let i = 0; i < 5; i++) { promesas.push( fs.promises.readFile(`archivo${i}.txt`, 'utf8') .then(data => console.log(`Archivo ${i} leído`)) ); } await Promise.all(promesas); console.timeEnd('asincrono'); // ~100ms (el más lento) } 

const fs = require('fs'); // 1. SÍNCRONO try { const data = fs.readFileSync('config.json', 'utf8'); const config = JSON.parse(data); console.log(config); } catch (error) { console.error('Error leyendo config:', error.message); } // 2. CALLBACK fs.readFile('config.json', 'utf8', (err, data) => { if (err) { console.error('Error:', err.message); return; } try { const config = JSON.parse(data); console.log(config); } catch (parseError) { console.error('Error parseando JSON:', parseError.message); } }); // 3. PROMISES async function cargarConfig() { try { const data = await fs.promises.readFile('config.json', 'utf8'); const config = JSON.parse(data); return config; } catch (error) { if (error.code === 'ENOENT') { console.log('Archivo de configuración no existe, usando defaults'); return {}; } throw error; } } 

const fs = require('fs'); // Sin encoding - retorna Buffer const buffer = fs.readFileSync('imagen.jpg'); console.log(buffer); // <Buffer ff d8 ff e0 00 10 4a 46 49 46...> // Con encoding - retorna string const texto = fs.readFileSync('archivo.txt', 'utf8'); console.log(typeof texto); // string // Encodings disponibles const encodings = [ 'utf8', // Por defecto para texto 'ascii', // Solo caracteres ASCII 'base64', // Base64 'hex', // Hexadecimal 'binary', // Binario (deprecated) 'utf16le' // UTF-16 Little Endian ]; // Ejemplo con diferentes encodings const data = fs.readFileSync('archivo.txt'); console.log('UTF-8:', data.toString('utf8')); console.log('Base64:', data.toString('base64')); console.log('Hex:', data.toString('hex')); 

const fs = require('fs'); // Para archivos grandes, usa streams function leerArchivoGrande(filename) { const stream = fs.createReadStream(filename, { encoding: 'utf8', highWaterMark: 64 * 1024 // 64KB chunks }); let contenido = ''; stream.on('data', (chunk) => { contenido += chunk; console.log(`Leído chunk de ${chunk.length} caracteres`); }); stream.on('end', () => { console.log(`Archivo completo leído: ${contenido.length} caracteres`); }); stream.on('error', (error) => { console.error('Error leyendo archivo:', error.message); }); } 

const fs = require('fs'); const data = { name: 'Mi App', version: '1.0.0', timestamp: new Date().toISOString() }; // 1. SÍNCRONO try { fs.writeFileSync('output.json', JSON.stringify(data, null, 2)); console.log('Archivo escrito exitosamente'); } catch (error) { console.error('Error escribiendo archivo:', error.message); } // 2. CALLBACK fs.writeFile('output.json', JSON.stringify(data, null, 2), 'utf8', (err) => { if (err) { console.error('Error:', err.message); return; } console.log('Archivo escrito exitosamente'); }); // 3. PROMISES async function guardarDatos(datos) { try { await fs.promises.writeFile( 'output.json', JSON.stringify(datos, null, 2), 'utf8' ); console.log('Archivo guardado'); } catch (error) { console.error('Error guardando:', error.message); } } 

const fs = require('fs'); // Agregar al final del archivo const logEntry = `${new Date().toISOString()} - Usuario logueado\n`; // SÍNCRONO fs.appendFileSync('app.log', logEntry); // ASÍNCRONO fs.appendFile('app.log', logEntry, (err) => { if (err) { console.error('Error escribiendo log:', err.message); return; } console.log('Log agregado'); }); // PROMISES await fs.promises.appendFile('app.log', logEntry); 

const fs = require('fs'); // Para escritura continua o archivos grandes function escribirArchivoGrande() { const stream = fs.createWriteStream('salida.txt'); // Escribir múltiples chunks for (let i = 0; i < 1000; i++) { const data = `Línea ${i}: ${new Date().toISOString()}\n`; stream.write(data); } // Cerrar el stream stream.end(); stream.on('finish', () => { console.log('Archivo escrito completamente'); }); stream.on('error', (error) => { console.error('Error escribiendo:', error.message); }); } // Ejemplo: Logger con rotación class FileLogger { constructor(filename, maxSize = 10 * 1024 * 1024) { // 10MB this.filename = filename; this.maxSize = maxSize; this.currentStream = null; this.currentSize = 0; this.initStream(); } initStream() { if (this.currentStream) { this.currentStream.end(); } this.currentStream = fs.createWriteStream(this.filename, { flags: 'a' }); this.currentSize = 0; } log(message) { const entry = `${new Date().toISOString()} - ${message}\n`; if (this.currentSize + entry.length > this.maxSize) { // Rotar archivo const timestamp = new Date().toISOString().replace(/[:.]/g, '-'); const backupName = `${this.filename}.${timestamp}`; this.currentStream.end(); fs.renameSync(this.filename, backupName); this.initStream(); } this.currentStream.write(entry); this.currentSize += entry.length; } } const logger = new FileLogger('app.log'); logger.log('Aplicación iniciada'); 

const fs = require('fs'); const path = require('path'); // Crear directorio simple fs.mkdir('nuevo-directorio', (err) => { if (err) { if (err.code === 'EEXIST') { console.log('El directorio ya existe'); } else { console.error('Error creando directorio:', err.message); } return; } console.log('Directorio creado'); }); // Crear directorio con subdirectorios (recursive) const dirPath = path.join('proyecto', 'src', 'components'); // SÍNCRONO try { fs.mkdirSync(dirPath, { recursive: true }); console.log('Estructura de directorios creada'); } catch (error) { console.error('Error:', error.message); } // ASÍNCRONO fs.mkdir(dirPath, { recursive: true }, (err) => { if (err) { console.error('Error:', err.message); return; } console.log('Estructura creada'); }); // PROMISES async function crearEstructura() { try { await fs.promises.mkdir(dirPath, { recursive: true }); console.log('Estructura creada con promises'); } catch (error) { console.error('Error:', error.message); } } 

const fs = require('fs'); const path = require('path'); // Listar archivos y directorios fs.readdir('.', (err, files) => { if (err) { console.error('Error leyendo directorio:', err.message); return; } console.log('Archivos y directorios:'); files.forEach(file => { console.log(`- ${file}`); }); }); // Con información detallada fs.readdir('.', { withFileTypes: true }, (err, entries) => { if (err) { console.error('Error:', err.message); return; } entries.forEach(entry => { const type = entry.isDirectory() ? 'DIR' : 'FILE'; console.log(`${type}: ${entry.name}`); }); }); // Función recursiva para listar todo async function listarRecursivo(dir, nivel = 0) { try { const entries = await fs.promises.readdir(dir, { withFileTypes: true }); for (const entry of entries) { const indent = ' '.repeat(nivel); const fullPath = path.join(dir, entry.name); if (entry.isDirectory()) { console.log(`${indent}📁 ${entry.name}/`); await listarRecursivo(fullPath, nivel + 1); } else { console.log(`${indent}📄 ${entry.name}`); } } } catch (error) { console.error(`Error leyendo ${dir}:`, error.message); } } // Uso listarRecursivo('./src'); 

const fs = require('fs'); // Eliminar directorio vacío fs.rmdir('directorio-vacio', (err) => { if (err) { if (err.code === 'ENOENT') { console.log('El directorio no existe'); } else if (err.code === 'ENOTEMPTY') { console.log('El directorio no está vacío'); } else { console.error('Error:', err.message); } return; } console.log('Directorio eliminado'); }); // Eliminar directorio recursivamente (Node.js 14+) fs.rm('directorio-con-contenido', { recursive: true, force: true }, (err) => { if (err) { console.error('Error eliminando:', err.message); return; } console.log('Directorio eliminado recursivamente'); }); // Función para limpiar directorio (eliminar contenido pero mantener directorio) async function limpiarDirectorio(dir) { try { const entries = await fs.promises.readdir(dir, { withFileTypes: true }); for (const entry of entries) { const fullPath = path.join(dir, entry.name); if (entry.isDirectory()) { await fs.promises.rm(fullPath, { recursive: true, force: true }); } else { await fs.promises.unlink(fullPath); } } console.log(`Directorio ${dir} limpiado`); } catch (error) { console.error('Error limpiando directorio:', error.message); } } 

const fs = require('fs'); // Obtener información de archivo/directorio fs.stat('archivo.txt', (err, stats) => { if (err) { if (err.code === 'ENOENT') { console.log('El archivo no existe'); } else { console.error('Error:', err.message); } return; } console.log('Información del archivo:'); console.log('- Tamaño:', stats.size, 'bytes'); console.log('- Es archivo:', stats.isFile()); console.log('- Es directorio:', stats.isDirectory()); console.log('- Creado:', stats.birthtime); console.log('- Modificado:', stats.mtime); console.log('- Último acceso:', stats.atime); console.log('- Permisos:', stats.mode.toString(8)); }); // Función utilitaria para información legible function formatearTamaño(bytes) { const sizes = ['Bytes', 'KB', 'MB', 'GB']; if (bytes === 0) return '0 Bytes'; const i = Math.floor(Math.log(bytes) / Math.log(1024)); return Math.round(bytes / Math.pow(1024, i) * 100) / 100 + ' ' + sizes[i]; } async function infoArchivo(filename) { try { const stats = await fs.promises.stat(filename); return { nombre: filename, tamaño: formatearTamaño(stats.size), tipo: stats.isFile() ? 'archivo' : 'directorio', creado: stats.birthtime.toLocaleDateString(), modificado: stats.mtime.toLocaleDateString(), permisos: stats.mode.toString(8).slice(-3) }; } catch (error) { return { error: error.message }; } } // Ejemplo de uso infoArchivo('package.json').then(info => { console.log(info); }); 

const fs = require('fs'); // Verificar si existe fs.access('archivo.txt', fs.constants.F_OK, (err) => { if (err) { console.log('El archivo no existe'); } else { console.log('El archivo existe'); } }); // Verificar permisos específicos fs.access('archivo.txt', fs.constants.R_OK | fs.constants.W_OK, (err) => { if (err) { console.log('No tienes permisos de lectura/escritura'); } else { console.log('Tienes permisos de lectura y escritura'); } }); // Constantes de permisos const permisos = { F_OK: 'existe', R_OK: 'lectura', W_OK: 'escritura', X_OK: 'ejecución' }; // Función para verificar múltiples permisos async function verificarPermisos(filename) { const resultados = {}; for (const [constante, nombre] of Object.entries(permisos)) { try { await fs.promises.access(filename, fs.constants[constante]); resultados[nombre] = true; } catch { resultados[nombre] = false; } } return resultados; } // Uso verificarPermisos('archivo.txt').then(permisos => { console.log('Permisos:', permisos); }); 

const fs = require('fs'); // Monitorear archivo o directorio const watcher = fs.watch('archivo.txt', (eventType, filename) => { console.log(`Evento: ${eventType}`); if (filename) { console.log(`Archivo: ${filename}`); } }); // Eventos: 'rename' (crear, eliminar, renombrar) y 'change' (modificar) // Detener el watcher después de 30 segundos setTimeout(() => { watcher.close(); console.log('Watcher cerrado'); }, 30000); // Manejar errores watcher.on('error', (error) => { console.error('Error en watcher:', error.message); }); 

const fs = require('fs'); // Monitoreo por polling (menos eficiente pero más confiable) fs.watchFile('config.json', { interval: 1000 }, (curr, prev) => { console.log('Archivo modificado:'); console.log(`- Tamaño anterior: ${prev.size}`); console.log(`- Tamaño actual: ${curr.size}`); console.log(`- Última modificación: ${curr.mtime}`); }); // Detener el watcher setTimeout(() => { fs.unwatchFile('config.json'); console.log('Watchfile detenido'); }, 60000); 

const fs = require('fs'); const path = require('path'); class DirectoryWatcher { constructor(directory) { this.directory = directory; this.watchers = new Map(); this.files = new Map(); this.init(); } async init() { // Escanear archivos existentes await this.scanDirectory(); // Monitorear directorio this.dirWatcher = fs.watch(this.directory, (eventType, filename) => { if (filename) { this.handleFileEvent(eventType, filename); } }); console.log(`Monitoreando directorio: ${this.directory}`); } async scanDirectory() { try { const files = await fs.promises.readdir(this.directory); for (const file of files) { const filepath = path.join(this.directory, file); const stats = await fs.promises.stat(filepath); if (stats.isFile()) { this.files.set(file, { size: stats.size, mtime: stats.mtime.getTime() }); } } } catch (error) { console.error('Error escaneando directorio:', error.message); } } async handleFileEvent(eventType, filename) { const filepath = path.join(this.directory, filename); try { const stats = await fs.promises.stat(filepath); const currentInfo = this.files.get(filename); if (!currentInfo) { // Archivo nuevo console.log(`📄 Archivo creado: ${filename}`); this.files.set(filename, { size: stats.size, mtime: stats.mtime.getTime() }); } else if (stats.mtime.getTime() > currentInfo.mtime) { // Archivo modificado console.log(`✏️ Archivo modificado: ${filename}`); console.log(` Tamaño: ${currentInfo.size} → ${stats.size} bytes`); this.files.set(filename, { size: stats.size, mtime: stats.mtime.getTime() }); } } catch (error) { if (error.code === 'ENOENT') { // Archivo eliminado if (this.files.has(filename)) { console.log(`🗑️ Archivo eliminado: ${filename}`); this.files.delete(filename); } } else { console.error(`Error procesando ${filename}:`, error.message); } } } close() { if (this.dirWatcher) { this.dirWatcher.close(); } console.log('Watcher cerrado'); } } // Uso const watcher = new DirectoryWatcher('./src'); // Cerrar después de 5 minutos setTimeout(() => { watcher.close(); }, 5 * 60 * 1000); 

const fs = require('fs'); // Crear stream de lectura const readStream = fs.createReadStream('archivo-grande.txt', { encoding: 'utf8', start: 0, // Byte de inicio end: 1000, // Byte de fin highWaterMark: 64 * 1024 // Tamaño del buffer (64KB) }); readStream.on('data', (chunk) => { console.log(`Chunk recibido: ${chunk.length} caracteres`); }); readStream.on('end', () => { console.log('Lectura completada'); }); readStream.on('error', (error) => { console.error('Error leyendo:', error.message); }); 

const fs = require('fs'); // Crear stream de escritura const writeStream = fs.createWriteStream('salida.txt', { flags: 'w', // 'w' = write, 'a' = append encoding: 'utf8', highWaterMark: 64 * 1024 }); // Escribir datos writeStream.write('Primera línea\n'); writeStream.write('Segunda línea\n'); // Finalizar writeStream.end('Última línea\n'); writeStream.on('finish', () => { console.log('Escritura completada'); }); writeStream.on('error', (error) => { console.error('Error escribiendo:', error.message); }); 

const fs = require('fs'); const { pipeline } = require('stream'); const { Transform } = require('stream'); // Transform que convierte a mayúsculas const upperCaseTransform = new Transform({ transform(chunk, encoding, callback) { this.push(chunk.toString().toUpperCase()); callback(); } }); // Pipeline: leer → transformar → escribir pipeline( fs.createReadStream('entrada.txt'), upperCaseTransform, fs.createWriteStream('salida-mayusculas.txt'), (error) => { if (error) { console.error('Pipeline falló:', error.message); } else { console.log('Pipeline completado exitosamente'); } } ); 

const path = require('path'); // Información sobre rutas console.log('Separador de directorios:', path.sep); // \ en Windows, / en Unix console.log('Separador de PATH:', path.delimiter); // ; en Windows, : en Unix const archivo = '/usuarios/juan/documentos/archivo.txt'; console.log('Directorio padre:', path.dirname(archivo)); // /usuarios/juan/documentos console.log('Nombre del archivo:', path.basename(archivo)); // archivo.txt console.log('Extensión:', path.extname(archivo)); // .txt console.log('Nombre sin extensión:', path.basename(archivo, '.txt')); // archivo // Parsear ruta completa const parsed = path.parse(archivo); console.log(parsed); // { // root: '/', // dir: '/usuarios/juan/documentos', // base: 'archivo.txt', // ext: '.txt', // name: 'archivo' // } // Construir rutas const nuevaRuta = path.format({ dir: '/usuarios/maria', name: 'config', ext: '.json' }); console.log(nuevaRuta); // /usuarios/maria/config.json 

const path = require('path'); // path.join() - Une segmentos de ruta console.log(path.join('usuarios', 'juan', 'documentos')); // usuarios/juan/documentos (Unix) o usuarios\juan\documentos (Windows) console.log(path.join('/usuarios', '../juan', './documentos')); // /juan/documentos // path.resolve() - Resuelve a ruta absoluta console.log(path.resolve('archivo.txt')); // /ruta/completa/actual/archivo.txt console.log(path.resolve('/usuarios', 'juan', 'archivo.txt')); // /usuarios/juan/archivo.txt console.log(path.resolve('..', 'archivo.txt')); // /ruta/padre/archivo.txt // Diferencia clave console.log(path.join('a', '/b', 'c')); // a/b/c console.log(path.resolve('a', '/b', 'c')); // /b/c (absoluta desde /b) 

const path = require('path'); const rutaAbsoluta = '/usuarios/juan/proyecto/src/index.js'; const rutaBase = '/usuarios/juan/proyecto'; // Convertir absoluta a relativa const rutaRelativa = path.relative(rutaBase, rutaAbsoluta); console.log(rutaRelativa); // src/index.js // Verificar si es absoluta console.log(path.isAbsolute('/usuarios/juan')); // true console.log(path.isAbsolute('src/index.js')); // false // Normalizar ruta (eliminar .. y .) console.log(path.normalize('/usuarios/juan/../maria/./documentos')); // /usuarios/maria/documentos 

const path = require('path'); const fs = require('fs'); // Encontrar archivos con extensión específica function encontrarArchivos(directorio, extension) { const archivos = []; function buscarRecursivo(dir) { const entries = fs.readdirSync(dir, { withFileTypes: true }); for (const entry of entries) { const fullPath = path.join(dir, entry.name); if (entry.isDirectory()) { buscarRecursivo(fullPath); } else if (path.extname(entry.name) === extension) { archivos.push(fullPath); } } } buscarRecursivo(directorio); return archivos; } // Crear estructura de proyecto function crearEstructuraProyecto(nombre) { const estructura = [ 'src', 'src/components', 'src/utils', 'tests', 'docs', 'public' ]; const basePath = path.join(process.cwd(), nombre); // Crear directorio base fs.mkdirSync(basePath, { recursive: true }); // Crear subdirectorios for (const dir of estructura) { const dirPath = path.join(basePath, dir); fs.mkdirSync(dirPath, { recursive: true }); } // Crear archivos iniciales const archivos = { 'package.json': JSON.stringify({ name: nombre, version: '1.0.0', description: '', main: 'src/index.js' }, null, 2), 'src/index.js': '// Punto de entrada de la aplicación\nconsole.log("Hola mundo");', 'README.md': `# ${nombre}\n\nDescripción del proyecto.`, '.gitignore': 'node_modules/\n.env\n*.log' }; for (const [archivo, contenido] of Object.entries(archivos)) { const archivoPath = path.join(basePath, archivo); fs.writeFileSync(archivoPath, contenido); } console.log(`Proyecto ${nombre} creado en ${basePath}`); } // Uso // crearEstructuraProyecto('mi-nuevo-proyecto'); 

const fs = require('fs'); // Manejar errores específicos fs.readFile('archivo-inexistente.txt', (err, data) => { if (err) { switch (err.code) { case 'ENOENT': console.log('Archivo no encontrado'); break; case 'EACCES': console.log('Permiso denegado'); break; case 'EISDIR': console.log('Es un directorio, no un archivo'); break; case 'EMFILE': console.log('Demasiados archivos abiertos'); break; case 'ENOSPC': console.log('No hay espacio en disco'); break; default: console.log('Error desconocido:', err.message); } return; } console.log('Archivo leído exitosamente'); }); // Función helper para manejo de errores function manejarErrorFS(error) { const errores = { ENOENT: 'Archivo o directorio no encontrado', EACCES: 'Permiso denegado', EEXIST: 'Archivo o directorio ya existe', EISDIR: 'Es un directorio', ENOTDIR: 'No es un directorio', EMFILE: 'Demasiados archivos abiertos', ENOSPC: 'No hay espacio en disco', EIO: 'Error de entrada/salida' }; return errores[error.code] || `Error desconocido: ${error.message}`; } 

const fs = require('fs'); const path = require('path'); // Función segura para leer archivo async function leerArchivoSeguro(filename, defaultValue = null) { try { const data = await fs.promises.readFile(filename, 'utf8'); return data; } catch (error) { if (error.code === 'ENOENT') { console.log(`Archivo ${filename} no existe, usando valor por defecto`); return defaultValue; } throw error; // Re-lanzar otros errores } } // Función segura para escribir archivo async function escribirArchivoSeguro(filename, data) { try { // Crear directorio padre si no existe const dir = path.dirname(filename); await fs.promises.mkdir(dir, { recursive: true }); // Escribir a archivo temporal primero const tempFile = `${filename}.tmp`; await fs.promises.writeFile(tempFile, data); // Renombrar (operación atómica) await fs.promises.rename(tempFile, filename); console.log(`Archivo ${filename} escrito exitosamente`); } catch (error) { console.error(`Error escribiendo ${filename}:`, manejarErrorFS(error)); throw error; } } // Función para copiar archivo con validaciones async function copiarArchivo(origen, destino) { try { // Verificar que el origen existe await fs.promises.access(origen, fs.constants.F_OK); // Verificar que el destino no existe o preguntar al usuario try { await fs.promises.access(destino, fs.constants.F_OK); throw new Error(`El archivo ${destino} ya existe`); } catch (error) { if (error.code !== 'ENOENT') { throw error; } } // Crear directorio destino si no existe const dirDestino = path.dirname(destino); await fs.promises.mkdir(dirDestino, { recursive: true }); // Copiar archivo await fs.promises.copyFile(origen, destino); console.log(`Archivo copiado: ${origen} → ${destino}`); } catch (error) { console.error('Error copiando archivo:', manejarErrorFS(error)); throw error; } } 

const fs = require('fs'); const path = require('path'); class ConfigManager { constructor(configPath = 'config.json') { this.configPath = configPath; this.config = {}; this.defaults = { port: 3000, host: 'localhost', debug: false, database: { host: 'localhost', port: 5432, name: 'myapp' } }; this.load(); } load() { try { if (fs.existsSync(this.configPath)) { const data = fs.readFileSync(this.configPath, 'utf8'); this.config = { ...this.defaults, ...JSON.parse(data) }; } else { this.config = { ...this.defaults }; this.save(); // Crear archivo con defaults } } catch (error) { console.error('Error cargando configuración:', error.message); this.config = { ...this.defaults }; } } save() { try { const dir = path.dirname(this.configPath); if (!fs.existsSync(dir)) { fs.mkdirSync(dir, { recursive: true }); } fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2)); } catch (error) { console.error('Error guardando configuración:', error.message); } } get(key) { return key.split('.').reduce((obj, k) => obj && obj[k], this.config); } set(key, value) { const keys = key.split('.'); const lastKey = keys.pop(); const target = keys.reduce((obj, k) => { if (!obj[k]) obj[k] = {}; return obj[k]; }, this.config); target[lastKey] = value; this.save(); } } // Uso const config = new ConfigManager(); console.log('Puerto:', config.get('port')); console.log('Host DB:', config.get('database.host')); config.set('debug', true); config.set('database.name', 'production'); 

const fs = require('fs'); const path = require('path'); class Logger { constructor(options = {}) { this.logDir = options.logDir || 'logs'; this.maxFileSize = options.maxFileSize || 10 * 1024 * 1024; // 10MB this.maxFiles = options.maxFiles || 5; this.level = options.level || 'info'; this.levels = { error: 0, warn: 1, info: 2, debug: 3 }; this.currentFile = null; this.currentStream = null; this.currentSize = 0; this.init(); } init() { // Crear directorio de logs if (!fs.existsSync(this.logDir)) { fs.mkdirSync(this.logDir, { recursive: true }); } this.rotateIfNeeded(); } rotateIfNeeded() { const today = new Date().toISOString().split('T')[0]; const logFile = path.join(this.logDir, `app-${today}.log`); if (this.currentFile !== logFile) { if (this.currentStream) { this.currentStream.end(); } this.currentFile = logFile; this.currentStream = fs.createWriteStream(logFile, { flags: 'a' }); // Obtener tamaño actual try { const stats = fs.statSync(logFile); this.currentSize = stats.size; } catch { this.currentSize = 0; } } // Rotar por tamaño if (this.currentSize > this.maxFileSize) { this.rotateBySize(); } } rotateBySize() { if (this.currentStream) { this.currentStream.end(); } // Renombrar archivos existentes for (let i = this.maxFiles - 1; i > 0; i--) { const oldFile = `${this.currentFile}.${i}`; const newFile = `${this.currentFile}.${i + 1}`; if (fs.existsSync(oldFile)) { if (i === this.maxFiles - 1) { fs.unlinkSync(oldFile); // Eliminar el más antiguo } else { fs.renameSync(oldFile, newFile); } } } // Renombrar archivo actual fs.renameSync(this.currentFile, `${this.currentFile}.1`); // Crear nuevo archivo this.currentStream = fs.createWriteStream(this.currentFile, { flags: 'w' }); this.currentSize = 0; } log(level, message, meta = {}) { if (this.levels[level] > this.levels[this.level]) { return; // Nivel muy bajo } this.rotateIfNeeded(); const timestamp = new Date().toISOString(); const logEntry = { timestamp, level: level.toUpperCase(), message, ...meta }; const logLine = JSON.stringify(logEntry) + '\n'; this.currentStream.write(logLine); this.currentSize += logLine.length; // También mostrar en consola console.log(`[${timestamp}] ${level.toUpperCase()}: ${message}`); } error(message, meta) { this.log('error', message, meta); } warn(message, meta) { this.log('warn', message, meta); } info(message, meta) { this.log('info', message, meta); } debug(message, meta) { this.log('debug', message, meta); } close() { if (this.currentStream) { this.currentStream.end(); } } } // Uso const logger = new Logger({ logDir: './logs', level: 'debug', maxFileSize: 1024 * 1024 // 1MB para testing }); logger.info('Aplicación iniciada'); logger.error('Error de conexión', { host: 'localhost', port: 3000 }); logger.debug('Variable de debug', { variable: 'valor' }); 

const fs = require('fs'); const path = require('path'); const { pipeline } = require('stream'); const zlib = require('zlib'); class BackupManager { constructor(sourceDir, backupDir) { this.sourceDir = sourceDir; this.backupDir = backupDir; if (!fs.existsSync(this.backupDir)) { fs.mkdirSync(this.backupDir, { recursive: true }); } } async createBackup() { const timestamp = new Date().toISOString().replace(/[:.]/g, '-'); const backupName = `backup-${timestamp}`; const backupPath = path.join(this.backupDir, backupName); console.log(`Iniciando backup: ${this.sourceDir} → ${backupPath}`); try { await this.copyDirectory(this.sourceDir, backupPath); // Comprimir backup const compressedPath = `${backupPath}.tar.gz`; await this.compressDirectory(backupPath, compressedPath); // Eliminar directorio sin comprimir await this.removeDirectory(backupPath); console.log(`Backup completado: ${compressedPath}`); // Limpiar backups antiguos await this.cleanOldBackups(); return compressedPath; } catch (error) { console.error('Error creando backup:', error.message); throw error; } } async copyDirectory(source, destination) { await fs.promises.mkdir(destination, { recursive: true }); const entries = await fs.promises.readdir(source, { withFileTypes: true }); for (const entry of entries) { const sourcePath = path.join(source, entry.name); const destPath = path.join(destination, entry.name); if (entry.isDirectory()) { await this.copyDirectory(sourcePath, destPath); } else { await fs.promises.copyFile(sourcePath, destPath); } } } async compressDirectory(source, destination) { // Crear archivo tar simple (sin usar librerías externas) const files = await this.getAllFiles(source); const writeStream = fs.createWriteStream(destination); const gzip = zlib.createGzip(); return new Promise((resolve, reject) => { pipeline( this.createTarStream(files, source), gzip, writeStream, (error) => { if (error) reject(error); else resolve(); } ); }); } async getAllFiles(dir) { const files = []; async function scan(currentDir) { const entries = await fs.promises.readdir(currentDir, { withFileTypes: true }); for (const entry of entries) { const fullPath = path.join(currentDir, entry.name); if (entry.isDirectory()) { await scan(fullPath); } else { files.push(fullPath); } } } await scan(dir); return files; } createTarStream(files, baseDir) { const { Readable } = require('stream'); return new Readable({ read() { if (files.length === 0) { this.push(null); return; } const file = files.shift(); const relativePath = path.relative(baseDir, file); // Simplificado: solo concatenar archivos con separador fs.readFile(file, (err, data) => { if (err) { this.emit('error', err); return; } const header = `\n--- ${relativePath} ---\n`; this.push(header); this.push(data); }); } }); } async removeDirectory(dir) { await fs.promises.rm(dir, { recursive: true, force: true }); } async cleanOldBackups(keepCount = 5) { const backups = await fs.promises.readdir(this.backupDir); const backupFiles = backups .filter(file => file.startsWith('backup-') && file.endsWith('.tar.gz')) .sort() .reverse(); if (backupFiles.length > keepCount) { const toDelete = backupFiles.slice(keepCount); for (const file of toDelete) { const filePath = path.join(this.backupDir, file); await fs.promises.unlink(filePath); console.log(`Backup antiguo eliminado: ${file}`); } } } async listBackups() { const backups = await fs.promises.readdir(this.backupDir); const backupFiles = backups .filter(file => file.startsWith('backup-') && file.endsWith('.tar.gz')) .sort() .reverse(); const backupInfo = []; for (const file of backupFiles) { const filePath = path.join(this.backupDir, file); const stats = await fs.promises.stat(filePath); backupInfo.push({ name: file, size: this.formatSize(stats.size), created: stats.birthtime.toLocaleString() }); } return backupInfo; } formatSize(bytes) { const sizes = ['Bytes', 'KB', 'MB', 'GB']; if (bytes === 0) return '0 Bytes'; const i = Math.floor(Math.log(bytes) / Math.log(1024)); return Math.round(bytes / Math.pow(1024, i) * 100) / 100 + ' ' + sizes[i]; } } // Uso const backupManager = new BackupManager('./src', './backups'); // Crear backup backupManager.createBackup() .then(backupPath => { console.log('Backup creado:', backupPath); return backupManager.listBackups(); }) .then(backups => { console.log('Backups disponibles:'); backups.forEach(backup => { console.log(`- ${backup.name} (${backup.size}) - ${backup.created}`); }); }) .catch(error => { console.error('Error:', error.message); });