readline in Node.js: leggere l'input utente dal terminale

Per leggere l'input dell'utente in Node.js, crea un'interfaccia readline su process.stdin e fai la domanda con rl.question(). Node.js non ha prompt(): la versione del browser apre una finestra di dialogo, e un programma da terminale non ne ha. La forma moderna usa readline/promises, dove await rl.question('Name? ') restituisce la riga scritta dall'utente. Chiudi l'interfaccia quando hai finito, altrimenti il programma resta in attesa di altro input.

// 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() ha stampato il suo prompt, ha aspettato una riga di input e l'ha restituita senza l'a capo, quindi il programma ha stampato Next year you will be 37. Per più domande, fai await di una question() dopo l'altra.

question() di readline con una callback

L'API originale, presente in ogni versione di Node.js, passa la risposta a una callback. Domande annidate vogliono callback annidate:

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

Ha stampato il prompt, poi You picked blue. La risposta è una semplice stringa, quindi falle trim prima di confrontarla: altrimenti un utente che scrive uno spazio dopo la parola ottiene 'blue ', che non è uguale a 'blue'.

Leggere l'input riga per riga

Per elaborare ogni riga finché l'input non finisce, scorri l'interfaccia con for await. È così che un programma legge una lista scritta dall'utente (chiusa con Ctrl+D) o un file passato con node index.js < numbers.txt. Il codice più vecchio fa lo stesso con gli eventi, rl.on('line', fn) per ogni riga e rl.on('close', fn) alla fine; il ciclo è quella coppia di eventi scritta dall'alto verso il basso:

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

Ha stampato 3 numbers, total 49, e il ciclo è finito da solo quando è finito l'input, quindi non serve close(). Aggiungi una quarta riga di input, 1, e il risultato diventa 4 numbers, total 50.

Leggere tutto lo stdin in una volta

Per un input che arriva in pipe da un altro programma (cat data.txt | node index.js), leggere tutto con una sola chiamata è più semplice. Il file descriptor 0 è lo standard input. Un file salvato su Windows può chiudere le righe con \r\n, quindi dividi su /\r?\n/ quando l'input può arrivare da lì:

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

Ha stampato i tre articoli in colonna. readFileSync(0) blocca finché l'input non è completo, il che va bene per uno script che legge da una pipe e per i test, ma non per uno strumento interattivo, dove l'utente scriverebbe tutto prima di vedere un qualsiasi prompt.

Quale usare

Tutti e quattro leggono lo stesso standard input. Cambia quando il tuo codice riceve il testo: una risposta alla volta, una riga alla volta o tutto alla fine.

Errori comuni

Dimenticare rl.close(). L'interfaccia tiene aperto lo standard input, quindi il programma non termina mai dopo l'ultima domanda. Chiudila quando hai tutte le risposte.

Usare la risposta come numero. Come tutto quello che si scrive in un terminale, la risposta è una stringa. '36' + 1 è '361'; converti prima con Number().

Passare in pipe più risposte a più domande. Quando l'input arriva da una pipe invece che dalla tastiera, readline lo legge tutto in una volta, e una riga che arriva prima che venga fatta la sua question() va persa. Per l'input in pipe usa il ciclo for await o readFileSync(0).

Omettere l'opzione output. Senza output: process.stdout, question() non stampa mai il suo prompt, e l'utente fissa un terminale vuoto. Il ciclo riga per riga non ne ha bisogno, perché non stampa niente.