process.argv in Node.js: argomenti da riga di comando

process.argv è un array che contiene la riga di comando che ha avviato il tuo programma Node.js. L'indice 0 è il percorso dell'eseguibile node, l'indice 1 è il percorso del tuo script, e i tuoi argomenti iniziano dall'indice 2. Quindi process.argv.slice(2) ti dà esattamente quello che l'utente ha scritto dopo il nome del file, sempre come stringhe.

// $ node index.js Ada 42 --verbose
const path = require('path');

console.log('argv[0]:', path.basename(process.argv[0]));
console.log('argv[1]:', path.basename(process.argv[1]));
console.log('your arguments:', process.argv.slice(2));

Le prime due voci sono percorsi completi, quindi stampa solo la loro ultima parte (node e index.js), poi [ 'Ada', '42', '--verbose' ]. Cambia la riga degli argomenti in Grace 7 ed eseguilo di nuovo: l'array cambia di conseguenza.

Cosa finisce in process.argv

La shell divide la riga dopo node sugli spazi e passa i pezzi a Node.js. I flag scritti prima del nome del file appartengono a Node.js stesso, non al tuo programma:

node --max-old-space-size=4096 index.js --port=8080
# process.argv.slice(2) is [ '--port=8080' ]
# process.execArgv is      [ '--max-old-space-size=4096' ]

Le virgolette raggruppano più parole in un solo argomento ("Ada Lovelace" arriva come una sola stringa), e la shell espande pattern come *.txt in nomi di file prima che Node.js li veda.

Leggere gli argomenti con slice(2)

La maggior parte degli script destruttura gli argomenti che si aspetta e dà a ciascuno un default:

// $ node index.js Ada
const [name = 'world', greeting = 'Hello'] = process.argv.slice(2);

console.log(`${greeting}, ${name}`);

Ha stampato Hello, Ada: un argomento ha riempito name, e greeting è tornato al suo default. Aggiungi Hi dopo Ada nella riga degli argomenti e stampa Hi, Ada; svuota la riga e ottieni Hello, world.

I numeri arrivano come stringhe

La shell non ha tipi. Ogni argomento è una stringa, quindi i calcoli vengono sbagliati finché non converti:

// $ node index.js 7 5
const [a, b] = process.argv.slice(2);

console.log('as strings:', a + b);
console.log('as numbers:', Number(a) + Number(b));

const n = Number('ten');
console.log('bad input:', n, Number.isNaN(n));

a + b ha unito le stringhe in 75, e Number() ha dato 12. Una parola che non è un numero diventa NaN, quindi controlla con Number.isNaN e stampa un messaggio d'uso invece di andare avanti con un valore rotto.

Parsing a mano dei flag --name=value

Per un paio di flag basta un breve ciclo. Questo trasforma --port=8080 in port: '8080', un --verbose da solo in true, e tiene tutto il resto come argomento posizionale:

// $ node index.js build --port=8080 --verbose src
const flags = {};
const positional = [];

for (const arg of process.argv.slice(2)) {
    if (arg.startsWith('--')) {
        const [key, value = true] = arg.slice(2).split('=');
        flags[key] = value;
    } else {
        positional.push(arg);
    }
}

console.log(JSON.stringify(flags));
console.log(positional);

Ha stampato {"port":"8080","verbose":true} e [ 'build', 'src' ], con port ancora come stringa. Questo ciclo non gestisce i flag brevi come -p né un valore nell'argomento successivo (--port 8080); per quello usa il parser integrato qui sotto.

util.parseArgs, il parser integrato

Node.js 18.3 e successivi includono util.parseArgs, che gestisce flag lunghi e brevi, valori nell'argomento successivo, booleani e default:

const { parseArgs } = require('node:util');

// node index.js -p 8080 --verbose src
const { values, positionals } = parseArgs({
    options: {
        port: { type: 'string', short: 'p', default: '3000' },
        verbose: { type: 'boolean', short: 'v' },
    },
    allowPositionals: true,
});

console.log(values);      // [Object: null prototype] { port: '8080', verbose: true }
console.log(positionals); // [ 'src' ]

parseArgs legge process.argv.slice(2) di default. Lancia un errore su un'opzione che non hai dichiarato, così intercetta errori di battitura come --prot; passa strict: false per accettare flag sconosciuti. I tipi delle opzioni sono solo string e boolean, quindi per i numeri serve ancora Number(). values è un oggetto senza prototype, ed è per questo che viene stampato con [Object: null prototype]; leggilo come qualsiasi oggetto.

Errori comuni

Leggere process.argv[0] come primo argomento. È il percorso di node. Il tuo primo argomento è process.argv[2].

Dimenticare che tutto è una stringa. '10' > '9' è false, perché le stringhe si confrontano carattere per carattere. Converti prima.

Mettere segreti negli argomenti. Le righe di comando finiscono nella cronologia della shell e negli elenchi dei processi che gli altri utenti della macchina possono leggere. Passa password e chiavi API tramite variabili d'ambiente.