No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

File system

12/31
Recursos

Aportes 124

Preguntas 25

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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: 鈥淚nterfaz 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:


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(鈥榝s鈥);
    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)
<h1>File system</h1>

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.

鈥淯se 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

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!

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 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(鈥榝s鈥). Require en si es un modulo que se encarga de cargar dinamicamente modulos de JS. Ser铆a como Thanos diciendo 鈥渦se 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 鈥渦tf8鈥 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.

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.

Un aportesito gracias a mi amigo chatGpt, 鉂わ笍

Le pregunt茅 por qu茅 la funci贸n de borrar se llama 鈥榰nlink鈥 y no 鈥榙elete鈥 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 鈥榰nlink鈥 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!

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(鈥榝s鈥);

// 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 鈥渞equiere鈥 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)

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

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

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: 鈥榓鈥檥

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

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 鈥渇s鈥;

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

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

/*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: 鈥淚nterfaz 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

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

Use la versi贸n con asyn/await

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)

馃幈 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)

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.

Es verdad, si puedes realizar los ejercicios con promesas:

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);
}
// 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 aadir (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(鈥榝s鈥);

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(鈥榥o he podido escribirlo鈥,err);
}else{
console.log(鈥榮e a escrito correctamente鈥);
}

});

}

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

//escribir(__dirname + 鈥/archivo1.txt鈥,鈥榮oy 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 鈥榝s鈥 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!

unlink

Como no ten铆a claro que era require vi la documentaci贸n y pude extraer esto:

const fs = require('fs');

require(): M贸dulo (no es un global) usado para importar m贸dulos, JSON y archivos locales. Acepta como argumento el nombre del modulo o ruta.
(鈥榝s鈥): Nos aprovisiona de una API para interactuar con archivos de sistema

const fs = require('fs')

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

//leer(`${__dirname}/archivo1.txt`,console.log)

function escribir (ruta,contenido,callback){
    fs.writeFile(ruta,contenido, function (err){
        if(err){
            console.error('Ha ocurrido un error:',err)
        }else{
            console.log('se ha escrito correctamente')
        }
    })
}

//escribir(`${__dirname}/archivo1.txt`, 'soy un archivo nuevo')

function borrar(ruta){
    fs.unlink(ruta,function(){
        console.log('archivo eliminado correctamente')
    })
}

borrar(`${__dirname}/archivo1.txt`)```

readfile

const fs = require('fs');

function leer(ruta,callback) {

    fs.readFile(ruta,(err,data)=>{
        //ya se ley贸 el archivo
        console.log(data.toString());

    })
}


function escribir(ruta,contenido,callback) {
    
    fs.writeFile(ruta,contenido,function (err){

        //esta funcion es el callback
        if (err) {
            console.log('No se ha podido escribir archivo')
        }else{
            console.log('Se escribio archivo correctamente')
        }
    });
}

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



//leer(__dirname+'/archivo.txt',console.log);
//escribir(__dirname+'/archivo.txt',"estoy escribiendo en un archivo :D",console.log);
borrar(__dirname+'/archivo.txt',console.log);