Node.js FileSystem: Lectura/Escritura de archivos en Node.js

Clase 16 de 34 • Curso Básico de Node.js 2018

Resumen

El módulo del sistema de archivos de Node.js le permite trabajar con el sistema de archivos en su computadora. Para incluir el módulo de Sistema de archivos, use el método require ()

Jose Enrique Marquez

student•

Aca les dejo un ejemplo aplicando promesas y async await los terminos aprendidos en las clases anteriores.

const fs = require('fs');
const ops = require('./src/fileops');

const readFile = (path) => {
  return new Promise((resolve, reject) => {
    fs.readFile(path, 'utf8', (err, list) => {
      if (err) reject(err);

      resolve(list.split('\n'));
    });
  });
}

const writeFile = (path, value) => {
  return new Promise((resolve, reject) => {
    fs.writeFile(path, value, (err, list) => {
      if (err) reject(err);
      resolve(true);
    });
  });
}

const main = function() {
  readFile('./resources/number.txt')
    .then(async (res) => {
      const newNumbers = ops.incrementValues(res.map(n => Number(n)));
      const save = await writeFile('./resources/numbernew.txt', newNumbers)
      console.log(save);
    })
  .catch((err) => console.log(err));
}

main();

Jose Enrique Marquez

student•

Hay que prestar atencion donde se coloca el async cuando se quiere utilizar async await en el retorno de la promesa para utilizar el await es requerido ponerle async a la funcion then y no a la funcion princial para que no de error.

leonardo Oteca

student•

Te equivocaste de clase amigo

Juan Jose Rojas Rojas

student•

¿Entendieron el error que sucede en el minuto 15:35?

Eso se debe a que ambas funciones, readFile y writeFile, son asíncronas.

Freddy Córdova Arana

student•

Muchas gracias, me aclaraste la duda 😃

Mario Eduardo Contreras Serrano

student•

mmm… según yo es por el Scope de incValues.

Alejandro Oñate

student•

Creo que no era necesario el map esta linea:
const numbers = text.split("\n").map(n=>Number(n));
ya que el metodo incrementValues tiene el map para la conversion de string a numero:
(modulo fileops.js)
const mapIncrement = val => Number(val) + 1;

Jair Israel Avilés Eusebio

student•

Buena...

Carlos Enrique Ramírez Flores

student•

el comando **throw **detiene la ejecucion del codigo

Iván Toro

student•

throw

Kevin Alvarez

student•

Es solo para que sepas que en caso de error se lanzará una excepción que deberás capturar con un try-catch para el manejo de errores en tiempo de ejecución

Nathaly Stefani Riaño Bejarano

student•

✔ Ejercicio con Async/Await y ejecución en orden 😃:

const fs = require('fs')
const fileops = require('./src/fileops')

const resources = './resources'
const numberFilePath = `${resources}/number.txt`
const nameFilePath = `${resources}/name.txt`

function readFiles(path, encoding) {
    return new Promise((resolve, reject) => {
        fs.readFile(path, encoding, (err, data) => {
            if (err) throw err
            let arrData = data.split(/\r?\n/)
            resolve(arrData)
        })
    })
}

function writeFiles(path, list) {
    return new Promise((resolve, reject) => {
        fs.writeFile(path, list, (err, writeResult) => {
            if (err) throw err
            writeResult = 'Escritura exitosa'
            resolve(writeResult)
        })
    })
}

async function writeNumbers(readPath, writePath) {
    let readData = await readFiles(readPath, 'utf8')
    let incNumbers = fileops.incrementValues(readData).join('\n')
    await writeFiles(writePath, incNumbers)
        .then(result => console.log(`${result} de números`))
}

async function writeNames(readPath, writePath) {
    let readData = await readFiles(readPath, 'utf8')
    let callNames = fileops.callNames(readData).join('\n')
    await writeFiles(writePath, callNames)
        .then(result => console.log(`${result} de nombres`))
}

const executeExercise = async () => {
    await writeNumbers(numberFilePath, `${resources}/numberNew.txt`)
    await writeNames(nameFilePath, `${resources}/nameNew.txt`)
}

executeExercise()

Victor Gamez

student•

la verdad es que no se porque, pero poniendo la ruta relativa no me funcionaba...

Error: ENOENT: no such file or directory, open './resources/number.txt'

pero bueno, usandop __dirname ya lo ha cogido bien.

fs.readFile(`${__dirname}/resources/number.txt`, 'utf8', (err, text) => {
    if (err) throw err;

   // . . .
});

silvio reynaldo peña diaz

student•

me paso lo mismo (Y)

Raul Zarza

student•

me ha roto la cabeza ese problema por dos dias completos ... creo que tambien me funciono. Alguien me explica por que ?

Evert Escalante

student•

Esta clase fue el complemento perfecto para la unidad de Asincronia, creo que entendi alfin bien como son y funcionan las promesas y async-await 😄

Fileops.js

read: function (path, encoding) {
    const  lecture = new Promise ((resolve, reject) => {
      fs.readFile(path, encoding, (err, result) => {
        if(err) throw err;
        const date = result.split('\n');
        resolve(date); 
      })
    })

    return lecture
  },

  write: function (path, list) {
    const newFile = new Promise((resolve, reject) => {
      fs.writeFile(path, list, (err, result) => {
        if (err) throw err;
        result =  'Escritura Finalizada';
        resolve(result);
      })
    })

    return newFile;
  }

index.js - Promises

/promesa para leer y sobre escribir numeros en un nuevo archivo
ops.read(pathN, encoding)
	.then(numbers => {
		numbers = numbers.map(n => Number(n))
		incNumbers = ops.incrementValues(numbers)
		//console.log(numbers)
		return ops.write('./resources/newNumbers.txt', incNumbers.join('\n'));
	})
	.then(result => console.log(result))
	.catch(err => console.log(err))

//promesa para leer y sobre escribir nombres, cadenas en un nuevo archivo
ops.read(path, encoding)
	.then(names => {
		stringValues = ops.callNames(names);
		//console.log(stringValues);
		return ops.write('./resources/newsnames.txt', stringValues.join('\n'))
	})
	.then(result => console.log(result))
	.catch(err => console.log(err));

index.js - Async-await

function readFile (path) {
	 return new Promise ((resolve, reject) => {
	 	fs.readFile(path, encoding, (err, text) => {
	 		if (err) throw err;
	 		resolve(text);
	 		console.log('arcivo leido')
	 	})
	 })
}

function writeFile(path, values) {
	return new Promise ((resolve, reject) => {
		fs.writeFile(path, values, (err, res) => {
			if(err) throw err;
			console.log('arcivo escrito')
		})
	})
}

 async function writeNumbers() {
	const text = await readFile(pathN)
	const numbers = text.split('\n')
	const values = ops.incrementValues(numbers)
	await writeFile('./resources/newNubmers.txt', values.join('\n'))
}

async function writeNames () {
	const text = await readFile(path)
	const names = text.explit('\n');
	const values = ops.callNames(names);
	await writeFile('/resources/newNAmes.txt', values.join('\n'));
}

writeNumbers();
writeNames();

Evert Escalante

student•

Pd: me tomo 5 Horas entenderlo

Carlos Andres Castañeda Osorio

student•

Para completementar, la forma en la que debe ser escrito el módulo a importar dentro del require tambien se encuentra en la documentación, para el caso del File System se encuentra en la siguiente URL:
File System Node JS

Axel Vasquez

student•

Dato curioso Si solo queremos convertir un String a Number podemos solo usar "Number" en el map y hará lo mismo que hacer una función retornando el numero convertido

Ejemplo:

//	Esto
const numbers = text.split('\n').map(Number)
//	Es igual a  esto
const numbers = text.split('\n').map(n => Number(n))

De hecho funcionaria igual a la inversa, solo para considerar.

David Vargas Domínguez

student•

Usando promesas y async

const fs = require('fs')
const op = require('./src/fileops')

function readFile(path) {
    return new Promise(function (resolve, reject) {
        fs.readFile(path, 'utf-8', function(err, text) {
            
            if(err) reject(err)
            resolve(text)
            
            console.log('Archivo leído');
        })
    }) 
}


function writeFile(path, values) {
    return new Promise(function (resolve, reject) {
        fs.writeFile(path, values, (err, res) => {
            if (err) throw err
            console.log('Archivo escrito')
        })
    })
}


async function writeNumbers() {
    const text = await readFile('./resources/number.txt')
    const numbers = text.split('\n')
    const values = op.incrementValues(numbers)
    await writeFile('./resources/numbernew.txt', values.join('\n'))
}

async function writeNames(pathToRead, PathToWrite) {
    const text = await readFile(pathToRead)
    const names = text.split('\n')
    const values = op.callNames(names).join('\n')
    await writeFile(PathToWrite, values)
}

// writeNumbers()
writeNames('./resources/name.txt', './resources/greetwithnames.txt')

Alvaro Javier Fernandez Solano

student•

Tengo una pregunta porque no funciona si el lambda de mapIncrement se pone entre llaves?

incrementValues: function(list) { const mapIncrement = (val) => { Number(val) + 1; }; return list.map(mapIncrement); },

devuelve puros undefined

Carlos Martinez

student•

es debido a que es una arrow function, por ello debes de poner return cuando pones llaves {} ya que si no lo haces es como si retornaras nada

// si quieres retornar, asi no sirve
const mapIncrement = (val) => {
Number(val) + 1;
};

// tendría que ser asi:
const mapIncrement = (val) => {
return Number(val) + 1;
};

// o con parentesis en vez de llaves allí no hace falta la palabra return 
const mapIncrement = (val) => (
    Number(val) + 1
);

Sergui Morejón

student•

Aquí les dejo el ejercicio de los nombres 😃

fs.readFile('./resources/name.txt', "utf8", function(err, namesList){
    if(err) throw err
    names = namesList.split("\n");
    var greet = ops.callNames(names)
    fs.writeFile('./resources/name.txt', greet.join('\n'), function(err, result){
        if(err) throw err;

        console.log('Writed Succesfully')
    })
})

// Usando async-await

function readNames(path){
    return new Promise(function(resolve, reject){
        fs.readFile(path, "utf8", function(err, namesList){
            if(err) reject(err);
            var res = namesList.split("\n")
            resolve(res)
        })
    })
}

function writeNames(path, value){
    return new Promise(function(resolve, reject){
        fs.writeFile(path, value, function(err, namesList){
            if(err) reject(err);

            resolve(console.log('Writed Succesfully'))
        })
    })
}

function main(){
    readNames('./resources/name.txt')
    .then(function(res){
        var names = ops.callNames(res);
        writeNames('./resources/name.txt', names.join("\n"))
    }).catch(function(err){
        console.log(err);
    })
}

main();

Jordi Santamaría Portolés

student•

La primera vez que veo convertir string a number sin usar parseInt xD

Eden Rodrigo Verdugo Garcia

student•

const fs = require("fs")
const ops = require("./src/fileops")

async function leerArchivo(path){
    return new Promise((resolve, reject) => {
        fs.readFile(path, 'utf8', (err, data) => {
            if(err) reject(err)

            resolve(data)
        })
    })
}

async function escribirArchivo(path, data) {
    return new Promise((resolve, reject) =>{
        fs.writeFile(path, data, (err, result) => {
            if(err) reject(err)

            resolve(result)
        })
    })
}

(async () => {
    let datos = await leerArchivo('./resources/name.txt')

    datos = datos.split('\n').map(item => String(item))
    
    const lst = ops.callNames(datos).join('\n')
    
    let result = await escribirArchivo('./resources/hola-name.txt', lst)

    console.log(result)
})()

Leobannys Urdaneta

student•

Bueno experimentando viendo los comentarios y clases anteriores lo implemente de una forma tratando de colocar menos lineas de codigo en el index.js, para empezar cree un archivo llamado functions.js en el src que tiene lo siguiente:

const fs = require("fs");
module.exports = {
    /**
     * 
     * @param {string} path 
     * @param {String} options 
     */
    leerArchivo: async function (path, options) {
        options !== undefined ? options : '';
        return new Promise((resolve, reject) => {
            fs.readFile(path, options, (err, data) => {
                if (err) reject(err);
                resolve(data);
            });
        });
    },
    /**
     * 
     * @param {string} path 
     * @param {*[]} data 
     */
    escribirArchivo: async function (path, data) {
        return new Promise((resolve, reject) => {
            fs.writeFile(path, data, (err, results) => {
                if (err) reject(err);
                resolve(results);
            });
        });
    }
}

y luego de esto los llame en el index.js, a continuación mi index.js:

const fnc = require('./src/functions');
const ops = require('./src/fileops');

let formatNumbers, incValues, formatNames, cNames;

(async () => {
    const numbers = await fnc.leerArchivo("./resources/number.txt", "utf8");
    formatNumbers = numbers.split("\r\n").map(n => Number(n));
    incValues = ops.incrementValues(formatNumbers);
    fnc.escribirArchivo("./resources/numbernew.txt", incValues.join("\n"));

    const names = await fnc.leerArchivo("./resources/name.txt", "utf8");
    formatNames = names.split("\r\n");
    cNames = ops.callNames(formatNames);
    fnc.escribirArchivo("./resources/namesformat.txt", cNames.join("\n"));
    
})();

Ernesto Vizcaíno Alvarado

student•

Aqui esta mi solucion al reto

const fs = require("fs");
const ops = require("./src/fileops");

fs.readFile("./resources/name.txt", "utf8", (err, text) => {
  if (err) throw err;
  const names = text.split("\n");
  shwNames = ops.callNames(names);
  fs.writeFile("./resources/namesnew.txt", shwNames.join("\n"), err => {
    if (err) throw err;
  });
});

Luis Donaldo Lopez Gil

student•

function readFile(path) {
    return new Promise(function (resolve, reject){
        fs.readFile(path, "utf8",(err, texto) => {
            if (err) throw err
            resolve(texto)
        })
    })
}

function writeFile(path, data) {
    return new Promise(function (resolve, reject) {
        fs.writeFile(path,data,(err, res) => {
            if (err) throw err
            console.log("Success");
        })
    })
}
async function saludar() {
    nombres = await readFile("./resources/name.txt")
    nombres = ops.callNames(nombres.split("\n"))
    writeFile("./resources/newName.txt", nombres.join("\n"))
}

saludar()```

Deyvis Neyser Valdez Gavilan

student•

Hola, comparto mi código del reto:

let nomValue;

const data = (err, text) => {
    if(err) throw err;
    const nombres = text.split("\n")
    nomValue = ops.callNames(nombres)

    fs.writeFile("./resources/namenew.txt", nomValue.join("\n"), (err, result) => {
        if(err) throw err;
    })
}

fs.readFile("./resources/name.txt", "utf8", data)

Aarón González

student•

¡Excelente! Funciona al 100%

Pedro Roberto Capriles Morales

student•

Cumpliendo con el reto se utiliza la función callNames

fs.readFile("./resources/name.txt","utf8",(err,text)=>{
    if(err) throw err;

    const names = text.split("\n").map(n=> n.trim());

    const greetingList = ops.callNames(names);
    fs.writeFile(
        "./resources/callNames.txt",
        greetingList.join("\n"),
        (err, result) =>{
            if(err) throw err;
        }
    );
})

Resultado

Ernesto Truyen

student•

const fs = require('fs');
const ops = require('./src/fileops');

function leerArchivo(){
    return new Promise((resolve,reject)=>{
        fs.readFile('./resources/name.txt','utf8',(err,data)=>{
            if(err) throw err;
            let content = ops.callNames(data.split('\n'));
            resolve(content);
        });
    });
}

function crearArchivo(text){
    return new Promise((res,rej)=>{
        fs.writeFile('./resources/newNames.txt', text.join('\n') ,(err,data)=>{
            if(err) throw err;
            res(true);
        });
    });
}


async function crearArchivoConNombresCompuestos(){
    const contenidoDoc1 = await leerArchivo();
    const contenidoDoc2 = await crearArchivo(contenidoDoc1);
}

crearArchivoConNombresCompuestos();

César Espitia

student•

Excelente algoritmo!!! Muchas gracias por comparitr. 👍

Node.js FileSystem: Lectura/Escritura de archivos en Node.js

Introducción al curso

¿Dónde aprender Node.js actualizado?

Todo lo que aprenderás sobre node.js

Aspectos generales de Node.js

Introducción a Node.js

Historia de Node.js

Preparación del entorno de trabajo

Creación de máquina virtual de trabajo

Instalación de recursos de proyecto en MacOSX

Instalación de recursos de proyecto

Clonación de repositorio del curso

Gestión de proyectos con Node y NPM

Introducción a Node.js: CLI y REPL

Creación de proyectos de Node.js con NPM

Módulos en Node.js: require() y module.exports

Manejando modulos externos con NPM y require()

Asincronismo en Node.js

Fundamentos de asincronismo con Node.js

Callbacks y Promesas: Casos de estudio

Hacia el futuro: asincronismo con Async/Await

Módulos nativos básicos de Node.js

Node.js FileSystem: Lectura/Escritura de archivos en Node.js

Node.js Readline: Introducción de datos por terminal

Node.js Child Process: Ejecución de subprocesos con Node.js

Node.js Debugger: Depuración de código en Node.js

Node.js Errors: Manejo de errores en Node.js

Node.js Events: Emisión y recepción de eventos en Node.js

Servicios web en Node.js con Express.js

Introducción al protocolo HTTP

Creación de un servidor web básico con HTTP

Creación de un servidor web con Express.js

Construcción de un API con Express.js

Servicios de datos en Node.js con MongoDB

MongoDB: Conexión y escritura de datos con Node.js

Completando nuestro API con MongoDB

Aplicaciones Real-Time en Node.js con Socket.io

Bienvenido a la sección del Proyecto del Curso

Introducción a Socket.io y proyecto de curso

Presentación del proyecto final: Tic-tac-toe

Bases y fundamentos del proyecto final: Tic-tac-toe

Desarrollo del Proyecto final del curso: Tic-tac-toe

Finalizando el proyecto final del curso: Tic-tac-toe

Conclusiones

Consideraciones finales