如何将命令行参数传递给Node.js程序?


2412

我有一个用Node.js编写的Web服务器,我想使用一个特定的文件夹启动。我不确定如何在JavaScript中访问参数。我正在像这样运行节点:

$ node server.js folder

server.js是我的服务器代码。Node.js帮助说这是可能的:

$ node -h
Usage: node [options] script.js [arguments]

如何在JavaScript中访问这些参数?不知何故,我无法在网上找到此信息。

Answers:


3046

标准方法(无库)

参数存储在 process.argv

以下是处理命令行参数的节点文档:

process.argv是一个包含命令行参数的数组。第一个元素是'node',第二个元素是JavaScript文件的名称。接下来的元素将是任何其他命令行参数。

// print process.argv
process.argv.forEach(function (val, index, array) {
  console.log(index + ': ' + val);
});

这将生成:

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

7
我应该在命令提示符下键入什么以运行带有命令行参数的node.js脚本?
安德森·格林

8
更新:我找到了上述问题的答案。stackoverflow.com/questions/12925802/…–
安德森·格林

2
Minimist是一个出色且简单的参数解析器
Guilherme Nagatomo

4
您也可以在知道位置的情况process.argv[n]下访问单个参数:n从零开始的索引在哪里
Luca Steeb 2015年

6
第二个元素(process.argv [1])可能是js文件,也可能不是。节点命令语法为node [options] [ -e script | script.js ] [arguments]node debug script.js [arguments]。例如:node --harmony script.js balalanode --no-deprecation --enable-ssl2 script.js balala,我们可以将process.execArgvprocess.argv
一起

678

为了使参数像常规的javascript函数一样标准化,我在node.js shell脚本中执行以下操作:

var args = process.argv.slice(2);

请注意,第一个arg通常是nodejs的路径,第二个arg是您正在执行的脚本的位置。


19
请注意,我是4年前写的这个答案,而我正在运行的代码今天仍然可以100%运行。仍与最新的节点版本保持一致,并且零问题仍然存在:这只是一个简单的Shell脚本专家。不属于包含JS库的大型全局对象。我今天仍然站在我的答案后面。我将在4年后再提供一次更新。
Mauvis Ledford'3

55
var args = process.argv.splice(process.execArgv.length + 2);//因为节点命令用法存在例外,例如:node --harmony script.js balala。参见process.execArgv
cuixiping

36
@cuixiping但execArgv没有argv如此的2足够
托米Kyntola

7
在查看了此答案的编辑历史之后,我想花一点时间来同情@MauvisLedford。没有什么比以个人喜好为名对代码进行未经请求的编辑令人讨厌的了(启动没有任何可量化的好处)。向谁这样做:扔掉。
乔纳森·杜马因

12
不要process.argv.splice(process.execArgv.length + 2):对于命令node --harmony script.js --versionprocess.argv['/usr/local/bin/node', 'script.js', '--version']标志上node包括在process.argv
КонстантинВан

360

为此,它使用极简库来提供正确的答案。我们曾经使用节点优化器,但此后不推荐使用。

这是一个如何使用它的示例,直接摘自简约文档:

var argv = require('minimist')(process.argv.slice(2));
console.dir(argv);

--

$ node example/parse.js -a beep -b boop
{ _: [], a: 'beep', b: 'boop' }

--

$ node example/parse.js -x 3 -y 4 -n5 -abc --beep=boop foo bar baz
{ _: [ 'foo', 'bar', 'baz' ],
  x: 3,
  y: 4,
  n: 5,
  a: true,
  b: true,
  c: true,
  beep: 'boop' }

32
实际上,此解决方案对于开发带有更多标志和参数的命令行工具更为有用,因此应增加恕我直言。
JK ABC


5
@JKABC我不会将其称为最正确的答案,因为OP只是要求访问琐碎的命令行信息。但是我同意,如果您打算扩展CLI,则minimist和command-line-args都非常有用。
Justus Romijn

2
我想知道为什么'-n5'不产生'n5:true'-这对我来说有意义。
Max Waterman '18

7
@MaxWaterman:因为以单个破折号开头的选项只能用于单个字符。单个char选项之后的所有内容均作为该选项的参数(无需空格)。以两个破折号(即--n5)开头的选项应生成'n5:true'。对于大多数Unix命令行工具来说,这是相当标准的行为(但不幸的是,并非所有人)。
Menno Smits

313

基于当前野外趋势的2018年答案:


香草javascript参数解析:

const args = process.argv;
console.log(args);

返回:

$ node server.js one two=three four
['node', '/home/server.js', 'one', 'two=three', 'four']

官方文档


最常用的NPM软件包进行参数解析:

Minimist:用于最少的参数解析。

Commander.js:最常用的参数解析模块。

喵喵:Commander.js的更轻巧的替代品

Yargs:更复杂的参数解析(繁重)。

Vorpal.js:具有参数解析功能的成熟/交互式命令行应用程序。


76
“ $ npm install -g yargs”产生了1.9 MB的JavaScript代码。当argv解析器库需要2 MB的代码时,这种疯狂何时才能结束?攻击面增加,RAM浪费等...
joonas.fi 16-10-13

9
Yargs是一个较大的工具,它也可以解析命令行参数。没有疯狂,只是缺乏信息。如果您想减轻重量,请使用原始的JS,Meow或Minimist。
2016年

1
“ $ npm i yargs”-> 800 KB在这里,我想软件包所有者终于学会了忽略无关的文件。不管怎样,还是大的愚蠢的项目,但是小的时候,你需要的稳健性和较大的项目你已经有了依赖..
安德烈·菲格雷多

3
我创建了一个名为wily-cli的程序包,目的是使它比列出的大牌更强大,更可自定义并且更易于使用。对于那些感兴趣的人,安装后仅94.6 KB
Jason

1
vscode import-cost告诉我,yargs(159.2K)现在实际上比喵声(180.2K)轻。极简主义者仍然以3.4K的优势击败他们!
Shivam Tripathi

124

乐观主义者(节点最优主义者)

查看乐观主义者库,它比手工分析命令行选项要好得多。

更新资料

不赞成使用乐观主义者。尝试yargs,它是乐观主义者的积极分支。



7
极简主义者是如今已被弃用的乐观主义者的另一个继任者。这是“乐观主义者的论点分析器的精髓,没有任何奇特的修饰。” 上个月(截至2015年12月)的下载量为2300万。
2015年

96

这里有几个很好的答案,但这似乎非常复杂。这与bash脚本访问参数值的方式非常相似,并且正如MooGoo所指出的那样,它已经作为标准提供给node.js。(只是使它对于node.js的新手来说是可以理解的)

例:

$ node yourscript.js banana monkey

var program_name = process.argv[0]; //value will be "node"
var script_path = process.argv[1]; //value will be "yourscript.js"
var first_value = process.argv[2]; //value will be "banana"
var second_value = process.argv[3]; //value will be "monkey"

80

Commander.js

对于定义选项,操作和参数非常有用。它还会为您生成帮助页面。

及时

如果您喜欢回调方法,则非常适合从用户那里获取输入。

共同提示

如果您喜欢生成器方法,则非常适合从用户那里获取输入。


26
@Evan Carroll,请不要编辑我的答案来推广图书馆,我不使用stackoverflow.com/posts/7483600/revisions,尤其是因为您缺少的功能,应保存此类意见以供评论或将请求拉至模块作者,而不是其他人的答案。
balupton

Commander.js确实帮助了我。其他库不能与nexe编译器一起使用,但是这个库可以解决问题。如果要在使用nexe时获取args,请确保将-f传递给nexe编译器。
pierce.jason 2014年

60

没有标志格式化为简单对象的库

function getArgs () {
    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;
            });
        }
    });
    return args;
}
const args = getArgs();
console.log(args);

例子

简单

输入

node test.js -D --name=Hello

输出

{ D: true, name: 'Hello' }

真实世界

输入

node config/build.js -lHRs --ip=$HOST --port=$PORT --env=dev

输出

{ 
  l: true,
  H: true,
  R: true,
  s: true,
  ip: '127.0.0.1',
  port: '8080',
  env: 'dev'
}

1
由于某些标志的格式很长,您可以考虑一下。而不是= longArg[1]您可以这样写:= longArg.length > 1 ? longArg[1] : true;它可以让您传递这种类型的论点:node config/build.js --flag1 --flag2
特拉斯顿

我喜欢。它使线有点长,所以我把它弄坏了。谢谢你告诉我这件事。
迈克尔·沃纳

54

Stdio图书馆

在NodeJS中解析命令行参数的最简单方法是使用stdio模块。受UNIX getopt实用程序的启发,它很简单,如下所示:

var stdio = require('stdio');
var ops = stdio.getopt({
    'check': {key: 'c', args: 2, description: 'What this option means'},
    'map': {key: 'm', description: 'Another description'},
    'kaka': {args: 1, required: true},
    'ooo': {key: 'o'}
});

如果使用此命令运行先前的代码:

node <your_script.js> -c 23 45 --map -k 23 file1 file2

然后ops对象将如下所示:

{ check: [ '23', '45' ],
  args: [ 'file1', 'file2' ],
  map: true,
  kaka: '23' }

因此,您可以根据需要使用它。例如:

if (ops.kaka && ops.check) {
    console.log(ops.kaka + ops.check[0]);
}

还支持分组选项,因此您可以编写-om而不是-o -m

此外,stdio可以自动生成帮助/使用输出。如果致电,ops.printHelp()您将获得以下信息:

USAGE: node something.js [--check <ARG1> <ARG2>] [--kaka] [--ooo] [--map]
  -c, --check <ARG1> <ARG2>   What this option means (mandatory)
  -k, --kaka                  (mandatory)
  --map                       Another description
  -o, --ooo

如果未给出强制性选项(错误消息之前)或选项不明确(例如,如果您为选项指定单个arg并且需要2),则还会显示上一条消息。

您可以使用NPM安装stdio模块:

npm install stdio

3
根据SO的TOS,值得一提的是@sgmonda是该模块的唯一维护者;)不过不错的小模块。绝对有用。
Qix-蒙尼卡(Monica)2014年

1
确实有用,尽管最近的更新是2014年12月30日。维护得可能不如其他软件包好。
fearless_fool16年

好库!!完全是最新的更新。.它具有足够好的功能
Pablo Ezequiel

已经有一段时间了,但是我刚刚发布了第2版,具有完整的Promise和Typescript支持。:-)
sgmonda '19

47

如果您的脚本名为myScript.js,并且您希望将名字和姓氏“ Sean Worthington”作为如下参数传递:

node myScript.js Sean Worthington

然后在脚本中编写:

var firstName = process.argv[2]; // Will be set to 'Sean'
var lastName = process.argv[3]; // Will be set to 'Worthington'

28

命令行参数值得一看!

您可以使用主要的注释标准来设置选项(了解更多信息)。这些命令都是等效的,设置相同的值:

$ example --verbose --timeout=1000 --src one.js --src two.js
$ example --verbose --timeout 1000 --src one.js two.js
$ example -vt 1000 --src one.js two.js
$ example -vt 1000 one.js two.js

要访问这些值,请首先创建一个选项定义列表,以描述应用程序接受的选项。该type属性是一个setter函数(通过此函数传递提供的值),使您可以完全控制接收到的值。

const optionDefinitions = [
  { name: 'verbose', alias: 'v', type: Boolean },
  { name: 'src', type: String, multiple: true, defaultOption: true },
  { name: 'timeout', alias: 't', type: Number }
]

接下来,使用commandLineArgs()解析选项:

const commandLineArgs = require('command-line-args')
const options = commandLineArgs(optionDefinitions)

options 现在看起来像这样:

{
  src: [
    'one.js',
    'two.js'
  ],
  verbose: true,
  timeout: 1000
}

高级用法

除了上述典型用法外,您还可以配置命令行参数以接受更高级的语法形式。

基于命令的语法(git样式),形式为:

$ executable <command> [options]

例如。

$ git commit --squash -m "This is my commit message"

命令和子命令语法(docker风格),形式为:

$ executable <command> [options] <sub-command> [options]

例如。

$ docker run --detached --image centos bash -c yum install -y httpd

使用指南生成

--help可以使用命令行用法生成使用指南(通常在设置时打印)。请参阅下面的示例,并阅读文档以获取有关如何创建它们的说明。

一个典型的用法指南示例。

用法

所述聚合物-CLI使用指南是一个很好的真实的例子。

用法

进一步阅读

还有很多要学习的内容,请参阅Wiki中的示例和文档。


@Lloyd这与已经出现的问题有关- 在这里。Webstorm传递了一些其他参数。
kboom

@kboom问题已通过partialstopAtFirstUnknown选项解决。请参阅文档
劳埃德

23

有一个应用程序。好吧,模块。好吧,不止一个,可能是数百个。

Yargs是有趣的工具之一,其文档很酷。

这是github / npm页面上的示例:

#!/usr/bin/env node
var argv = require('yargs').argv;
console.log('(%d,%d)', argv.x, argv.y);
console.log(argv._);

输出在这里(它读取带破折号,长和短,数字等的选项)。

$ ./nonopt.js -x 6.82 -y 3.35 rum
(6.82,3.35)
[ 'rum' ] 
$ ./nonopt.js "me hearties" -x 0.54 yo -y 1.12 ho
(0.54,1.12)
[ 'me hearties', 'yo', 'ho' ]

21

这是命名参数的0深度解决方案:

const args = process.argv
    .slice(2)
    .map(arg => arg.split('='))
    .reduce((args, [value, key]) => {
        args[value] = key;
        return args;
    }, {});

console.log(args.foo)
console.log(args.fizz)

例:

$ node test.js foo=bar fizz=buzz
bar
buzz

注意:当参数包含时,自然会失败=。这仅用于非常简单的用法。



12

完全免费:使用Array.prototype.reduce()

const args = process.argv.slice(2).reduce((acc, arg) => {

    let [k, v = true] = arg.split('=')
    acc[k] = v
    return acc

}, {})

对于此命令 node index.js count=2 print debug=false msg=hi

console.log(args) // { count: '2', print: true, debug: 'false', msg: 'hi' }

也,

我们可以改变

    let [k, v = true] = arg.split('=')
    acc[k] = v

通过(更长)

    let [k, v] = arg.split('=')
    acc[k] = v === undefined ? true : /true|false/.test(v) ? v === 'true' : /[\d|\.]+/.test(v) ? Number(v) : v

自动解析布尔值和数字

console.log(args) // { count: 2, print: true, debug: false, msg: 'hi' }

您的较长版本对包含点的字符串有问题。
柏林

聪明的解决方案!如果我要同时支持countc命令行选项(c作为的别名/快捷方式count)怎么办?
Alex Vang

这很漂亮!但是它不使用“一个字母键一个破折号和一个单词键两个破折号”标准。不幸的是,我的选择太冗长和丑陋,无法在此处发布,因此我将添加另一个答案。
isacvale

10

传递,解析参数是一个简单的过程。Node为您提供了process.argv属性,该属性是一个字符串数组,这些字符串是调用Node时使用的参数。数组的第一项是Node可执行文件,第二项是脚本的名称。

如果您使用以下参数运行脚本

$ node args.js arg1 arg2

文件:args.js

console.log(process.argv)

你会得到像

 ['node','args.js','arg1','arg2']

9
npm install ps-grab

如果您想运行以下内容:

node greeting.js --user Abdennour --website http://abdennoor.com 

-

var grab=require('ps-grab');
grab('--username') // return 'Abdennour'
grab('--action') // return 'http://abdennoor.com'

或类似的东西:

node vbox.js -OS redhat -VM template-12332 ;

-

var grab=require('ps-grab');
grab('-OS') // return 'redhat'
grab('-VM') // return 'template-12332'

1
该存储库不再在github上可用。
steadweb

8

proj.js

for(var i=0;i<process.argv.length;i++){
  console.log(process.argv[i]);
}

终奌站:

nodemon app.js "arg1" "arg2" "arg3"

结果:

0 'C:\\Program Files\\nodejs\\node.exe'
1 'C:\\Users\\Nouman\\Desktop\\Node\\camer nodejs\\proj.js'
2 'arg1' your first argument you passed.
3 'arg2' your second argument you passed.
4 'arg3' your third argument you passed.

说明:

0 :机器中的node.exe目录(C:\ Program Files \ nodejs \ node.exe')

1:项目文件的目录。(proj.js)

2 :您对节点(arg1)的第一个参数

3 :您的第二个参数node(arg2)

4 :您的第三个参数node(arg3)

您的实际参数以数组的2nd索引形式开始argv,即process.argv[2]


7

您可以使用来获取命令行参数system.args。而且我使用下面的解决方案将参数解析为一个对象,因此我可以按名称获取想要的对象。

var system = require('system');

var args = {};
system.args.map(function(x){return x.split("=")})
    .map(function(y){args[y[0]]=y[1]});

现在您不需要知道参数的索引。用起来像args.whatever

注意:您应该使用命名参数,例如file.js x=1 y=2使用此解决方案。


无法使用,map属性未定义。
卡拉姆

6

您可以解析所有参数并检查它们是否存在。

文件:parse-cli-arguments.js:

module.exports = function(requiredArguments){
    var arguments = {};

    for (var index = 0; index < process.argv.length; index++) {
        var re = new RegExp('--([A-Za-z0-9_]+)=([A/-Za-z0-9_]+)'),
            matches = re.exec(process.argv[index]);

        if(matches !== null) {
            arguments[matches[1]] = matches[2];
        }
    }

    for (var index = 0; index < requiredArguments.length; index++) {
        if (arguments[requiredArguments[index]] === undefined) {
            throw(requiredArguments[index] + ' not defined. Please add the argument with --' + requiredArguments[index]);
        }
    }

    return arguments;
}

比只是做:

var arguments = require('./parse-cli-arguments')(['foo', 'bar', 'xpto']);

4

没有图书馆

如果要在香草JS / ES6中执行此操作,则可以使用以下解决方案

仅在NodeJS> 6中有效

const args = process.argv
  .slice(2)
  .map((val, i)=>{
    let object = {};
    let [regexForProp, regexForVal] = (() => [new RegExp('^(.+?)='), new RegExp('\=(.*)')] )();
    let [prop, value] = (() => [regexForProp.exec(val), regexForVal.exec(val)] )();
    if(!prop){
      object[val] = true;
      return object;
    } else {
      object[prop[1]] = value[1] ;
      return object
    }
  })
  .reduce((obj, item) => {
    let prop = Object.keys(item)[0];
    obj[prop] = item[prop];
    return obj;
  }, {});

而这个命令

node index.js host=http://google.com port=8080 production

将产生以下结果

console.log(args);//{ host:'http://google.com',port:'8080',production:true }
console.log(args.host);//http://google.com
console.log(args.port);//8080
console.log(args.production);//true

ps如果您找到更优雅的解决方案,请更正map中的代码并简化功能,谢谢;)


1
我同意,但可以缩短一点吗? let args = process.argv.slice(2).reduce((acc, arg) => { let [k, v] = arg.split('=') acc[k] = v return acc }, {})
约瑟夫·梅德里格纳克

4

尽管上述答案很完美,并且有人已经建议过,但是使用该软件包确实很容易。这是一个很好的程序包,它使传递参数到命令行变得非常容易。

npm i yargs
const yargs = require("yargs");
const argv = yargs.argv;
console.log(argv);

请访问https://yargs.js.org/了解更多信息。


Yargs不会影响在命令行上传递参数的方式,它仅有助于读取代码中的参数。
user3285954 '19

4

传递参数很容易,接收参数只是阅读process.argv数组Node基本上可以从任何地方访问。但是您一定要将它们作为键/值对读取,因此您需要一段脚本来解释它。

约瑟夫·梅德里格纳克(Joseph Merdrignac)发布了一个漂亮的使用reduce的代码,但它依赖于key=value语法而不是-k valueand --key value。我将其重写为更丑陋且使用第二个标准的时间更长,我将其发布为答案,因为它不适合用作评论。但这确实完成了工作。

   const args = process.argv.slice(2).reduce((acc,arg,cur,arr)=>{
     if(arg.match(/^--/)){
       acc[arg.substring(2)] = true
       acc['_lastkey'] = arg.substring(2)
     } else
     if(arg.match(/^-[^-]/)){
       for(key of arg.substring(1).split('')){
         acc[key] = true
         acc['_lastkey'] = key
       }
     } else
       if(acc['_lastkey']){
         acc[acc['_lastkey']] = arg
         delete acc['_lastkey']
       } else
         acc[arg] = true
     if(cur==arr.length-1)
       delete acc['_lastkey']
     return acc
   },{})

使用此代码,命令node script.js alpha beta -charlie delta --echo foxtrot将为您提供以下对象


args = {
 "alpha":true,
 "beta":true,
 "c":true,
 "h":true,
 "a":true,
 "r":true
 "l":true,
 "i":true,
 "e":"delta",
 "echo":"foxtrot"
}

3

在Node.js中检索参数的最简单方法是通过process.argv数组。这是一个全局对象,无需导入任何其他库即可使用它。就像我们前面展示的那样,您只需要将参数传递给Node.js应用程序,这些参数就可以通过process.argv数组在应用程序内进行访问。

process.argv数组的第一个元素将始终是指向节点可执行文件的文件系统路径。第二个元素是正在执行的JavaScript文件的名称。第三个元素是用户实际传递的第一个参数。

'use strict';

for (let j = 0; j < process.argv.length; j++) {  
    console.log(j + ' -> ' + (process.argv[j]));
}

该脚本所做的全部工作是遍历process.argv数组,并打印索引以及存储在这些索引中的元素。如果您质疑要接收的参数和接收顺序,这对于调试非常有用。

您也可以使用yargs之类的库来处理commnadline参数。


2

没有库的TypeScript解决方案:

interface IParams {
  [key: string]: string
}

function parseCliParams(): IParams {
  const args: IParams = {};
  const rawArgs = process.argv.slice(2, process.argv.length);
  rawArgs.forEach((arg: string, index) => {
    // Long arguments with '--' flags:
    if (arg.slice(0, 2).includes('--')) {
      const longArgKey = arg.slice(2, arg.length);
      const longArgValue = rawArgs[index + 1]; // Next value, e.g.: --connection connection_name
      args[longArgKey] = longArgValue;
    }
    // Shot arguments with '-' flags:
    else if (arg.slice(0, 1).includes('-')) {
      const longArgKey = arg.slice(1, arg.length);
      const longArgValue = rawArgs[index + 1]; // Next value, e.g.: -c connection_name
      args[longArgKey] = longArgValue;
    }
  });
  return args;
}

const params = parseCliParams();
console.log('params: ', params);

输入: ts-node index.js -p param --parameter parameter

输出: { p: 'param ', parameter: 'parameter' }


1

process.argv是您的朋友,Node JS本身支持捕获命令行args。请参见以下示例::

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

0

如节点文档中所述,process.argv属性返回一个数组,其中包含启动Node.js进程时传递的命令行参数。

例如,假设以下脚本用于process-args.js:

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

以以下方式启动Node.js进程:

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

将生成输出:

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

0

大多数人都给出了很好的答案。我也想在这里做点贡献。我使用lodash库来提供答案,以迭代我们在启动应用程序时传递的所有命令行参数:

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

要运行以上代码,只需运行以下命令:

npm install
node index.js xyz abc 123 456

结果将是:

xyz 
abc 
123
456

0

将命令行参数传递给Node.js程序的最佳方法是使用命令行界面(CLI)

您可以使用一个漂亮的npm模块,称为nodejs-cli

如果您想创建一个没有依赖性的程序,我想在我的Github上创建一个程序,如果您想查看它,它实际上非常简单易用,请单击此处


0

ES6样式的无依赖性解决方案:

const longArgs = arg => {
    const [ key, value ] = arg.split('=');
    return { [key.slice(2)]: value || true }
};

const flags = arg => [...arg.slice(1)].reduce((flagObj, f) => ({ ...flagObj, [f]: true }), {});


const args = () =>
    process.argv
        .slice(2)
        .reduce((args, arg) => ({
            ...args,
            ...((arg.startsWith('--') && longArgs(arg)) || (arg[0] === '-' && flags(arg)))
        }), {});
console.log(args());
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.