How do I pass command line arguments to a Node.js program and receive them?

You can get command-line information from process.argv()

And I don't want to limit the problem to node.js. Instead, I want to turn it into how to parse the string as the argument.

console.log(ArgumentParser(`--debug --msg="Hello World" --title="Test" --desc=demo -open --level=5 --MyFloat=3.14`)) 

output

{ "debug": true, "msg": "Hello World", "title": "Test", "desc": "demo", "open": true, "level": 5, "MyFloat": 3.14 } 

code

Pure javascript, no dependencies needed

// 👇 Below is Test (() => { window.onload = () => { const testArray = [ `--debug --msg="Hello World" --title="Test" --desc=demo -open --level=5 --MyFloat=3.14`, ] for (const testData of testArray) { try { const obj = ArgumentParser(testData) console.log(obj) } catch (e) { console.error(e.message) } } } })() // 👇 Script class ParserError extends Error { } function Cursor(str, pos) { this.str = str this.pos = pos this.MoveRight = (step = 1) => { this.pos += step } this.MoveToNextPara = () => { const curStr = this.str.substring(this.pos) const match = /^(?<all> *--?(?<name>[a-zA-Z_][a-zA-Z0-9_]*)(=(?<value>[^-]*))?)/g.exec(curStr) // https://regex101.com/r/k004Gv/2 if (match) { let {groups: {all, name, value}} = match if (value !== undefined) { value = value.trim() if (value.slice(0, 1) === '"') { // string if (value.slice(-1) !== '"') { throw new ParserError(`Parsing error: '"' expected`) } value = value.slice(1, -1) } else { // number or string (without '"') value = isNaN(Number(value)) ? String(value) : Number(value) } } this.MoveRight(all.length) return [name, value ?? true] // If the value is undefined, then set it as ture. } throw new ParserError(`illegal format detected. ${curStr}`) } } function ArgumentParser(str) { const obj = {} const cursor = new Cursor(str, 0) while (1) { const [name, value] = cursor.MoveToNextPara() obj[name] = value if (cursor.pos === str.length) { return obj } } }

NodeJS exposes a global variable called process.

we can use:

process.argv 

to get the command line arguments passes to our script.

The output of process.argv will be a list in the following order:

[ full-path-to-node-executable, full-path-to-the-script-file ...additonal-arguments-we-provide ] 

process.argv is your friend, capturing command line args is natively supported in Node JS. See example below::

process.argv.forEach((val, index) => { console.log(`${index}: ${val}`); }) 

I extended the getArgs function just to get also commands, as well as flags (-f, --anotherflag) and named args (--data=blablabla):

1. The module

/** * @module getArgs.js * get command line arguments (commands, named arguments, flags) * * @see https://stackoverflow.com/a/54098693/1786393 * * @return {Object} * */ function getArgs () { const commands = [] const args = {} process.argv .slice(2, process.argv.length) .forEach( arg => { // long arg if (arg.slice(0,2) === '--') { const longArg = arg.split('=') const longArgFlag = longArg[0].slice(2,longArg[0].length) const longArgValue = longArg.length > 1 ? longArg[1] : true args[longArgFlag] = longArgValue } // flags else if (arg[0] === '-') { const flags = arg.slice(1,arg.length).split('') flags.forEach(flag => { args[flag] = true }) } else { // commands commands.push(arg) } }) return { args, commands } } // test if (require.main === module) { // node getArgs test --dir=examples/getUserName --start=getUserName.askName console.log( getArgs() ) } module.exports = { getArgs } 

2. Usage example:

$ node lib/getArgs test --dir=examples/getUserName --start=getUserName.askName { args: { dir: 'examples/getUserName', start: 'getUserName.askName' }, commands: [ 'test' ] } $ node lib/getArgs --dir=examples/getUserName --start=getUserName.askName test tutorial { args: { dir: 'examples/getUserName', start: 'getUserName.askName' }, commands: [ 'test', 'tutorial' ] } 

Use the minimist npm package. it is the easiest method and don't need to worry about anything.

const arguments = require("minimist")(process.argv.slice(2)); // get the extra argument of command line . eg node app.js --process="sendEmailWithReminder" 

We can use it in windows task scheduler too.

Simplest possible solution to precisely what the OP asked

if (process.argv.length != 3) { console.log("Please call with a folder name") process.exit(1) } let arg = process.argv[2] console.log("your folder is:", arg) 

and hence

% node test.js Please call with a folder name % node test.js catPhotos your folder is: catPhotos 

That's it.

The original question was asking to pass command line arguments, not about more complex parsing of arguments. Yet with all the complex answers, they all missed one simple, useful variation.

Did you know that the Unix shell supports named arguments? This dates back to the original Bourne shell in the 1980s. Usage is simple:

$ FOO=one BAR=two nodejs myscript.js 

To fetch the parameters in Javascript:

var foo = process.env.FOO; var bar = process.env.BAR; 

Named parameters are much easier to read, once you get past two or three parameters. Optional parameters are simple, and order is not fixed.

(This might even work on Windows, with the recent support for Unix shells.)

Also, shockingly few Unix programmers know of this usage. :)

as stated in the node docs The process.argv property returns an array containing the command line arguments passed when the Node.js process was launched.

For example, assuming the following script for process-args.js:

// print process.argv process.argv.forEach((val, index) => { console.log(`${index}: ${val}`); }); 

Launching the Node.js process as:

 $ node process-args.js one two=three four 

Would generate the output:

0: /usr/local/bin/node 1: /Users/mjr/work/node/process-args.js 2: one 3: two=three 4: four 

Most of the people have given good answers. I would also like to contribute something here. I am providing the answer using lodash library to iterate through all command line arguments we pass while starting the app:

// Lodash library const _ = require('lodash'); // Function that goes through each CommandLine Arguments and prints it to the console. const runApp = () => { _.map(process.argv, (arg) => { console.log(arg); }); }; // Calling the function. runApp(); 

To run above code just run following commands:

npm install node index.js xyz abc 123 456 

The result will be:

xyz abc 123 456 

Typescript way to do it with minimist.

npm i minimist @types/minimist

app.ts

// import import { MyProgram } from './main'; // libraries import minimist from 'minimist'; // interfaces import { ParsedArgs } from 'minimist'; // code const args: ParsedArgs = minimist(process.argv.slice(2)); let app = new MyProgram(args.a).getApp(); export { app }; 

Command to run after compiling to JavaScript with gulp

node app.js -a MyParam

You can use Rest operator to accept n numbers of arguments in a function and use it like this i have posted a sample program i hope which will help you to get the point.

 function sum(...theArgs) { let total = 0; for (const arg of theArgs) { total += arg; } return total; } console.log(sum(1, 2, 3)); // Expected output: 6 console.log(sum(1, 2, 3, 4)); // Expected output: 10 enter code here