No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

File system

12/31
Recursos

Aportes 91

Preguntas 23

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

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:


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

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

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

😱 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 😢

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!

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

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 👀

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

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.

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

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.

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

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)

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');
    }
})

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.

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

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

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

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

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

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: “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);
    }
});> 

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.js

main.js

Gestionar archivos del sistema tenemos a File system

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!

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.
(‘fs’): 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);

Wow, esto se pone más bueno!!! Excelente!!!

Genial 😄

Excelente clase!! Ya lo habia usado sin saber que hacia

jeje

const fs = require('fs');

function Read(ruta, callback) {
    fs.readFile(ruta, (error, data) => {
        if (error) {
            console.log("la lectura del archivo fallo");
        } else {
            console.log(data.toString());
            if (callback) {
                callback();
            }
        }

    })
}

function Write(ruta, content, callback) {
    fs.writeFile(ruta, content, (error) => {
        if (error) {
            console.log("no se produjo el cambio");
        } else {
            if (callback) {
                callback();
            }

        }
    })
}

Write(`${__dirname}/prueba.txt`, 'soy matias antes', () => {
    Read(`${__dirname}/prueba.txt`, ()=>{
        Write(`${__dirname}/prueba.txt`, 'soy matias despues', () => {
            Read(`${__dirname}/prueba.txt`);
        })
    })
});

Es recomendable trabajar de forma asincrona, para no saturar el hilo principal

Es importante recordar la sintaxis de una promesa mientras las escribimos
cb es la siguiente acción después de

function leer(ruta, cb) { //cb es el anuncio de que terminamos de ejecutar la funcion
  fs.readFile(ruta, (err, data) => { //aqui el contenido de esta funcion anonima es el que nos dice que termino
    //archivo leído 
    cb(data.toString()) //activa el callback y manda un dato y termina la funcion callback
  })
}

leer(__dirname + '/file.txt', data => console.log(data)) //aqui vemos como la funcion callback contiene solo un console.log y lo ejecuta

Entonces aquí, ese console.log qué pone cuando manda llamar la función qué tarea ejecuta o en qué caso más bien?

Excelente clase. Mis respetos para este profe.

Para poder poder probar todas las funciones, Emprese escribiendo, luego leyendo, y con la funcion

setTimeout()

… la usé para para borrar, y luego para volver a leer algo que ya no existe para causar un error controlado:

const fs = require('fs');

const read = (ruta,callback)=>{
    fs.readFile(ruta,(err,data)=>{
        (data)
        ?callback(data.toString())
        :callback("The file doesn't exist");
    })
}

const write = (ruta, contenido,callback) =>{
    fs.writeFile(ruta, contenido, (err)=>{
        (!err)
           ?callback('File created!')
           :callback(`I  didn´t can write it :c ${err}`); 
    })
}

const drop = (ruta,callback) =>{
    fs.unlink(ruta, (err)=>{
        (!err)
            ?callback("Drop it successfully")
            :callback(`I didn´t can drop it :c ${err}`)
    });
}

write(__dirname + '/archivo1.txt', 'I´m a new file!',console.log); 
read(__dirname + '/archivo1.txt',console.log);

setTimeout(()=>{
    drop(__dirname + '/archivo1.txt',console.log);
},1200)

setTimeout(()=>{
    read(__dirname + '/archivo1.txt',console.log);
}, 1500)

Consola:

Aquí mi pequeño aporte. Hago una petición a la API de Rick and Morty y guardar en mi directorio la respuesta a esa petición.

const fetch = require('node-fetch'); 
const fs = require('fs');

const URL_API = 'https://rickandmortyapi.com/api/character';

const getDataApi = async(url) => {
    try {
        const response = await fetch(url);
        const data = await response.json();
        const results = JSON.stringify(data);
        fs.writeFile('files/apiRick-Morty.json', results, (err) => {
            if (err) throw err
        });
    } catch (error) {
        console.error(`Ha habido un error de consulta a ${url}, ${error}`)
    }
};

getDataApi(URL_API);

file system --> fs

writefile

Apuntes que pueden ser utiles

/*
  Trabajando con File system
*/

const fs = require('fs');

/*
  Leer un archivo con fs.
  fs funciona de manera asincrona,
  todos los metodos tienen una alternativa sincrona, la cual
  no es recomendada ya que durante ese tiempo de proceso
  se bloquea el hilo principal.

  La funcion readFile recibe dos parametros,
  1. La ruta de donde quiero leer el archivo
  2. El callback, el cual recibe los sgtes argumentos
    1. Un error.
    2. La data.
*/

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

/*
  Escribir en un achivo con fs.
  La funcion writeFile, recibe dos parametros.
  1. La ruta donde quiero escribir el archivo.
  2. El contenido.
  3. un callback (opcional)
*/

function escribir(ruta, content, fn){
  fs.writeFile(ruta, content, function(err){
    if(err){
      console.error('No se ha podido escribir en el archivo', err);
    } else {
      console.log('El archivo se ha escrito correctamente');
    }
  });
}

/*
  Eliminar un archivo con fs.
  La funcion unlink recibe dos parametros.
  1. La ruta.
  2. callback (opcional)
*/

function eliminar(ruta, fn){
  fs.unlink(ruta, fn);
}

leer(__dirname + '/file.txt', console.log);
escribir(__dirname + '/file1.txt', 'Escribiendo un archivo con fs, genial', console.log);
eliminar(__dirname + '/file.txt', console.log);```

Código de la clase 😃
PD: Realizado con Carbono

😃

Usando fs con las diferentes maneras que hay:

const fs = require('fs')
const fsAsync = require('fs/promises')

const PATH_NAME = (__dirname+'/hi.txt')

// Sync
try {
  let res = fs.readFileSync(PATH_NAME)
  console.log(res.toString())
} catch (error) {
  console.log(error);
}

// Callback
fs.readFile(PATH_NAME, (err, data) => {
  if(err) throw err
  console.log(data.toString());
})

// Promise
fsAsync.readFile(PATH_NAME)
  .then(res => {
    console.log(res.toString());
  })
  .catch(err => {
    console.log(err);
  })

// Async/Await
;(async (path) => {
  try {
    let res = await fsAsync.readFile(path)
    console.log(res.toString())
  } catch (error) {
    console.log(error)
  }
})(PATH_NAME)

Alguien me puede decir xq ese console no se muestra?:
const fs = require(‘fs’).promises;\n
async function Leer(ruta) {\n
console.log(‘Porque esto si se muestra’);\n
const file = await fs.readFile(ruta, ‘utf8’, (err, data) => {\n
if (err) throw err;\n
console.log(‘xq no se muestra este texto en consola?’);\n
});\n
console.log(‘Porque esto tambien se muestra’);\n
}\n
Leer(__dirname + ‘/archivo.txt’)\n

Excelentes funcionalidades, mucho en poquito tiempo

woooooooo!
ya me siento como un hacker con esta clase
😎

Mi segundo aporte:

fileSystem.js

const fs = require('fs');
const contenido = `Hola, soy un nuevo archivo


y tengo varias líneas`;

function leer(ruta, cb) {
    return new Promise((resolve, reject)=>{
        fs.readFile(ruta, 'utf-8', (err, success) => {
            if (err) {
                reject(err);
            } else {
                cb(success);
                resolve(success);
            }
        });

    })
}


function escribir(ruta, contenido, cb) {
    return new Promise((resolve, reject)=>{
        fs.writeFile(ruta, contenido, function (err){
            if (err) {
                reject(err);
            } else {
                cb('Escritura realizada correctamente');
                resolve();
            }
        });
    });
}

function borrar(ruta, cb) {
    return new Promise((resolve, reject)=>{
        fs.unlink(ruta, (err) => {
            if (err) {
                reject(err);
            } else {
                cb('Borrado realizado correctamente');
                resolve();
            }
        });
    });
}

async function main(path) {
    await escribir(path, contenido, console.log);
    await leer(path, console.log);
    await borrar(path, console.log);
    console.log('Termina el proceso');
}

console.log('Empieza el proceso');
main(__dirname + '/archivo1.txt');

Excelente clase, simplicidad para dar a entender conceptos claves-(el profesor “Super recomendado!”)

//import fs from 'fs';
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.log("No he podido escribir", err);
        }
        else {
            console.log('Se ha escrito correctamente');
        }
    });
}

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

Qué extensiones usa en visual studio code para node.js? Muchas gracias