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

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

Contenido del curso

Introducción al curso

Aspectos generales de Node.js

Preparación del entorno de trabajo

Gestión de proyectos con Node y NPM

Asincronismo en Node.js

Módulos nativos básicos de Node.js

Servicios web en Node.js con Express.js

Servicios de datos en Node.js con MongoDB

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

Conclusiones

34
Consideraciones finales
02:20 min

Tomar examen

Resumen

El módulo Readline proporciona una forma de leer un flujo de datos, una línea a la vez. En este enlace podrás ver la documentación: https://nodejs.org/dist/latest-v10.x/docs/api/readline.html

Comentarios

Jose Enrique Marquez

student•

Agrego el codigo de la clase.

const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

const q = [
  'Cual es tu primer nombre? ',
  'Cual es tu primer apellido? ',
  'Cual es tu edad? '
];

const AskQuestion = (rl, question) => {
  return new Promise((resolve, rej) => {
    rl.question(question, answer => {
      resolve(answer);
    });
  });
}

const Ask = (questions) => {
  return new Promise(async resolve => {
    let results = [];
    for (let i=0; i < questions.length; i++) {
      const result = await AskQuestion(rl, questions[i]);
      results = [...results, result];
    }
    rl.close();
    resolve(results);
  });
}

Ask(q)
  .then(q => {
    console.log(`Hola ${q[0]} ${q[1]}, tu edad es la siguiente: ${q[2]}`);
  })

RAMIRO JHONATAN TORREJON CASTRO

student•

¿Saben si es igual, o por que el uso de promesa en la function Ask?

También funciona de esta forma:

const ask = async questions => {
  let results = []
  for (let question of questions){
    const result = await askQuestion(rl, question)
    results.push(result);
  }
  rl.close()
  return results;
}

(async function() {
  const greeting = await ask(q);
  console.log(`Hola ${greeting[0]} ${greeting[1]}, tu edad es la siguiente ${greeting[2]}`)
})();

Sergio Armando Velasco Guzmán

student•

Rajho, creo que basicamente es lo mismo, solo que para mi, se ve mas ordenado y es mas entendible el uso de las promesas

Efrén Sánchez

student•

🐄 Cowsay :

Copia el código y pégalo en tu index.js
En la terminal: npm install cowsay y node index 😛😛

const cowsay =  require ('cowsay');
const readline = require ('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

console.log(cowsay.say({
  text: "hello! I can <sleep>, <mocking> or <died>",
  e: "0 0",
  T: " "
}));
console.log('*************************');

rl.question('What I do?: ', (answer) => {

  if (answer == 'sleep') {
    console.log(cowsay.think({
      text: "z Z z Z z",
      e: "- -",
      T: ""
    }));
    console.log('*************************');
  }
  else if (answer == 'died') {
    console.log(cowsay.say({
      text: " ......... ",
      e: "XX",
      T: "U"
    }));
    console.log('*************************');
  }
  else if (answer == 'mocking') {
    console.log(cowsay.say({
      text: "Ha ha ha!",
      e: "oO",
      T: " U"
    }));
    console.log('*************************');
  }
  else{
    console.log(cowsay.say({
      text:`I can't ${answer} \n Thank you for nothing`,
      e: "o <",
      T: ""
    }));
    console.log('*************************');
  }

  rl.close();
});

Jair Israel Avilés Eusebio

student•

LOL muy divertido

Gerardo Manuel Reyes Fernández

student•

Un for un poco más descriptivo

for (let question of questions) {
            const result = await AskQuestion(rl, question);
            
           results.push(result)

        }

Carlos Andres Castañeda Osorio

student•

El código usando una función async, await en lugar de usar el .then()

const readline = require('readline')

 const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
 })

const q = [
    '¿Cual es tu primer nombre?',
    '¿Cual es tu primer apellido?',
    '¿Cual es tu edad?'
]

const askQuestion = (rl, question) => {
    return new Promise((resolve, reject) => {
        rl.question(question, (answer)=> {
            resolve(answer)
        })
    })
}

const ask = function(questions){
    return new Promise(async resolve => {
        let results = []
        for(let question of questions){
            const result = await askQuestion(rl, question)
            results.push(result)
        }
        rl.close()
        resolve(results)
    })
}

async function obtenerRespuestas (preguntas) {
    const results = await ask(preguntas)
    console.log(results)
}

obtenerRespuestas(q)

Carlos Bueno Tavares

student•

tengo el codigo exactamente y no me funciona solo se me ejecuta el .then con hola undefinden unde...

Ivan Alex Omonte Carreño

student•

Asegúrate que el callback esté bien definido.

Deyvis Neyser Valdez Gavilan

student•

Hola Bloodysi, compártenos tu código para poder ayudarte. Saludos.

Fernando Alejandro Yerena Ramos

student•

¿Cuál puede ser la razón por la que no itere en el arreglo usando array.map? Al reescribir la función ask para utilizar array.map en lugar de for, la función solo me muestra la primera pregunta, al responder no me muestra la segunda, pero me permite seguir escribiendo.

const ask = (q) => 
{
    let results = [];

    return new Promise(async resolve =>
    {
        await Promise.all(
            q.map(async (item) =>
            {
                let result = await askQuestion(rl, item);
                results.push(result)
            })
        ).then(() =>
        {
            resolve(results);
            rl.close();
        });
    })
};

Agregué un un console.log() y si llega a hacer el .push. Pero no itera al resto del arreglo.

Edward Steven Ramos Palacios

teacher•

Tienes que decidir si usar promesas con .then o si vas a usar async/await veo que el await de la linea 30 esta sobrando.

Jose Enrique Marquez

student•

a Falta de enlace yo lo agrego

Jose Enrique Marquez

student•

ojo con la version 10.x de node

Carlos Enrique Ramírez Flores

student•

que tantas diferencias hay entre v8 y 10?

Ivan Cardozo

student•

const readLine = require(“readline”);

const rl = readLine.createInterface({
input: process.stdin,
output: process.stdout
});

const q = [
"Cual es tu primer nombre? ",
"Cual es tu primer apellido? ",
"Cual es tu edad? ",
];

const askQuestion = (rl, question) => {
return new Promise((res, rej) => {
rl.question(question, answer => {
res(answer);
});
});
}

const ask = function(questions) {
return new Promise(async resolve => {
let results = [];
for(let i = 0; i < questions.length; i++) {
const result = await askQuestion(rl, questions[i]);

        results.push(result);
    }
    rl.close();
    resolve(results);
 })

}

ask(q)
.then(q => {
console.log(Hola ${q[0]}${q[1]}, tu edad es la siguiente: ${q[2]});
});

Noe Mikhael Huaccharaque Ruiz

student•

Yo tambien repeti mi primer apellido :)

Victor Gamez

student•

una pregunta urgente... Porque este codigo si funciona:

const AskQuestion = (rl, question) => {
    return new Promise((resolve, rej) => {
        rl.question(question, answer => {
            resolve(answer);
        });
    });
}

y este no

const AskQuestion = async (rl, question) => {
    return await rl.question(question);
}

Evert Escalante

student•

const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
})

const q = [
  
  'Cual es tu primer nombre ?  ',
  'Cual es tu primer apellido ? ',
  'Cual es tu edad ? '
];

/*esta funcuion permite usar la interfaz, para imprimir una pregunta en la consola
asi mismo, se queda esperando por la respuesta, cuando la obtiene la guardamos en resolve*/
const AskQuestion = (rl, question) => {

  return new Promise ((resolve, reject) => {
    rl.question(question, answer => {
      resolve(answer);
    })
  })
} 

/*Esta funcion recibe la interfaz,  una lista de preguntas, luego retornara una nueva promesa
esta usa async,  dentro de esa lista de preguntas vamos a iterar con un for
luego  usaremos await para llamar a  AskQuestion entonces,
no pasara a la siguiente promesa hasta que esta se resuelva si o si
finalmente ponemos  el resultado en results*/
const Ask = function (questions) {

  return new Promise (async resolve => {
    let results = [];

    for (let i = 0; i < questions.length; i++) {

      const result = await AskQuestion(rl, questions[i]);
      results.push(result);
    }

    rl.close();

    resolve(results);

  })
}

//puedes resolverlo con then 
Ask(q)
  .then(q => {
    console.log(`Hola ${q[0]} ${q[1]}, tu edad es ${q[2]} años humanos y `;)
  })


/*puedes resolverlo con  async await
async function Getanswers(questions) {
  const results = await Ask(q);
  console.log(results)
}

Getanswers(q);
*/```

Nathaly Stefani Riaño Bejarano

student•

Gracias, me ayudaste a entender mejor éste tema 👍

Juan Sebastián Joya Rodríguez

student•

te cuento que en console.log final, pusiste mal el ; y no queria compilar jejeje,

Emilio Jose Ugeda Sanoja

student•

const readline = require('readline');
const rl= readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

const q = [
    "¿Cual es tu primer nombre? ",
    "¿Cual es tu primer apellido? ",
    "¿Cual es tu edad? ",
    "¿Pais de origen? ",
    "¿Cual es tu habilidad? ",
    "¿Color fvorito? "
];

const AskQuestion = (rl, question)=>{
    return new Promise((resolv)=>{
        rl.question(question, answer =>{
            resolv(answer)
        });
    });
}

const Ask = function(questions){
    return new Promise(async resolv=>{
        let resultados = [];
        for(let i = 0; i < questions.length; i++){
            const resultado = await AskQuestion(rl,questions[i]);
            resultados.push(resultado)
        };
        rl.close()
        resolv(resultados)
    });
};
Ask(q)
.then(q=>{
        console.log(`Hola mi nombre es ${q[0]} ${q[1]}, tengo ${q[2]} años de edad, nací en ${q[3]}, mi habilidad es "${q[4]}" y mi color favorito es el ${q[5]}`)
    });

César Espitia

student•

Por acá dejo mi código

const readline = require('readline')
const interface = readline.createInterface({
    input: process.stdin,
    output: process.stdout
})
const questions = [
    "What's your first name? ",
    "What's your last name? ",
    "What's your age? "
]

const askQuestion = (inter, quest) => {
    return new Promise((res) => {
        inter.question(quest, (answer) => {
            res(answer)
        })
    })
}

const ask = (questions) => {
    return new Promise(async (res) => {
        let result = []
        for (let index = 0; index < questions.length; index++) {
            const response = await askQuestion(interface, questions[index])
            result.push(response)
        }
        interface.close()
        res(result)
    })
}

ask(questions).then((question) => {
    console.log(`Hey ${question[0]} ${question[1]}! Your age is ${question[2]}`)
})

Edith Hernández Navarrete

student•

Gracias, Me funcionó!!

Juan Pablo Cabero Carrasco

student•

Reto Nro.2: Uso de modulo "readline" "process"

Gerardo Solis Valenzuela

student•

const readline = require('readline')

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
})

const questions = [
  'Cual es tu primer nombre? ',
  'Cual es tu primer apellido? ',
  'Cual es tu edad? '
]

const askQuestions = question => new Promise(resolve => rl.question(question, resolve))

const ask = async questions => {
  const answers = []
  for await (let question of questions) {
    const answer = await askQuestions(question)
    answer.push(answer)
  }
  rl.close()
  return answers
}

ask(questions).then(console.log)

Iván Toro

student•

Muy util para crear módulos de desarrollo.

IRVING ALAMO GARCIA

student•

Está muy bien todo, solo que creo que hace falta hacer un poco de zoom a la grabación de los videos porque en pantallas pequeñas se batalla bastante. Las letras se ven muuuy pequeñas.

Henry Corredor

student•

Me puse a jugar un poco con este módulo para entenderlo mejor, por eso hice este código usando algo de lo aprendido en Jquery a JS, se los comparto:

const manejador = require('readline');

(async function preguntar(){

    const formulario = manejador.createInterface({
        input: process.stdin,
        output: process.stdout
    })

    await formulario.question('Cómo quieres que te llame: ', respuesta =>{
        console.log(`${respuesta} mi amor, ¿cómo estás?`)
        formulario.close()
    })
})()```

Platzi Team

student•

Hola , para los que quieran entender un poco mas les dejo el link de la documentación.

Carlos Enrique Ramírez Flores

student•

tu estas trabjando con la 11?

Walter Lensinas

student•

Me sale repetida la pregunta en la terminal 😦

Terminal:

test@test-VirtualBox:~/Desktop/nodejsbasico$ node index.js
Cual es tu primer nombre? test
Cual es tu primer nombre?
Cual es tu primer apellido? test
Cual es tu primer apellido?
Cual es tu edad? 1111
Cual es tu edad?
Hola test test, tu edad es la siguiente: 1111
test@test-VirtualBox:~/Desktop/nodejsbasico$

Código:

const readLine = require("readline");
 
const rl = readLine.createInterface({
    input: process.stdin,
    output: process.stdout
});
 
 const q = [
     "Cual es tu primer nombre? ",
     "Cual es tu primer apellido? ",
     "Cual es tu edad? ",
 ];
 
 const askQuestion = (rl, question) => {
     return new Promise((res, rej) => {
        rl.question(question, answer => {
            res(answer);
        });
     });
 }
 
 const ask = function(questions) {
     return new Promise(async resolve => {
        let results = [];
        for(let i = 0; i < questions.length; i++) {
            const result = await askQuestion(rl, questions[i]);
            console.log(questions[i]);
            results.push(result);
        }
        rl.close();
        resolve(results);
     })
 }
 
 ask(q)
    .then(q => {
        console.log(`Hola ${q[0]} ${q[1]}, tu edad es la siguiente: ${q[2]}`);
    });

Alejandro Oñate

student•

Quizás ya lo pillaste pero es por el console.log() dentro de la función ask

const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

const q = [
  'Cual es tu primer nombre? ',
  'Cual es tu primer apellido? ',
  'Cual es tu edad? '
];

const AskQuestion = (rl, question) => {
  return new Promise((resolve, rej) => {
    rl.question(question, answer => {
      resolve(answer);
    });
  });
}

const Ask = (questions) => {
  return new Promise(async resolve => {
    let results = [];
    for (let i=0; i < questions.length; i++) {
      const result = await AskQuestion(rl, questions[i]);
      results = [...results, result];
    }
    rl.close();
    resolve(results);
  });
}

Ask(q)
  .then(q => {
    console.log(`Hola ${q[0]} ${q[1]}, tu edad es la siguiente: ${q[2]}`);
  })

const ask = async questions => {
  let results = []
  for (let question of questions){
    const result = await askQuestion(rl, question)
    results.push(result);
  }
  rl.close()
  return results;
}

(async function() {
  const greeting = await ask(q);
  console.log(`Hola ${greeting[0]} ${greeting[1]}, tu edad es la siguiente ${greeting[2]}`)
})();

const cowsay =  require ('cowsay');
const readline = require ('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

console.log(cowsay.say({
  text: "hello! I can <sleep>, <mocking> or <died>",
  e: "0 0",
  T: " "
}));
console.log('*************************');

rl.question('What I do?: ', (answer) => {

  if (answer == 'sleep') {
    console.log(cowsay.think({
      text: "z Z z Z z",
      e: "- -",
      T: ""
    }));
    console.log('*************************');
  }
  else if (answer == 'died') {
    console.log(cowsay.say({
      text: " ......... ",
      e: "XX",
      T: "U"
    }));
    console.log('*************************');
  }
  else if (answer == 'mocking') {
    console.log(cowsay.say({
      text: "Ha ha ha!",
      e: "oO",
      T: " U"
    }));
    console.log('*************************');
  }
  else{
    console.log(cowsay.say({
      text:`I can't ${answer} \n Thank you for nothing`,
      e: "o <",
      T: ""
    }));
    console.log('*************************');
  }

  rl.close();
});

const readline = require('readline')

 const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
 })

const q = [
    '¿Cual es tu primer nombre?',
    '¿Cual es tu primer apellido?',
    '¿Cual es tu edad?'
]

const askQuestion = (rl, question) => {
    return new Promise((resolve, reject) => {
        rl.question(question, (answer)=> {
            resolve(answer)
        })
    })
}

const ask = function(questions){
    return new Promise(async resolve => {
        let results = []
        for(let question of questions){
            const result = await askQuestion(rl, question)
            results.push(result)
        }
        rl.close()
        resolve(results)
    })
}

async function obtenerRespuestas (preguntas) {
    const results = await ask(preguntas)
    console.log(results)
}

obtenerRespuestas(q)

const ask = (q) => 
{
    let results = [];

    return new Promise(async resolve =>
    {
        await Promise.all(
            q.map(async (item) =>
            {
                let result = await askQuestion(rl, item);
                results.push(result)
            })
        ).then(() =>
        {
            resolve(results);
            rl.close();
        });
    })
};

const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
})

const q = [
  
  'Cual es tu primer nombre ?  ',
  'Cual es tu primer apellido ? ',
  'Cual es tu edad ? '
];

/*esta funcuion permite usar la interfaz, para imprimir una pregunta en la consola
asi mismo, se queda esperando por la respuesta, cuando la obtiene la guardamos en resolve*/
const AskQuestion = (rl, question) => {

  return new Promise ((resolve, reject) => {
    rl.question(question, answer => {
      resolve(answer);
    })
  })
} 

/*Esta funcion recibe la interfaz,  una lista de preguntas, luego retornara una nueva promesa
esta usa async,  dentro de esa lista de preguntas vamos a iterar con un for
luego  usaremos await para llamar a  AskQuestion entonces,
no pasara a la siguiente promesa hasta que esta se resuelva si o si
finalmente ponemos  el resultado en results*/
const Ask = function (questions) {

  return new Promise (async resolve => {
    let results = [];

    for (let i = 0; i < questions.length; i++) {

      const result = await AskQuestion(rl, questions[i]);
      results.push(result);
    }

    rl.close();

    resolve(results);

  })
}

//puedes resolverlo con then 
Ask(q)
  .then(q => {
    console.log(`Hola ${q[0]} ${q[1]}, tu edad es ${q[2]} años humanos y `;)
  })


/*puedes resolverlo con  async await
async function Getanswers(questions) {
  const results = await Ask(q);
  console.log(results)
}

Getanswers(q);
*/```

const readline = require('readline');
const rl= readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

const q = [
    "¿Cual es tu primer nombre? ",
    "¿Cual es tu primer apellido? ",
    "¿Cual es tu edad? ",
    "¿Pais de origen? ",
    "¿Cual es tu habilidad? ",
    "¿Color fvorito? "
];

const AskQuestion = (rl, question)=>{
    return new Promise((resolv)=>{
        rl.question(question, answer =>{
            resolv(answer)
        });
    });
}

const Ask = function(questions){
    return new Promise(async resolv=>{
        let resultados = [];
        for(let i = 0; i < questions.length; i++){
            const resultado = await AskQuestion(rl,questions[i]);
            resultados.push(resultado)
        };
        rl.close()
        resolv(resultados)
    });
};
Ask(q)
.then(q=>{
        console.log(`Hola mi nombre es ${q[0]} ${q[1]}, tengo ${q[2]} años de edad, nací en ${q[3]}, mi habilidad es "${q[4]}" y mi color favorito es el ${q[5]}`)
    });
 

const readline = require('readline')
const interface = readline.createInterface({
    input: process.stdin,
    output: process.stdout
})
const questions = [
    "What's your first name? ",
    "What's your last name? ",
    "What's your age? "
]

const askQuestion = (inter, quest) => {
    return new Promise((res) => {
        inter.question(quest, (answer) => {
            res(answer)
        })
    })
}

const ask = (questions) => {
    return new Promise(async (res) => {
        let result = []
        for (let index = 0; index < questions.length; index++) {
            const response = await askQuestion(interface, questions[index])
            result.push(response)
        }
        interface.close()
        res(result)
    })
}

ask(questions).then((question) => {
    console.log(`Hey ${question[0]} ${question[1]}! Your age is ${question[2]}`)
})

const readline = require('readline')

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
})

const questions = [
  'Cual es tu primer nombre? ',
  'Cual es tu primer apellido? ',
  'Cual es tu edad? '
]

const askQuestions = question => new Promise(resolve => rl.question(question, resolve))

const ask = async questions => {
  const answers = []
  for await (let question of questions) {
    const answer = await askQuestions(question)
    answer.push(answer)
  }
  rl.close()
  return answers
}

ask(questions).then(console.log)

const manejador = require('readline');

(async function preguntar(){

    const formulario = manejador.createInterface({
        input: process.stdin,
        output: process.stdout
    })

    await formulario.question('Cómo quieres que te llame: ', respuesta =>{
        console.log(`${respuesta} mi amor, ¿cómo estás?`)
        formulario.close()
    })
})()```

test@test-VirtualBox:~/Desktop/nodejsbasico$ node index.js
Cual es tu primer nombre? test
Cual es tu primer nombre?
Cual es tu primer apellido? test
Cual es tu primer apellido?
Cual es tu edad? 1111
Cual es tu edad?
Hola test test, tu edad es la siguiente: 1111
test@test-VirtualBox:~/Desktop/nodejsbasico$

const readLine = require("readline");
 
const rl = readLine.createInterface({
    input: process.stdin,
    output: process.stdout
});
 
 const q = [
     "Cual es tu primer nombre? ",
     "Cual es tu primer apellido? ",
     "Cual es tu edad? ",
 ];
 
 const askQuestion = (rl, question) => {
     return new Promise((res, rej) => {
        rl.question(question, answer => {
            res(answer);
        });
     });
 }
 
 const ask = function(questions) {
     return new Promise(async resolve => {
        let results = [];
        for(let i = 0; i < questions.length; i++) {
            const result = await askQuestion(rl, questions[i]);
            console.log(questions[i]);
            results.push(result);
        }
        rl.close();
        resolve(results);
     })
 }
 
 ask(q)
    .then(q => {
        console.log(`Hola ${q[0]} ${q[1]}, tu edad es la siguiente: ${q[2]}`);
    });

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

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