File system

Actualmente tanto la version LTS como current agregaron la API de File System basado en promesas 😃

Ejemplo de uso de forma nativa:

RESUMEN:

El file system provee una API para interactuar con el sistema de archivos cerca del estándar POSIX.
POSIX es el estándar para interfaces de comando y shell, las siglas las significan: “Interfaz de sistema operativo portátil” la X de POSIX es por UNIX.

El file system nos permite acceder archivo del sistema, leer, modificar., escribirlos, es muy útil para precompiladores, para lo que requiera hacer grabados de disco, o bases de datos en node requieren un uso intensivo de Node.Todo lo que hagamos con modulos por buenas prácticas son asincronos, pero tienen una version sincrona no recomendada pues pordría bloquear el event loop con más facilidad.

Para ver más sobre la documentación de FileSystem:

• FileSystem Docs

const fs = require('fs');

function leer(ruta, cb) {
    fs.readFile(ruta, (err, data) => {
        cb(data.toString());
    })
}

function escribir(ruta, contenido, cb) {
    fs.writeFile(ruta, contenido, function (err) {
        if (err) {
            console.error('No he podido escribirlo', err);
        } else {
            console.log('Se ha escrito correctamente');
        }

    });
}

function borrar(ruta, cb) {
    fs.unlink(ruta, cb);
}

// escribir(__dirname + '/archivo1.txt', 'Soy un archivo nuevo', console.log);
// leer(__dirname + '/archivo1.txt', console.log)
borrar(__dirname + '/archivo1.txt', console.log);

De esta forma se pueden leer archivos como si fueran promesas:
(util.promisify convierte funciones que retornen un callback a funciones que retornen una promesa 😎)

const fs = require('fs');
const util = require('util');

const readFile = util.promisify(fs.readFile)

readFile('./files/olakase.txt').then(file => {
	// 😎 do something 😎
}).catch(e => {
	console.error("🔥fire fire fire 🔥")
})

// o

async function foo() {
	try {
		const file = await readFile('./files/olakase.txt')
		console.log("🥺🥺🥺")
	} catch(e) {
		console.error("🔥🔥🔥")
	}
}

El File System es uno de los módulos principales que nos ofrece Node, este modulo es aquel que nos permite operar directamente con los archivos de nuestro sistema, permitiéndonos crear, leer, editar o eliminar archivos de nuestra índole.
Es mu importante tener en cuenta que la mayoría de métodos de este modulo son asíncronos, pero también nos ofrecen su versión síncrona, la cual es muy poco recomendable a la hora de usar ya que puede bloquear el evento loop de Node.
Para poder usar este modulo lo debemos importar con require en una constante con el mismo nombre del módulo:

• Const fs = require(‘fs’);
  Una vez importado podremos comenzar a usar los métodos que este módulo nos ofrece:
• Fs.readFile(path, callback);
• Fs.writeFile(path, content, callback)
• Fs.unlink(path, callback)

En node podemos crear, editar y eliminar archivos desde el servidor. La mayoria de estas acciones tienen metodos sincronos y asincronos, por ejemplo readFile y readFileSync.

“Use readFile siempre que sea posible, readFileSync bloquea el hilo mientras la solicitud es resuelta.”

Leer archivo

const fs = require('fs')
fs.readFile('path_to_file', (e, d) => {
    e ?
    console.error(e) :
    console.log(d.toString())
})

Escribir archivo

const fs = require('fs')
const ms = 'Este es el mensaje a guardar';
fs.writeFile('path_to_file', ms, e => {
    e ?
    console.error('Error al escribir') :
    console.log('Escrito correctamente')
})

Borrar archivo

const fs = require('fs')
fs.unlink('path_to_file', e => {
    e ?
    console.error('Error al borrar') :
    console.log('Borrado correctamente')
})

Le di otra funcionalidad al file system. La función makeTable crea un archivo de texto con la tabla de multiplicar de cualquier número. Les comparto el código:

File system

El file system es un módulo que nos va a permitir acceder archivos de nuestro sistema, también nos permite leer, modificar, cambiarles el nombre, entre otras cosas.

Para usar File system tenemos que hacer un require

const fs = require('fs')

⚠ Recuerda que preferible manejar todo de forma Async

Leer un archivo:

function readMyFile(route, cb) {
    fs.readFile(route, (error, data) => {
        cb(data.toString())
    })
}

readMyFile(__dirname + '/file.txt', console.log)

Crear un archivo:

function writeOnMyFile(route, content, cb) {
    fs.writeFile(
        route, 
        content, 
        (error) => (error) ? console.log('No he podido escribir', error) : console.log(`Se ha escrito correctamente`)
    )
}

writeOnMyFile(__dirname + '/createdFile.txt', 'Soy un archivo totalmente nuevo, dude', console.log)

Borrar un archivo:

function deleteFile(route, cb) {
    fs.unlink(route, cb)
}

deleteFile(__dirname + '/createdFile.txt', console.log)

😱 NO LO HAGAS!!! 😱

Por mas tentador que parezca, nunca intentes hacer un ciclo for al internar crear multiples archivos con fs, si no lo haces bien saldrá mal…

MUY MAL 😢

A partir de Node 10 podemos ocupar directamente la API de fs promises:

require('fs').promises
filehandle = await fsPromises.open('thefile.txt', 'r');

Para quien quiera ahondar:

https://nodejs.org/dist/latest-v10.x/docs/api/fs.html#fs_fs_promises_api

Por cierto comunidad, desde que tenemos ES6 ya normalmente no se escribe el + para concatenar una variable dentro de un texto como lo hace el profe con el __dirname + 'archivo.txt'.
Ahora se utilizan las backtick (``), asi

leer(`${__dirname}/archivo.txt`)

Una nota importante para los que apenas comienzan con este curso. La ruta que se define en las funciones de manipulación de archivos, es relativa al directorio desde el cuál se ejecutó node o nodemon, mas NO relativa al directorio en donde se encuentra el archivo .js en ejecución.

Happy Coding!

Una observacion! si usamos

writeFile

sobre un archivo que YA poseía informacion, se perderá esa informacion porque será reescrito con la data nueva que se envía en la funcion 👀

Me pareció importante compartirles la razón por la que se escribe const fs = require(‘fs’). Require en si es un modulo que se encarga de cargar dinamicamente modulos de JS. Sería como Thanos diciendo “use un modulo para cargar un modulo”. SI quieren produndizar en RequireJS les dej el enlace

El readFile() también puede recibir un segundo parámetro (entre la ruta al archivo y la callback function) que es un objeto con opciones para la lectura, con la codificación y un flag:

fs.readFile(__dirname + "/archivo.txt", { encoding: "utf8" }, (error, data) => { ... });

Incluso le podemos pasar solamente el string “utf8” y el método lo sabrá entender como la codificación, quedándonos:

fs.readFile(__dirname + "/archivo.txt", "utf8", (error, data) => { ... });

Con eso seteamos que la codificación sea en el formato de utf8 y nos podemos ahorrar el .toString() al Buffer.

Para leer más sobre el tema: Documentación oficial del readFile()

const fs = require('fs').promises;

async function read(path) {
    try {
        console.log("leyendo...")
        const data = await fs.readFile(path);
        return data.toString();
    } catch (err) {
        console.log("No se ha leido el archivo")
    }
}


async function write(path, content) {
    try {
        await fs.writeFile(path, content);
        console.log("Se ha escrito")
    } catch (err) {
        console.log('No se ha podido escribir');
    }
}

async function borrar(path) {
    try {
        console.log("Deleting");
        await wait();
        await fs.unlink(path);
    } catch (err) {
        console.log("no se ha podido eliminar");
    }

}

function wait() {
    return new Promise((res, rej) => {
        setTimeout(() => {
            console.log('...')
            res();
        }, 2000);
    })
}


async function main() {
    try {
        const data = await read(__dirname + '/archivo.txt');
        console.log(data)
        console.log('Termina lec')
        await write(__dirname + '/arch1.txt', "Soy un nuevo archivo")
        console.log('Espera...')
        await wait();
        await wait();
        await borrar(__dirname + '/arch1.txt');
        console.log('Eliminado')
    } catch (err) {
        console.log(err)
    }
}
main();

filesystem: permite acceder a archivos de nuestro sistema, acceder a archivos, escribirlos, leerlos, modificarlos. Es muy útil cuando se empieza a trabajar con precompiladores, cosas para hacer grabado de disco.

Con async y await:

const fs = require('fs')

async function read(path) {
    return new Promise((resolve, reject) => {
        fs.readFile(path, (err, data) => {
            if(err) reject(err)
            resolve(data.toString())
        })
    })
}

async function write(path, text) {
    return new Promise((resolve, reject) => {
        fs.writeFile(path, text, (err) => {
            if(err) reject(err)
            resolve('Escritura terminada')
        })
    })
}

async function deleteFile(path) {
    return new Promise((resolve, reject) => {
        fs.unlink(path, (err) => {
            if(err) reject('No se pudo eliminar')
            resolve("Archivo eliminado")
        })
    })
}

async function files() {
    try {
        let path = `${__dirname}/text_file.txt` 
        let result = await write(path, "un nuevo archivo")
        console.log(result)
        result = await read(path)
        console.log("Contenido txt: ", result)
        result = await deleteFile(path)
        console.log(result)
    } catch {
        console.log('Ocurrio un error: ', error)
    }
}

files()

Un aportesito gracias a mi amigo chatGpt, ❤️

Le pregunté por qué la función de borrar se llama ‘unlink’ y no ‘delete’ que suena como mas a BORRAR! y bueno me comentó que nodeJs trata de seguir las convenciones que dictan los sitemas operativos de Unix y Linux,

y ajam… entonces? por qué se llama unlink con la gente de linux y UNIX?

y bueno me respondió que en los años 70 80, cuando esta cosa empezó el borrado de archivos se llama también ‘unlink’ y eso de unlink era porque cuando borraban un archivo lo que hacían (y asumo que aún hacen) era borrar la referencia a dicho archivo,

y ya está!

no es que borran lo que se que haya que destruir dentro del disco duro, sino que simpleente se borran las referencias hacía ese espacio de memoria y simplemente lo sobreescriben en el futuro con los nuevos archivos creados!

agradecería me digan los que saben si en algo estoy pelao!

Les comparto mis funciones con arrow functions:

const fs = require('fs')

const leer = (ruta, cb) => {
  fs.readFile(ruta, (err, data) => {
    cb(data.toString())
  })
}

const escribir = (ruta, contenido, cb) => {
  fs.writeFile(ruta, contenido, (error, data) => {
    if (error) {
      cb(error.message)
    } else {
      cb('Escritura Terminada')
    }
  })
}

const borrar = (ruta, cb) => {
  fs.unlink(ruta, cb)
}

//leer(`${__dirname}/archivo.txt`, console.log)
//escribir(`${__dirname}/archivo1.txt`, 'Hola soy un archivo nuevo', console.log)
borrar(`${__dirname}/archivo1.txt`, console.log)

Hola a todos, tuve problemas para poder leer el archivo ya que al ejecutar el còdigo que sugeria el profesor me daba como resultado UNDEFINED sin embargo estuve buscando bastante tiempo y encontre una soluciòn la cual consta en definir el path o ruta literal con el modulo de path dentro del código.

Mi resultado fué elñ siguiente, por si alguien tiene problemas ya que estamos en pleno JS challenge.

El File System es uno de los módulos principales que nos ofrece Node, este modulo es aquel que nos permite operar directamente con los archivos de nuestro sistema, permitiéndonos crear, leer, editar o eliminar archivos de nuestra índole.

Haciendo una aclaración sobre mi aporte anterior el NodeJS normalmente funciona con CommonJS, pero ahora va implementarse el ESmodules. En este caso el __dirname da problemas, una manera de solucionarlo es haciendo uso de los process y de la funcion cwd() de esta manera: __dirname = process.cwd();

Si ya tienes un archivo creado con texto dentro, y lo que quieres es agregarle texto y no reemplazarlo, solo con pasarle un objeto {flag: ‘a’}

esto significa que el texto que le agregues se pondrá al final de tu texto.

en la documentación de NODE hay mas parametros que podemos utilizar
https://nodejs.org/dist/latest-v18.x/docs/api/fs.html#file-system-flags

Hay unos detalles en esta clase que están mal.

1. En la función de escribir NUNCA usamos el callback, perfectamente podemos hacer esto y sigue funcionando:

const escribir = (ruta, contenido) => {
  fs.writeFile(ruta, contenido, (error) => {
    error ?
      console.error('No he podido escribirlo', error) :
      console.log('Se ha escrito correctamente')
  })
}

//let contenido = 'Soy un archivo nuevo'

//escribir(__dirname + '/archivo1.txt', contenido)

Y el otro es que cuando borramos NO da null porque no hubo, dio null porque NO hicimos nada con el callback.

Yo lo hice así y es prácticamente lo mismo:

const borrar = (ruta, cb) => {
  fs.unlink(ruta, cb)
}

borrar(__dirname + '/archivo1.txt', ()=>{});

Aprovechando el api de fs basado en promises , ademas usando async y await.

Se puede apreciar como la ejecución de readFile y readWriteDelete por momentos se overlapean debido a que ambas se ejecutan asíncronamente.

Sin embargo, dentro de readWriteDelete la ejecución de writeFile, readFile y deleteFile ocurre de forma secuencial

Es mas facil escribir hacer estas operaciones basicas en Node ya que te dejas de preocupar por crear variables para el flujo de datos, buffer, etc… Es mas simple

Importante conocer la estructura de fs.

const fs = require('fs');

function leer(ruta, callback) {
    fs.readFile(ruta, (err, data) => {
        console.log(data.toString());
    })
}

function escribir(ruta, contenido, callback) {
    fs.writeFile(ruta, contenido, (err) => {
        if (err) {
            console.error('No he podido escribirlo', err);
        } else {
            console.log('Se ha escrio correctamente');
        }
    });
}


function borrar(ruta, callback) {
    fs.unlink(ruta, callback);
}

//escribir(__dirname + '/archivo1.txt', 'Soy un archivo nuevo', console.log);
//leer(__dirname + '/archivo.txt', console.log)

borrar(__dirname + '/archivo1.txt', console.log);

const fs = require('fs');

fs.readFile('./package.json', (err, data) => {
    console.log(data.toString());
})

Asi de pequeño

fs.writeFile(__dirname + '/creado.txt', 'soy en contenido', (err) => {
    if(err){
        console.log('no se pudo crear');
    }else{
        console.log('creado correctamente');
    }
})

hace varios meses, me puse el reto de poder correr con node las paginas que voy desarrollando, y logre que me cargaran archivos con el modulo Path

¿Cuál es la finalidad de invocar los console.log sin los paréntesis ni parámetros?

// First we require the file system module
var fs = require(‘fs’);

// To create/write a file
// Ej: this would write 'hola mundo' in a file located within the assets folder.
fs.writeFile('assets/text.txt', 'hola mundo ♥️');

// To delete the file
fs.unlink('assets/text.txt')

Notas importantes

• Cuando hacemos un “requiere” la variable o constante deberá tener el mismo nombre que el modulo que estamos solicitando.
• Ambas funciones fueron llamadas de manera asíncrona (por ejemplo podemos tener varias funciones corriendo al mismo tiempo). Para llamarlas de manera síncrona (en donde solo puede suceder una función a la vez) se llamaría la funcion fs.writeFileSync(path, data) y la funcion para eliminar sería fs.unlinkSync(path)

Use la versión con asyn/await

Es verdad, si puedes realizar los ejercicios con promesas:

Escribí una función simple para agregar información a un archivo en vez de sobreescribirlo.

File system

1. File System: El módulo fs es un módulo central en Node.js que proporciona funciones para trabajar con el sistema de archivos del sistema operativo.
2. Módulo requerido: Para utilizar las funciones del módulo fs, primero debes requerirlo en tu archivo de JavaScript utilizando require('fs').
3. Lectura de archivos: Puedes leer el contenido de un archivo utilizando la función fs.readFile(). Esta función toma la ruta del archivo y una función de devolución de llamada que se ejecuta una vez que se completa la lectura del archivo.
4. Escritura de archivos: Puedes escribir datos en un archivo utilizando la función fs.writeFile(). Esta función toma la ruta del archivo, los datos a escribir y una función de devolución de llamada que se ejecuta una vez que se completa la escritura.
5. Manipulación de archivos: El módulo fs proporciona una variedad de funciones para manipular archivos, como renombrar archivos (fs.rename()), eliminar archivos (fs.unlink()), verificar la existencia de un archivo (fs.existsSync()), entre otros.
6. Operaciones asíncronas y síncronas: La mayoría de las funciones en el módulo fs tienen versiones asíncronas y síncronas. Las versiones asíncronas utilizan una función de devolución de llamada para manejar los resultados, mientras que las versiones síncronas bloquean la ejecución hasta que se completa la operación.
7. Streams: Además de la lectura y escritura básica de archivos, el módulo fs también proporciona soporte para trabajar con streams, que son flujos de datos que se pueden leer o escribir de manera eficiente.

Recuerda que el módulo fs ofrece muchas más funcionalidades y opciones para trabajar con archivos y directorios en Node.js. Te recomiendo consultar la documentación oficial de Node.js para obtener más detalles y ejemplos específicos sobre el uso del módulo fs: https://nodejs.org/api/fs.html

Hola 😁

Código de clase utilizando Promesas, y try catch.

Resultado sin errores.

Ejemplo de resultado con error (No encuentra el archivo).

Por si quieren profundizar en lo que vimos hoy, les dejo por acá enlaces a la documentación de File System y a unos ejemplos de uso que da W3 Schools 😉

File System

Todas las operaciones del sistema de archivos tienen formularios sincrónicos, de devolución de llamada y basados en promesas, y se puede acceder a ellos mediante la sintaxis de CommonJS y los módulos ES6 (ESM).
.
Todo lo que hagamos con modulos por buenas prácticas son asincronos, pero tienen una version sincrona no recomendada pues pordría bloquear el event loop con más facilidad.
.

File System Docs

El módulo file system nos permite acceder a archivos de nuestro sistema leerlos, escribirlos, modificarlos, cambiar el nombre y muchas otras cosas, es muy útil cuando se empieza a trabajar en pre-compiladores o cualquier cosa que requiera hacer un grabado en disco.

Interesante clase!!!

gracias @justinmark por tu aporte. lo estuve implementando, lo que no me funcionó hasta que agregué el promises en el import(require). Les dejo esta versión que estuve trabajando ya con el errorhandling 😃.

import { promises as fs } from “fs”;

const read = async (path) => {
try {
const file = await fs.readFile(path, { encoding: “utf-8” });
console.log(file.toString());
} catch (error) {
console.log(error.message);
}
};

/*El file system provee una API para interactuar con el sistema de archivos cerca del estándar POSIX.
POSIX es el estándar para interfaces de comando y shell, las siglas las significan: “Interfaz de sistema operativo portátil” la X de
POSIX es por UNIX.

El file system nos permite acceder archivo del sistema, leer, modificar., escribirlos, es muy útil para precompiladores, para lo que
requiera hacer grabados de disco, o bases de datos en node requieren un uso intensivo de Node.Todo lo que hagamos con modulos por buenas
prácticas son asincronos, pero tienen una version sincrona no recomendada pues pordría bloquear el event loop con más facilidad. */

const fs = require('fs');

function leer(ruta, cb) {
    fs.readFile(ruta, (err, data) => {
        cb(data.toString());
    })
}

function escribir(ruta, contenido, cb) {
    fs.writeFile(ruta, contenido, function (err) {
        if (err) {
            console.error('No he podido escribirlo', err);
        } else {
            console.log('Se ha escrito correctamente');
        }

    });
}


function borrar(ruta, cb) {
    fs.unlink(ruta, cb);
}

//leer(__dirname + '/archivo.txt', console.log) //para leer un archivo
//escribir(__dirname + '/archivo1.txt', 'Soy un archivo nuevo', console.log); //para crear un nuevo archivo y escribir en el
//leer(__dirname + '/archivo1.txt', console.log)
//borrar(__dirname + '/archivo1.txt', console.log); //borra un archivo```

Buenas compañeros, para practicar el fileSystem en node.js, realize una pequeña practica con 2 archivos, uno lo creo con codigo luego escribo en el, lo leeo, guardo el contenido en una variable, creo una carpeta mando el segundo archivo a esa dirección, y luego escribo el contenido del primer archivo dentro del segundo.

const fs = require("fs").promises
const path = require("path")
    
const Filepath = "./demo.txt"
let content
const writeThis = `Introduction: To create file, to write to a file or to read a file fs.open() method is used. fs.readFile() is only for reading the file and similarly fs.writeFile() is only for writing to a file, whereas fs.open() method does several operations on a file. First we need to load the fs class which is module to access physical file system. For it require method is used. For example: var fs = require('fs');`


// For write.
fs.open(Filepath, "w+")
.then((file)=> {
        console.log(file.fd)
        file.write(writeThis)
        console.log("The operation was sucessful")
        file.close();
    })
    .catch((err)=> console.error(err));


// For Read.

async function reader() {
    fs.open(Filepath, "r+")
    .then((file)=> {
        console.log(file.fd)
        file.readFile("utf-8")
            .then((data)=> {
                content = data;
                MoveandWrite()
                file.close() 
            })
            .catch((console.error))
        console.log("The operation was sucessful")
        
    })
    .catch((err)=> console.error(err));
}

reader();

function MoveandWrite() {
    const oldPath = "./theFile.txt"
    const newPath =  __dirname + "/testF/theFile.txt"

    fs.unlink(newPath).catch(()=> console.log("not deleted"))

    fs.mkdir(path.join(__dirname, "testF")).catch(()=> console.log("already exits"))

    fs.rename(oldPath, newPath)
    .then(()=> {
        fs.writeFile(newPath, content)
        .then(()=> console.log("written sucessfully"))
        .catch((console.error))
    })
    .catch((console.error))
}

File system

Es un modulo que permite acceder a archivos de nuestro sistema y podemos leerlos, escribirlos, modificarlos, cambiarles el nombre o eliminarlos.

Primero debemos traer nuestro modulo

const fs = require('fs');

Escritura de un archivo

function escribir(ruta, contenido, cb) {
  fs.writeFile(ruta, contenido, function(err) {
    if(err) {
      console.error('Hubo un problema de escritura')
    } else {
      console.log('Se ha escrito correctamente');
    }
  })
}
escribir(`${__dirname}/ejemplos.txt`, 'Soy una linea nueva', console.log);

Lectura de un archivo

function leer(ruta, cb) {
  fs.readFile(ruta, (err, data) => {
    cb(data.toString());
  })
}
leer(`${__dirname}/ejemplos.txt`, console.log);

Eliminar de un archivo

function borrar(ruta, cb) {
  fs.unlink(ruta, cb);
}
borrar(`${__dirname}/ejemplos.txt`, console.log);

function borrar(ruta, callback) {
    fs.unlink(ruta, (err) => {
        if (err) {
            console.error('No se ha podido eliminar el archivo');
        } else {
            console.log('Archivo eliminado con exito! 💪');
        }
    });
}

Si tienes error en leer archivos, debes verificar la ruta del archivo y porbar

<const fs = require('fs'); //importando file system

fs.readFile('./componentes/archivo.txt','utf-8',(error, data) =>{
    if (!error){
        console.log(data);
    }
    else{
        console.log(error);
    }
});> 

file-system.js

main.js

Gestionar archivos del sistema tenemos a File system

🎱 Codigo

const fs = require("fs");

function leer(ruta, cb) {
  fs.readFile(ruta, (err, data) => {//read para que nos traiga la informacion del archivo
    cb(data.toString());
  });
}

leer(__dirname + '/archivo.txt', console.log)

function escribir(ruta, contenido,cb){
    fs.writeFile(ruta,contenido,function(err){//write para escribir en un archivo 'modificar'
        if(err){
            console.error('No he podido escribirlo',err)
        } else{
            console.log('Se ha escrito correctamente');
        }

    })
}
escribir(__dirname + '/archivo1.txt','Soy un archivo nuevo',console.log)

function borrar(ruta,cb){
    fs.unlink(ruta,cb);//desconecta el archivo 'eliminar'
}

borrar(__dirname + '/archivo1.txt', console.log)

File system

readFile()

writeFile()

unlink()

require(’fs’).promises

El módulo “File System” (fs) en Node.js proporciona funciones para trabajar con el sistema de archivos del sistema operativo. Aquí tienes una breve descripción de las funciones que mencionaste:

1. readFile(): La función readFile() se utiliza para leer el contenido de un archivo en el sistema de archivos. Toma dos argumentos: la ruta del archivo que se desea leer y una función de devolución de llamada que se ejecuta cuando se completa la lectura del archivo. La función de devolución de llamada recibe dos argumentos: el error, en caso de que se produzca un error durante la lectura, y los datos del archivo leídos. Aquí tienes un ejemplo de uso:

   const fs = require('fs');
   
   fs.readFile('archivo.txt', 'utf8', (error, datos) => {
     if (error) {
       console.error('Error al leer el archivo:', error);
       return;
     }
     console.log('Contenido del archivo:', datos);
   });
   

2. writeFile(): La función writeFile() se utiliza para escribir datos en un archivo en el sistema de archivos. Toma tres argumentos: la ruta del archivo en el que se desea escribir, los datos que se desean escribir y una función de devolución de llamada que se ejecuta cuando se completa la escritura del archivo. La función de devolución de llamada recibe un argumento, que es un objeto de error en caso de que se produzca un error. Aquí tienes un ejemplo de uso:

   const fs = require('fs');
   
   fs.writeFile('archivo.txt', 'Contenido de ejemplo', (error) => {
     if (error) {
       console.error('Error al escribir en el archivo:', error);
       return;
     }
     console.log('El archivo se ha escrito correctamente.');
   });
   

3. unlink(): La función unlink() se utiliza para eliminar (borrar) un archivo del sistema de archivos. Toma dos argumentos: la ruta del archivo que se desea eliminar y una función de devolución de llamada que se ejecuta cuando se completa la eliminación del archivo. La función de devolución de llamada recibe un argumento, que es un objeto de error en caso de que se produzca un error. Aquí tienes un ejemplo de uso:

   const fs = require('fs');
   
   fs.unlink('archivo.txt', (error) => {
     if (error) {
       console.error('Error al eliminar el archivo:', error);
       return;
     }
     console.log('El archivo se ha eliminado correctamente.');
   });
   

Estas funciones son útiles para realizar operaciones de lectura, escritura y eliminación de archivos en Node.js. Es importante manejar los errores adecuadamente al trabajar con el sistema de archivos para garantizar que las operaciones se realicen de manera segura y confiable.

En Node.js, el módulo fs.promises proporciona una interfaz basada en promesas para realizar operaciones de lectura y escritura de archivos en el sistema de archivos. Esto simplifica la programación asincrónica al permitirte trabajar con promesas en lugar de utilizar devoluciones de llamada (callbacks) para manejar las operaciones de archivos. Aquí tienes un ejemplo de cómo utilizar fs.promises para realizar operaciones de lectura y escritura de archivos:

const fs = require('fs').promises;

async function leerArchivo() {
  try {
    const datos = await fs.readFile('archivo.txt', 'utf8');
    console.log('Contenido del archivo:', datos);
  } catch (error) {
    console.error('Error al leer el archivo:', error);
  }
}

async function escribirArchivo() {
  try {
    await fs.writeFile('nuevo-archivo.txt', 'Contenido de ejemplo');
    console.log('El archivo se ha escrito correctamente.');
  } catch (error) {
    console.error('Error al escribir en el archivo:', error);
  }
}

leerArchivo();
escribirArchivo();

En el ejemplo anterior, utilizamos fs.promises.readFile() y fs.promises.writeFile() para leer y escribir archivos respectivamente. Las operaciones se realizan de manera asincrónica y se manejan mediante async/await, lo que hace que el código sea más legible y estructurado.

Ten en cuenta que fs.promises es una característica relativamente nueva en Node.js, y está disponible a partir de Node.js 14.0.0 en adelante. Si estás utilizando una versión anterior de Node.js, es posible que no tengas acceso a fs.promises. En ese caso, puedes utilizar las funciones de devolución de llamada tradicionales proporcionadas por el módulo fs.

const fs = require("fs")
const path = require("path")

const read = (path, callback) => {
    fs.readFile(path, (err, data) => {
        console.log()
        console.log("Buffer, raw data", data)
        console.log("Data", data.toString())
    })
}

const write = (path, content, callback) => {
    fs.writeFile(path, content, callback)
}

const remove = (path, callback) => {
    fs.rm(path, callback)
}

const rename = (oldPath, path, callback) => {
    fs.rename(oldPath, path, callback)
}

const msg_handler = (err, simple_verb, past_verb) => {
    if (err) {
        console.log(`I haven't been able to ${simple_verb} file`)
    } else {
        console.log(`File has been ${past_verb} correctly`)
    }
}

const execWrite = (err) => {
    msg_handler(err, 'write', 'written')
}

const execRemove = (err) => {
    msg_handler(err, 'remove', 'removed')
}

const execRename = (err) => {
    msg_handler(err, 'rename', 'renamed')
}


read(__dirname + '/data.json')
write(__dirname + '/test.txt', 'Hello everyone', execWrite)
rename(__dirname + '/test.txt', __dirname + '/rename_test.txt', execRename)
remove(__dirname + '/rename_test.txt', execRemove)

También se puede hacer un append al archivo

fs, es la abreviatura en ingles para file system o sistema de archivos, y es, ademas, uno de los módulos más básicos y útiles de Node

Unlink File

Write File

Read File

Importar un modulo

global.mivariable = 'el valor';
const fs = require ('fs');

function leer (ruta,cb){
    fs.readFile(ruta, (err,data) =>{
        console.log(data.toString());
    })

}

function escribir (ruta,contenido,cb) {
    fs.writeFile(ruta,contenido,function(err) {
        if (err){
            console.error('no he podido escribirlo',err);
        }else 
        console.log ('se ha escrito correctamente')
        
    });
}

escribir(__dirname + '/PROGRAMACION/NOTAS.txt', 'soy un archivo nuevo',console.log)

para eliminar un archivo

const deletefile = async (path_file)=>{
    try {
        await fs.unlink(path_file);
        console.log(`Deleted ${path_file}`);
    } catch (error) {
        console.error(`Got an error trying to delete the file: ${error.message}`);
    }
}

deletefile(__dirname+space+file);

para crear un archivo

const write = async (nameFile, content)=>{
    try{
        await fs.writeFile(nameFile, content);
        console.log(`Wrote data to ${nameFile}`);
    }catch(err){
        console.error(`Got an error trying to write the file: ${err.message}`);
    }
}

write(file,content);

usando nodejs con la versión 18.14.2

import * as fs from 'node:fs/promises';
import { fileURLToPath } from 'url';
import { dirname } from 'path';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);


let name = 'README.md';
let space = '\\';

const read = async (file) =>{
    try{
        const data = await fs.readFile(file, 'utf-8');
        console.log(data);
    }catch(err){
        console.error(`got an error trying to read the file ${err.message}`);
    }
}

read(__dirname+space+name);

Este es un ejemplo de lectura/escritura de archivos planos usando promesas:

Muy útil para escribir logs en el servidor y monitorear el estado de la aplicación.

Mi aporte de forma síncrona:

const fs = require('fs').promises;

const leer = async (ruta) => {
    try {
        const archivo = await fs.readFile(ruta);
        console.log('--------');
        console.log('[Log] Leyendo: ', ruta,'\n');

        console.log(archivo.toString());
        console.log('--------');
    } catch (error) {
        console.error(error);
    }
};

const escribir = async (ruta, contenido) => {
    try {
        await fs.writeFile(ruta, contenido);
        console.log('[Log] ✅ Archivo Creado:', ruta);
    } catch (error) {
        console.error(error);
    }
};

const borrar = async (ruta) => {
    try {
        await fs.unlink(ruta);
        console.log('[Log] 🧺 Archivo Borrado:', ruta);
    } catch (error) {
        console.error(error);
    }
};

const ejecutarFunciones = async () => {
    await leer(__dirname + '/datos.txt');

    const archivoNuevo = __dirname + '/datos1.txt';

    await escribir(archivoNuevo, 'Archivo nuevo con texto');
    await leer(archivoNuevo);

    await borrar(archivoNuevo);
};
ejecutarFunciones();

File system

Este modulo es bastante importante ya que de seguro lo usaremos muchas veces y partiendo de esa premisa, es preciso aprender a manipularlo en su forma mas sencilla.

El file-system o fs nos va a permitir acceder a archivos de nuestro sistema, tambien nos permitira, leerlos, escribirlos, modificarlos, cambiar sus propiedades, cambiar su nombre, etc. Es muy util cuando empezamos a trabajar en precompiladores o cualquier trabajo que requiera hacer un grabado a disco.

Funciones basicas de file system
Lo primero que debemos hacer es importar el modulo que nos permitira ejecutar estas funciones. Lo podemos importar de la forma:

const fs = require('fs');

• Escritura de archivos: Creamos un arrow function que nos retornara un callback con la respuesta.

writeFile = (ruta, contenido, cb) => {
    // fs.writeFile nos ayuda a crear archivos en una ruta , nombre y contenido especificos.
    fs.writeFile(ruta, contenido, (err) => {
        if (err) {
            console.log('No se ha podido crear el archivo: ', err);
        } else {
            console.log('Se ha creado el archivo correctamente!');
        }
    });
}

• Lectura de archivos: Creamos un arrow function que nos retornara un callback con la respuesta.

readFile = (ruta, cb) => {
    // fs.readFile nos pemite leer archivos de una ruta en especifico.
    fs.readFile(ruta, (err, data) => {
        // console.log('data: ', data.toString());
        cb(data.toString());
    });
}

• Borrado de archivos: Creamos un arrow function que nos retornara un callback con la respuesta.

deleteFile = (ruta, cb) => {
    // fs.unlink(ruta, (err) => {});
    // fs.unlink nos permite borrar archivos de una ruta en especifico.
    fs.unlink(ruta, cb);
}

Esto es cool

Se puede usar import en vez de require a partir de la versión nodejs >= 13.2.0.
Creo que es el estandard en el mundo javascript ahora para módulos.

Mi pequeño aporte usando Promises

const fs = require('fs').promises;

const readFile = async (route, fileName) => {
  return await fs.readFile(`${route}/${fileName}`, {encoding: 'utf8'});
};

const writeFile = async (route, fileName, content) => {
  return await fs.writeFile(`${route}/${fileName}`, content);
};

const deleteFile = async (route, fileName) => {
  return await fs.unlink(`${route}/${fileName}`);
};

const writeNewDataFile = async (newData) => {
  writeFile(__dirname, "archivo1.txt", `${newData} + NUEVA DATA`).then((data) => {
    console.log(`🔥 File has be writed`);
    deleteBeforeCreated();
  }).catch((err) => {
    console.error(`🥺 Error to writeFile file:\n${err}`);
  });
}

const deleteBeforeCreated = () => {
  setTimeout(() => {
    deleteFile(__dirname, "archivo1.txt").then((data) => {
      console.log(`🔥 File has be deleted`);
    }).catch((err) => {
      console.error(`🥺 Error to delete file:\n${err}`);
    });
  }, 2000);
}

const main = () => {
  readFile(__dirname, "archivo.txt").then((data) => {
    console.log(`🔥Data readed file:\n${data}`);
    writeNewDataFile(data);
  }).catch((err) => {
    console.error(`🥺 Error to read file:\n${err}`);
  });
}

main();

El módulo file system permite acceder a archivos del sistema, leerlos, escribirlos, modificarlos, etc.
Un módulo en node se puede traer o importar con const fs.
Lo que se ejecuta con file system nodeJS lo hace de forma asíncrona, esto se hace para poder ejecutar diferentes procesos. - read file permite leer archivos.

• writeFile permite escribir archivos
• unlink permite delinkar los archivos que se han creado en el mismo directorio.

hay Funciones para sacar estadísticas de archivos, para poder cambiar el nombre entre otras

codigo de la clase 😃

const fs = require("fs");

function leer(ruta, callback) {
  fs.readFile(ruta, (err, data) => {
    callback(data.toString());
  });
}

function escribir(ruta, contenido, callback) {
  fs.writeFile(ruta, contenido, function (err, data) {
    if (err) {
      console.error(" No he podido escribirlo ", err);
    } else {
      console.log(" Se ha escrito correctamente ");
    }
  });
}

function borrar(ruta, callback) {
  fs.unlink(ruta, callback);
}

https://nodejs.org/api/fs.html

// File system

// El sistema de archivos importante para requerir archivos externos.

const fs = require('fs');
// Aqui se forma la var fs con las propiedades de file system

function read(route, cb){
    fs.readFile(route, (err, data) => {
        console.log(data.toString());
    });
}

function write(route, content, cb) {
    fs.writeFile(route, content, function(err) {
        if(err) {
            console.err('Error, Check the code ', err);
        } else{
            console.log('It write correct');
        }
        return route;
    })
}

function deletee(route, cb) {
    fs.unlink(route, cb);
    console.log('it was delete')
}

async function writeReadDelete(route, content, cb){
await write(route, content);
await read(route);
setTimeout(((route, cb),() => {
    deletee(route, cb);
    console.log('XD')
}), 10000) ;
}

//writeReadDelete(__dirname + '/archivee.txt', 'New archive', console.log)
//write(__dirname + '/archivee.txt', 'New archive', console.log)
//read(__dirname + '/text.text')
//deletee(__dirname + '/archivee.txt', console.log)

Estas son las funciones de leer y escribir que defini con promesas:

const writeFile = async(path, contenido) => {
    try {
        await fs.writeFile(path, contenido);
    } catch (error) {
        console.error(error);
    }
};

const readFile = async() => {
    try {
        const file = await fs.readFile('./Fundamentos/modulos/archivo.txt', { encoding: 'utf-8' });
        console.log(file);
    } catch (error) {
        console.error(error);
    }

};

Podemos trabajar con archivos desde el file system, para ello necesitamos importar un módulo llamado fs y usarlo de la siguiente manera:

const fs = require('fs');

function read(route, callback) {
	fs.readFile(route, (err, data) => {
		console.log(data.toString());
	});
}

read(__dirname + '/file.txt')

Y para escribir un archivo podría ser:

function write(route, content, callback) {
	fs.writeFile(route, content, function (err) {
		if(err) {
			console.log("An error!");
		}
		else {
			console.log("Todo cul");
		}
	});
}

write(__dirname + "/file2.txt", "Soy un archivo nuevo")

etc…

//llamado del módulo file system (fs)
const fs = require('fs');

//para leer un archivo
function leer (ruta, callback){
    fs.readFile(ruta, (error, data) => {
        if(error){
            throw error;
        } else{
            console.log('Archivo encontrado....')
        }
        callback(data.toString());
    })
}

leer(__dirname + '/file.txt', console.log);

//escribir un archivo
function escribir (ruta, contenido, cb){
    fs.writeFile(ruta, contenido, function(error){
        if(error){
            console.log('No se pudo escribir', error);
        } else{
            console.log('Se escribió correctamente');
        }
    })
}

escribir(__dirname + '/archivo.txt', 'Soy un archivo nuevo \n', console.log);
escribir(__dirname + '/delete.txt', 'I will be deleted', console.log);

//borrar un archivo
function borrar (ruta, cb){
    fs.unlink(ruta, (error) => {
        if(error){
            console.log('No se pudo borrar', error);
        } else {
            console.log(ruta + ' Se borró correctamente');
        }
    });
}

//Borra el archivo despues de 5 segundos, nos permite ver el archivo
setTimeout(() => {
    borrar(__dirname + '/delete.txt', console.log);
}, 5000);

//añadir texto a un archivo existente
function añadir (ruta, addData, cb){
    fs.appendFile(ruta, addData, (error) =>{
        if (error) throw error;
        console.log('Texto añadido...');
    })
}

añadir(__dirname + '/archivo.txt', 'Texto añadido', console.log);

Realicé este ejercicio aplicando promesas, donde leo un archivo y eso que leo es lo que escribo.

Acepto correcciones y consejos.

const fs = require('fs');
var content;

//funcion para leer archivos
function leer(ruta, cb){
    return new Promise((resolve, reject)=>{
        fs.readFile(ruta, (err, data)=>{
            content = data.toString();
            resolve(data.toString());
        });
    });
}

//funcion para escribir archivos
function escribir(ruta, contenido){
    fs.writeFile(ruta, contenido, (err)=>{
        if(err){
            console.error('No se pudo escribir', err);
        }else{
            console.log('Se escribió el archivo');
        }
    });
}

//funcion para borrar archivos
function borrar(ruta, cb){
    fs.unlink(ruta, cb);
}

leer(__dirname + '/Archivo.txt')
    .then((content) =>{
        escribir(__dirname + '/Archivo3.txt', content);
        // console.log(content);
    }).then((content) =>{
        escribir(__dirname + '/Archivo3.docx', content);
        // console.log(content);
    })
    .then((content)=>{
        borrar(__dirname + '/Archivo3.docx', console.log);
    })
    .catch(error => {
        console.log('Ha salido un error: ');
        console.log(error);
    });

const fs = require('fs').promises;
async function writeFile(path, content){
    try{
        await fs.writeFile(path, content)
    }catch(err){
        console.error(err);
    }
}
writeFile(__dirname + '/file1.txt', 'Hola me acaban de crear', console.log)

Hola no me sirve la funcion para borrar el archivo

const fs = require('fs').promises;

const readFile = async() =>{
    const file = await fs.readFile('./archivo.txt',{ encoding: 'utf-8'});
    console.log(file);
}
readFile();

function escribir(ruta, contenido, callback){
    fs.writeFile(ruta, contenido, function (err){
        if(err){
            console.error('No he podido escribirlo', err)
        }else{
            console.log('se ha escrito un archivo correctamente');
        }
    });
}

escribir(__dirname + 'archivo1.txt','Soy un archivo nuevo', console.log)

function borrar(ruta, cb){
    fs.unlink(ruta);
}

borrar(__dirname + '/modulosarchivo1.txt', console.log)

Gracias a esta explicaccion pude comprender un poquito mas y que ganas de aprender mas sobre fyle system de node.

Les comparto mi codigo con algo de ingles para los que empiezan a medio entender pues se les sea mas legible, espero que les ayude.

const fs = require('fs');

// para leer
function read(ruta, cb) {
  fs.readFile(ruta, (err, data) => {
    cb(data.toString());
  });
}
// para escribir
function write(ruta, contenido, cb) {
  fs.writeFile(ruta, contenido, (err) => {
    if (err) {
      console.log('No he podido escribirlo', err);
    }
    else {
      console.log('Se ha escrito correctamente');
    }
  });
}
// para borrar un archivo
function borrar(ruta, cb) {
  fs.unlink(ruta, cb);
}

write(__dirname + '/archivo1.txt', 'Soy un archivo nuevo', console.log);
// read(__dirname + '/archivo.txt', console.log);
// borrar(__dirname + '/archivo1.txt', console.log);

Excelente explicacion

const fs = require(‘fs’);

function leer (ruta,cb){
fs.readFile( ruta,(err,data)=>{
console.log(data.toString());
})
};

function escribir(ruta,contenido,cb){
fs.writeFile(ruta,contenido,function(err){
if (err) {
console.log(‘no he podido escribirlo’,err);
}else{
console.log(‘se a escrito correctamente’);
}

});

}

function borrar(ruta,cb) {
fs.unlink(ruta,cb);
}
//leer(__dirname + ‘/archivo1.txt’)

//escribir(__dirname + ‘/archivo1.txt’,‘soy un archivo nuevo Y ME LEGO ESTO DEL FUTURO’,console.log);

borrar(__dirname + ‘/archivo1.txt’,console.log);

File System

Permite acceder a archivos del sistema. Cambiar, modificar y hacer distintas cosas con los archivos del sistema.

Los métodos usados en File System son de forma asíncrona.

Leer un archivo

const fs = require('fs')

function read(rute, cb) {
  fs.readFile(rute, (error, data) => {
    cb(data.toString())
  })
}

read(`${__dirname}/file.txt`, console.log)

Escribir un archivo

const fs = require('fs')

function write(rute, content, cb) {
  fs.writeFile(rute, content, (error) => {
    if (error) {
      console.error(`No se ha podido escribir el archivo, ${error}`)
    } else {
      console.log(`Se ha escrito correctamente`)
    }
  })
}

write(`${__dirname}/file1.txt`, `I'm a new file`, console.log)

Borrar un archivo

const fs = require('fs')

function deleter(rute, cb) {
  fs.unlink(rute, cb)
}

deleter(`${__dirname}/file1.txt`, console.log)

Hola compañeros, vengo a compartir el código en base al ejemplo del profesor, pero usando promesas y arrow-functions.

const fileSystem = require('fs').promises;
const ruta = __dirname;
const contenido = "Soy un archivo nuevo."

fileSystem.writeFile(ruta + "/texto.txt", contenido)
    .then(() => {
        return fileSystem.readFile(ruta + "/texto.txt");
    })
    .then((data) => console.log(data.toString()))
    .then(() => fileSystem.unlink(ruta + "/texto.txt"))
    .catch((err) => console.error(err));

Y la versión usando async y await es la siguiente.

const fileSystem = require('fs').promises;
const ruta = __dirname;
const contenido = "Soy un archivo nuevo."

const usingFs = async () => {
    try {
        await fileSystem.writeFile(ruta + "/texto.txt", contenido);
        const message = await fileSystem.readFile(ruta + "/texto.txt");
        console.log(message.toString());
        await fileSystem.unlink(ruta + "/texto.txt")
    }
    catch (error) {
        console.error(error)
    }
}

usingFs()

cuando usamos la opcion asincrona, bloqueamos el proceso principal del servidor

tomando en cuenta la forma de como se explicaron las promesas aqui dejo un ejemplo de como implementarlo

¿Como puedo crear archivos en node.js?

Este curso cada vez está increíble! nada que ver con el curso que había de node básico.

le hice con promesas y le mandamos en la funcion el nombre del archivo que queremos leer, crear o borrar

const fs = require('fs');

/* lee un archivo txt */
function leer(ruta, cb) {
    fs.readFile(ruta, (err, data) => {
        cb(data.toString());
    })
}

/* crea un archivo txt */
function escribir(ruta, contenido, cb) {
    fs.writeFile(ruta, contenido, function(err) {
        if (err) {
            console.error('No he podido escribirlo', err);
        } else {
            console.log('Se ha escrito correctamente');
        }
    });
}

/* borrar un archivo txt */
function borrar(ruta, cb) {
    fs.unlink(ruta, cb);
}


leer(__dirname + '/archivo.txt', console.log)
escribir(__dirname + '/archivo1.txt', 'Soy un archivo nuevo', console.log);
borrar(__dirname + '/archivo1.txt', console.log)

El módulo ‘fs’ viene por defecto asíncrono.

HE aquí mi código escrito!! Excelente clase!!

const fs = require('fs');
function leer(ruta, cb){
    fs.readFile(ruta, (error, data) => cb(data.toString()));
}
function escribir(ruta, contenido, cb){
    fs.writeFile(ruta, contenido, error => {
        error ? console.log('No se ha podido escribir...', error) : console.log('Escrito correctamente!!')
    })
}
function borrar(archivo, cb) {
    setTimeout(() => {
        fs.unlink(archivo, cb);
    }, 3000);
}
escribir(__dirname+'/archivo2.txt','Hola soy un archivo nuevo escrito con node JS', console.log);
leer(__dirname+'/archivo2.txt', console.log);
borrar(__dirname+'/archivo2.txt', console.log);

Muy interesante no sabia de esto, es genial!