readline ב-Node.js: קריאת קלט מהמשתמש בטרמינל

כדי לקרוא קלט מהמשתמש ב-Node.js, צרו ממשק readline על process.stdin ושאלו עם rl.question(). ב-Node.js אין prompt(): הגרסה של הדפדפן פותחת חלון דו-שיח, ולתוכנית טרמינל אין כזה. הצורה המודרנית משתמשת ב-readline/promises, שבה await rl.question('Name? ') מחזיר את השורה שהמשתמש הקליד. סגרו את הממשק כשסיימתם, אחרת התוכנית ממשיכה לחכות לעוד קלט.

// input: 36
import * as readline from 'node:readline/promises';
import { stdin as input, stdout as output } from 'node:process';

const rl = readline.createInterface({ input, output });

const age = await rl.question('How old are you? ');
rl.close();

console.log(`Next year you will be ${Number(age) + 1}.`);

question() הדפיס את השאלה שלו, חיכה לשורת קלט אחת והחזיר אותה בלי תו השורה החדשה, ולכן התוכנית הדפיסה Next year you will be 37. לכמה שאלות, חכו ל-question() אחד אחרי השני.

question() של readline עם callback

ה-API המקורי, שקיים בכל גרסה של Node.js, מעביר את התשובה ל-callback. שאלות מקוננות פירושן callbacks מקוננים:

// input: blue
const readline = require('readline');

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

rl.question('Favorite color? ', (answer) => {
    console.log(`You picked ${answer.trim().toLowerCase()}.`);
    rl.close();
});

הוא הדפיס את השאלה, ואז You picked blue. התשובה היא מחרוזת רגילה, אז עשו לה trim לפני השוואה: משתמש שמקליד רווח אחרי המילה יקבל אחרת 'blue ', שאינו שווה ל-'blue'.

קריאת קלט שורה אחרי שורה

כדי לעבד כל שורה עד שהקלט נגמר, עברו על הממשק עם for await. כך תוכנית קוראת רשימה שהמשתמש מקליד (ומסיים עם Ctrl+D) או קובץ שמועבר אליה ב-pipe עם node index.js < numbers.txt. קוד ישן יותר עושה את אותו הדבר עם אירועים, rl.on('line', fn) לכל שורה ו-rl.on('close', fn) בסוף; הלולאה היא אותו זוג אירועים, כתוב מלמעלה למטה:

// input: 12
// input: 7
// input: 30
const readline = require('readline');

async function main() {
    const rl = readline.createInterface({ input: process.stdin });
    let total = 0;
    let count = 0;

    for await (const line of rl) {
        total += Number(line);
        count += 1;
    }

    console.log(`${count} numbers, total ${total}`);
}

main();

הוא הדפיס 3 numbers, total 49, והלולאה הסתיימה מעצמה כשהקלט נגמר, כך שאין צורך ב-close(). הוסיפו שורת קלט רביעית, 1, והתוצאה תהיה 4 numbers, total 50.

קריאת כל ה-stdin בבת אחת

לקלט שמגיע ב-pipe מתוכנית אחרת (cat data.txt | node index.js), פשוט יותר לקרוא הכל בקריאה אחת. File descriptor 0 הוא הקלט הסטנדרטי. קובץ שנשמר ב-Windows עלול לסיים שורות ב-\r\n, אז פצלו לפי /\r?\n/ כשהקלט יכול להגיע משם:

// input: apples 3
// input: bread 1
// input: cheese 2
const fs = require('fs');

const text = fs.readFileSync(0, 'utf8');
const lines = text.trim().split(/\r?\n/);

for (const line of lines) {
    const [item, qty] = line.split(' ');
    console.log(item.padEnd(8), 'x', qty);
}

הוא הדפיס את שלושת הפריטים בעמודה. readFileSync(0) חוסם עד שהקלט מושלם, וזה בסדר לסקריפט שקורא pipe ולבדיקות, אבל שגוי לכלי אינטראקטיבי, שבו המשתמש היה מקליד הכל לפני שהוא רואה שאלה כלשהי.

במה להשתמש

כל הארבע קוראות את אותו קלט סטנדרטי. ההבדל הוא מתי הקוד שלכם מקבל את הטקסט: תשובה אחת בכל פעם, שורה אחת בכל פעם, או הכל בסוף.

טעויות נפוצות

לשכוח את rl.close(). הממשק משאיר את הקלט הסטנדרטי פתוח, כך שהתוכנית לא יוצאת אף פעם אחרי השאלה האחרונה. סגרו אותו ברגע שיש לכם את כל התשובות.

להשתמש בתשובה כמספר. כמו כל מה שמוקלד בטרמינל, התשובה היא מחרוזת. '36' + 1 הוא '361'; המירו עם Number() קודם.

להעביר ב-pipe כמה תשובות לכמה שאלות. כשהקלט מגיע מ-pipe ולא מהמקלדת, readline קורא את כולו בבת אחת, ושורה שמגיעה לפני שה-question() שלה נשאל נזרקת. לקלט מ-pipe, השתמשו בלולאת for await או ב-readFileSync(0).

להשמיט את האפשרות output. בלי output: process.stdout, ‏question() לא מדפיס את השאלה שלו אף פעם, והמשתמש בוהה בטרמינל ריק. הלולאה של שורה אחרי שורה לא צריכה אותה, כי היא לא מדפיסה כלום.