process.argv w Node.js: argumenty wiersza poleceń

process.argv to tablica z wierszem poleceń, który uruchomił twój program Node.js. Indeks 0 to ścieżka do pliku wykonywalnego node, indeks 1 to ścieżka do twojego skryptu, a twoje własne argumenty zaczynają się od indeksu 2. Dlatego process.argv.slice(2) daje dokładnie to, co użytkownik wpisał po nazwie pliku, zawsze jako stringi.

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

Dwa pierwsze wpisy to pełne ścieżki, więc przykład wypisuje tylko ich ostatnią część (node i index.js), a potem [ 'Ada', '42', '--verbose' ]. Zmień wiersz argumentów na Grace 7 i uruchom ponownie: tablica się zmieni.

Co trafia do process.argv

Powłoka dzieli linię po node na spacjach i przekazuje kawałki do Node.js. Flagi zapisane przed nazwą pliku należą do samego Node.js, a nie do twojego programu:

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' ]

Cudzysłowy łączą słowa w jeden argument ("Ada Lovelace" przychodzi jako jeden string), a powłoka rozwija wzorce takie jak *.txt w nazwy plików, zanim Node.js je w ogóle zobaczy.

Pobieranie argumentów przez slice(2)

Większość skryptów destrukturyzuje oczekiwane argumenty i daje każdemu wartość domyślną:

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

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

Wypisało Hello, Ada: jeden argument wypełnił name, a greeting dostało wartość domyślną. Dopisz Hi po Ada w wierszu argumentów, a wypisze się Hi, Ada; wyczyść wiersz, a dostaniesz Hello, world.

Liczby przychodzą jako stringi

Powłoka nie zna typów. Każdy argument to string, więc arytmetyka na nich działa źle, dopóki ich nie zamienisz:

// $ 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 skleiło stringi w 75, a Number() dało 12. Słowo, które nie jest liczbą, zmienia się w NaN, więc sprawdzaj przez Number.isNaN i wypisz instrukcję użycia, zamiast kontynuować z zepsutą wartością.

Ręczne parsowanie flag --name=value

Przy kilku flagach wystarczy krótka pętla. Ta zamienia --port=8080 na port: '8080', samo --verbose na true, a resztę zostawia jako argumenty pozycyjne:

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

Wypisało {"port":"8080","verbose":true} i [ 'build', 'src' ], a port jest nadal stringiem. Ta pętla nie obsługuje krótkich flag, np. -p, ani wartości w następnym argumencie (--port 8080); do tego użyj wbudowanego parsera poniżej.

util.parseArgs, wbudowany parser

Node.js 18.3 i nowsze mają util.parseArgs, które obsługuje długie i krótkie flagi, wartości w następnym argumencie, wartości logiczne i domyślne:

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 domyślnie czyta process.argv.slice(2). Rzuca wyjątek przy opcji, której nie zadeklarowałeś, co wyłapuje literówki takie jak --prot; przekaż strict: false, żeby akceptować nieznane flagi. Typy opcji to tylko string i boolean, więc liczby nadal wymagają Number(). values to obiekt bez prototypu i dlatego wypisuje się z [Object: null prototype]; czytaj go jak każdy obiekt.

Częste błędy

Traktowanie process.argv[0] jako pierwszego argumentu. To ścieżka do node. Twój pierwszy argument to process.argv[2].

Zapominanie, że wszystko jest stringiem. '10' > '9' to false, bo stringi porównuje się znak po znaku. Najpierw zamień na liczby.

Wpisywanie sekretów w argumenty. Wiersze poleceń trafiają do historii powłoki i list procesów, które mogą odczytać inni użytkownicy maszyny. Hasła i klucze API przekazuj przez zmienne środowiskowe.