如何将命令行参数传递给Node.js程序并接收它们？

Question

我有一个写入的web服务器节点.js我想用一个特定的文件夹启动。我不知道如何在JavaScript中访问参数。我这样运行node：

$node server.js文件夹

在这里服务器.js是我的服务器代码。Node.js帮助表示这是可能的：

$节点-h用法：node[options]script.js[arguments]

如何在JavaScript中访问这些参数？不知怎么的，我在网上找不到这些信息。

Answer 1

标准方法（无库）

参数存储在处理argv

这里有节点文档介绍了如何处理命令行参数：

处理argv是包含命令行参数的数组。第一个元素是“node”，第二个元素是JavaScript文件的名称。接下来的元素是任何其他命令行参数。

//打印过程.argvprocess.argv.forEach（函数（val、索引、数组）{console.log（索引+'：'+val）；});

这将生成：

$node process-2js one two=三四0:节点1:/Users/mjr/work/node/process-2.js2:一个3:2=34:四

Answer 2

要像常规javascript函数接收的那样规范化参数，我在我的node.js shell脚本中这样做：

var args=进程.argv.slice（2）；

注意，第一个参数通常是指向nodejs的路径，第二个参数是正在执行的脚本的位置。

Answer 3

最新的正确的答案是使用最小主义者库。我们曾经使用节点乐观主义者但自那以后，它就被弃用了。

下面是一个直接取自最低限度文档的使用示例：

var argv=需要（'minimist'）（process.argv.slice（2））；控制台.dir（argv）；

-

$node示例/parse.js-a beep-b boop{_：[]，a:“哔”，b:“嘘”}

-

$node示例/parse.js-x 3-y 4-n5-abc--beep=boop foo bar baz{_：[“foo”，“bar”，“baz”]，x： 3、，y： 4、，n： 第5页，a： 是的，b： 是的，c： 是的，哔哔声：“boop”}

Answer 4

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

---

普通javascript参数解析：

const args=进程argv；控制台.log（args）；

这将返回：

$node-server.js一个二=三个四['node'，'/home/server.js'，'one'，'two=three'，'four']

官方文件

---

用于参数分析的最常用NPM包：

极简主义者：用于最小参数分析。

指挥官.js：参数分析最常用的模块。

喵：Commander.js的替代品更轻

雅格斯：更复杂的参数分析（重型）。

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

Answer 5

乐观主义者（节点乐观主义者）

结账优化程序库，它比手动解析命令行选项要好得多。

更新

乐观主义者已被弃用。尝试码这是乐观主义者的积极分叉。

Answer 6

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

常量getArgs=（）=>process.argv.reduce（（args，arg）=>{//长argif（参数切片（0，2）===“--”）{const longArg=arg.split（“=”）；const longArgFlag=longArg[0].slice（2）；const longArgValue=longArg.length>1？longArg[1]：true；args[longArgFlag]=longArg值；}//旗帜else if（arg[0]===“-”）{常量标志=arg.slice（1）.split（“”）；flags.forEach（（flag）=>{args[flag]=true；});}返回参数；}, {});const args=获取参数（）；控制台.log（args）；

示例

简单

输入

节点test.js-D--名称=您好

输出

{D:true，名称：“你好”}

真实世界

输入

节点配置/build.js-lHRs--ip=$HOST--port=$port--env=dev

输出

{ l： 是的，H： 是的，R： 是的，s： 是的，ip：“127.0.0.1”，端口：'8080'，env：“开发”}

Answer 7

这里有几个很好的答案，但看起来都很复杂。这与bash脚本访问参数值的方式非常相似，正如MooGoo指出的那样，它已经为node.js提供了标准。（只是为了让node.js新手能够理解它）

例子：

$node yourscript.js香蕉猴var program_name=进程.argv[0]//值将为“节点”var script_path=进程.argv[1]//值为“yourscript.js”var first_value=进程.argv[2]//价值将是“香蕉”var second_value=进程.argv[3]//值将为“monkey”

Answer 8

指挥官.js

非常适合定义选项、操作和参数。它还为您生成帮助页面。

及时

如果您喜欢回调方法，那么可以很好地从用户那里获取输入。

共同提示

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

Answer 9

Stdio图书馆

在NodeJS中解析命令行参数的最简单方法是使用标准输入输出模块。灵感来自UNIX获得选择权实用程序，如下所示：

var stdio=要求（'stdio'）；var ops=标准io.getopt({“check”：{key:“c”，args:2，description:“此选项的含义”}，“map”：{键：“m”，描述：“另一个描述”}，“kaka”：{参数：1，必需：true}，“ooo”：｛键：“o”｝});

如果使用此命令运行前面的代码：

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

然后操作对象如下：

{检查：[“23”，“45”]，参数：[“file1”，“file2”]，映射：true，卡卡：'23'}

所以你可以随意使用它。例如：

if（ops.kaka和ops.check）{console.log（ops.kaka+ops.check[0]）；}

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

此外，标准偏差可以自动生成帮助/用法输出。如果你打电话ops.printHelp（）您将获得以下信息：

用法：node something.js[--check<ARG1><ARG2>][--kaka][--ooo][--map]-c、 --检查<ARG1><ARG2>此选项的含义（强制）-k、 --卡卡（强制）--映射另一个描述-o、 --哦

如果未给定强制选项（前面有错误消息）或指定错误（例如，如果为选项指定了一个参数，而该参数需要2），也会显示上一条消息。

您可以安装标准件模块使用净现值法:

npm安装stdio

Answer 10

如果您的脚本名为myScript.js，并且您想将名字和姓氏“Sean Worthington”作为参数传递，如下所示：

节点myScript.js Sean Worthington

然后在脚本中写下：

var firstName=进程.argv[2]；//将设置为“Sean”var lastName=进程.argv[3]；//将设置为“沃辛顿”

Answer 11

Simple+ES6+no-dependency+支持布尔标志

const进程=require（“进程”）；const argv=键=>{//如果键存在且值未定义，则返回trueif（process.argv.includes（`-${key}`））返回true；const值=process.argv.find（element=>element.startsWith（`--${key}=`））；//如果键不存在且值未定义，则返回nullif（！value）返回null；return value.replace（`--${key}=`，''）；}

输出：

• 如果使用调用节点app.js然后argv（“oo”）将返回无效的
• 如果使用调用节点app.js—foo然后argv（“oo”）将返回真的
• 如果使用调用节点app.js—foo=然后argv（'fo'）将返回''
• 如果使用调用节点app.js--foo=bar然后argv（“oo”）将返回“bar”

Answer 12

命令行参数值得一看！

您可以使用主符号标准设置选项(了解更多信息). 这些命令都是等效的，设置相同的值：

$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$示例-vt 1000 one.js two.js

要访问这些值，首先创建一个列表选项定义描述应用程序接受的选项。这个类型属性是一个setter函数（通过它传递提供的值），使您能够完全控制接收的值。

const选项定义=[{name:“verbose”，别名：“v”，类型：Boolean}，{name:'src'，type:String，multiple:true，defaultOption:true}，{名称：'timeout'，别名：'t'，类型：数字}]

接下来，使用解析选项命令行参数（）:

const commandLineArgs=require（'command-line-args'）const options=commandLineArgs（optionDefinitions）

选项现在看起来像这样：

{源代码：[“one.js”，“两个.js”],verbose：true，超时：1000}

高级使用

除了上述典型用法之外，您还可以配置command-line-args以接受更高级的语法形式。

基于命令的语法（git样式）格式为：

$可执行文件<命令>[选项]

例如。

$git commit--squash-m“这是我的提交消息”

命令和子命令语法（docker样式）格式为：

$executable<命令>[选项]<子命令>[选项]

例如。

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

使用指南生成

使用指南（通常在以下情况下打印--帮助）可以使用生成命令行使用。请参阅以下示例和阅读文档获取如何创建它们的说明。

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

这个聚合物-氯化锂使用指南是一个很好的现实例子。

进一步阅读

还有很多东西要学，请看维基示例和文档。

Answer 13

以下是我对命名参数的0-dep解决方案：

const args=进程argv.切片（2）.map（arg=>arg.split（'='））.reduce（（args，[value，key]）=>{args[value]=键；返回参数；}, {});控制台.log（args.foo）控制台.log（args.fizz）

例子：

$node test.js foo=bar fizz=buzz酒吧嗡嗡声

注意：当参数包含=。这只是为了非常简单的使用。

Answer 14

有一个应用程序可以实现这一点。好吧，模块。嗯，不止一个，可能有数百个。

雅格斯是其中一个有趣的，它的文档读起来很酷。

以下是github/npm页面中的一个示例：

#!/usr/bin/env节点var argv=需要（'yargs'）.argv；控制台.log（“（%d，%d）”，argv.x，argv.j）；控制台日志（argv._）；

输出在这里（它读取带破折号等、短和长、数字等的选项）。

$ ./nonopt.js-x6.82-y3.35朗姆酒(6.82,3.35)[“朗姆酒”]$ ./nonopt.js“我的心”-x 0.54岁-y 1.12岁(0.54,1.12)[‘我的心’，‘哟’，‘呵呵’]

Answer 15

项目.js

for（var i=0；i<process.argv.length；i++）{控制台.log（进程.argv[i]）；}

终端：

节点程序应用程序.js“arg1”“arg2”“arg3”

结果：

0“C:\\Program Files\\nodejs\\node.exe”1'C:\\Users\\Nouman\\Desktop\\Node\\camer nodejs\\proj.js'2“arg1”是您通过的第一个参数。3“arg2”您传递的第二个参数。4“arg3”是您传递的第三个参数。

说明：

0. 计算机中node.exe的目录(C： \程序文件\ nodejs\ node.exe)
1. 项目文件的目录(项目.js)
2. 节点的第一个参数(参数1)
3. 节点的第二个参数(参数2)
4. 节点的第三个参数(参数3)

---

您的实际参数起始形式第二的索引自动变速箱数组，即进程.argv[2].

Answer 16

whithout库：使用Array.prototype.reduce（）

const args=进程.argv.slice（2）.reduce（（acc，arg）=>{让[k，v=true]=arg.split（'='）acc[k]=v返回acc}, {})

对于此命令节点index.js计数=2打印调试=false消息=hi

console.log（args）//{计数：“2”，打印：true，调试：“false”，消息：“hi”}

也，

我们可以改变

让[k，v=true]=arg.split（'='）acc[k]=v

比（更长）

让[k，v]=参数分割（'='）acc[k]=v===未定义？true:/true|false/.test（v）？v===“真”：/[\d|\.]+/.test（v）？编号（v）：v

自动解析布尔值（&N）

console.log（args）//{count:2，打印：true，调试：false，消息：hi}

Answer 17

基于标准输入分析参数(--key=值)

常数argv=（（）=>{常量参数={}；process.argv.slice（2）.map（（元素）=>{常量匹配=元素匹配（'--（[a-zA-Z0-9]+）=（.*）'）；if（匹配）{arguments[matches[1]=匹配[2].replace（/^['“]/，''）.replate（/[”“]$/，''”）；}});返回参数；})();

命令示例

节点app.js--name=stackoverflow--id=10另一个参数--text=“Hello World”

argv结果：控制台.log（argv）

{名称：“stackoverflow”，id:“10”，text:“你好，世界”}

Answer 18

本机方法

添加了Nodejs团队实用程序参数版本18.3.0和16.17.0中的功能。因此，如果您使用这些或更高版本的nodejs，您可以使用此本机解决方案解析命令行参数。parseArgs参数在v18之前是实验性的，在v20之后是稳定的。

文档中的用法示例：

const{parseArgs}=require（'node:util'）；const args=进程argv；常量选项={foo:{type:'布尔'，短：'f'},巴：{type:'string'}};常数{值，位置}=parseArgs（{args，options，allowPositionals:true}）；console.log（值）；控制台.log（位置）；

输出示例：

$node parseargs.js-f--条b[对象：空原型]{foo:true，bar:'b'}[“/Users/mbelsky/.nvm/versions/node/v18.12.1/bin/node”，'/Users/mbelsky/parseargs.js']

Answer 19

在节点代码中需要内置进程库。

const｛argv｝=require（“进程”）

用参数运行程序。

$node process-args.js one two=三四

argv是以下阵列：

argv[0]=/usr/bin/节点argv[1]=/home/user/process-args.jsargv[2]=一个argv[3]=二=三argv[4]=四

Answer 20

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

如果使用以下属性运行脚本

$节点args.js arg1 arg2

文件：args.js

console.log（进程.argv）

你会得到类似数组的

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

Answer 21

npm安装ps-grab

如果您想运行这样的程序：

node greeting.js--用户Abdennour--网站http://abdennoor.com

--

var grab=require（'ps-grab）；grab（'--username'）//return'Abdennour'抓取（'--action'）//返回'http://abdennoor.com'

---

或者类似于：

节点vbox.js-OS redhat-VM模板-12332；

--

var grab=require（'ps-grab）；grab（“-OS”）//返回“redhat”grab（'-VM'）//返回'template-12332'

Answer 22

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

文件：parse-cli-arguments.js：

module.exports=函数（requiredArguments）{var参数={}；for（var索引=0；索引<process.argv.length；索引++）{var re=新RegExp（'--（[A-Za-z0-9_]+）=（[A/-Za-zO-9_]+'），matches=re.exec（进程.argv[索引]）；if（匹配！==空）{arguments[匹配项[1]]=匹配项[2]；}}for（var index=0；index<requiredArguments.length；index++）{if（参数[requiredArguments[index]]===未定义）{throw（requiredArguments[index]+'未定义。请使用--'+requiredParguments[index]添加参数）；}}返回参数；}

不仅仅是这样：

var arguments=require（'./parse-cli-arguments'）（['foo'，'bar'，'xpto']）；

Answer 23

可以使用以下命令行参数系统参数。我使用下面的解决方案将参数解析为一个对象，这样我就可以通过名称找到我想要的对象。

var系统=要求（“系统”）；变量args={}；system.args.map（函数（x）{return x.split（“=”）}）.map（函数（y）{args[y[0]]=y[1]}）；

现在你不需要知道论点的索引。像这样使用参数.whatever

注意：您应该使用命名参数，如文件.js x=1 y=2使用这个解决方案。

Answer 24

传递参数很容易，接收参数只需读取进程。基本上，argv数组Node可以从任何地方访问。但您肯定想将它们作为键/值对来读取，所以您需要编写一段脚本来解释它。

Joseph Merdrignac使用reduce发布了一个漂亮的，但它依赖于key=值语法而不是-k值和--键值为了使用第二个标准，我把它改写得更难看更长了，我会把它作为答案发布，因为它不适合作为注释。但它确实完成了任务。

const args=进程.argv.slice（2）.reduce（（acc，arg，cur，arr）=>{if（参数匹配（/^--/））{acc[arg.substring（2）]=真acc['_lastkey']=参数子字符串（2）}其他if（参数匹配（/^-[^-]/））{for（arg.substring（1）.split（“”）的键）{acc[key]=真acc['_lastkey']=键}}其他if（acc['_lastkey']）{acc[acc['_lastkey']]=参数删除acc['_lastkey']}其他acc[arg]=真如果（cur==arr.length-1）删除acc['_lastkey']返回acc},{})

使用此代码可以执行命令节点script.js alpha beta-charlie delta--echo foxtrot会给你以下对象

参数={“阿尔法”：正确，“beta”：正确，“c”：正确，“h”：正确，“a”：正确，“r”：真“l”：正确，“i”：没错，“e”：“delta”，“echo”：“foxtrot”}

Answer 25

解决方案使用设置以解决使用简单参数（不带key+值）时的位置问题。

例如，这两个命令将返回相同的结果：

节点服务器.js详细信息json节点服务器.js-json详细信息

const args=新集合（process.argv.slice（2））；

然后可以使用args.has（'详细信息'）或args.has（“json”）不用担心位置。

Answer 26

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

npm i码const-yargs=要求（“yargs”）；常量argv=yargs.argv；控制台.log（argv）；

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

Answer 27

没有库的TypeScript解决方案：

接口IParams{[key:string]：string}函数parseCliParams（）：IParams{常量参数：IParams={}；const rawArgs=进程.argv.slice（2，进程.argv-length）；rawArgs.forEach（（arg:string，index）=>{//带“--”标志的长参数：if（arg.sice（0，2）.includes（'-'））{const longArgKey=arg.slice（2，arg.length）；const longArgValue=rawArgs[索引+1]；//下一个值，例如：--connection connection_nameargs[longArgKey]=longArg值；}//带有“-”标志的快照参数：else if（arg.slice（0，1）.includes（'-'））{const longArgKey=arg.slice（1，arg.length）；const longArgValue=rawArgs[索引+1]；//下一个值，例如：-c connection_nameargs[longArgKey]=longArg值；}});返回参数；}const参数=parseCliParams（）；console.log（'params:'，params）；

输入：ts-node index.js-p param——参数参数

输出：{p:“param”，参数：“parameter”}

Answer 28

没有库

如果您想在普通JS/ES6中执行此操作，可以使用以下解决方案

仅在中工作节点JS>6

常量args=进程.argv.切片（2）.map（（val，i）=>{让对象={}；让[regexForProp，regexForVal]=（（）=>[new RegExp（'^（.+？）='），new RegExp（'\=（.*）'）]）（）；let[prop，value]=（（）=>[regexForProp.exec（val），regexForVal.exec[val）]）（）；if（！道具）{对象[val]=true；返回对象；}其他{object[prop[1]=值[1]；回波信号}}).reduce（（对象，项）=>{let prop=Object.keys（item）[0]；obj[prop]=项目[prop]；返回对象；}, {});

还有这个命令

节点index.js主机=http://google.com端口=8080生产

将产生以下结果

控制台.log（args）//{主机：'http://google.com'，端口：'8080'，生产：true}console.log（args.host）//http://google.comconsole.log（args.port）//8080console.log（args.production）//真的

p.s.请更正地图中的代码并减少功能如果您找到更优雅的解决方案，谢谢；）

Answer 29

在Node.js中检索参数的最简单方法是通过process.argv数组。这是一个全局对象，您可以使用它，而无需导入任何其他库来使用它。您只需将参数传递给Node.js应用程序，正如我们前面所示，并且可以通过process.argv数组在应用程序中访问这些参数。

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

'使用严格'；for（设j=0；j<process.argv.length；j++）{控制台.log（j+'->'+（process.argv[j]））；}

该脚本所做的只是循环遍历process.argv数组并打印索引以及存储在这些索引中的元素。如果您对接收到的参数以及顺序有疑问，这对于调试非常有用。

您还可以使用yargs之类的库来处理命令行参数。

Answer 30

您可以从以下位置获取命令行信息process.argv（）

我不想把问题局限于节点.js相反，我想把它转化为如何将字符串解析为参数。

console.log（ArgumentParser（`--debug--msg=“Hello World”--title=“Test”--desc=demo-open--level=5--MyFloat=3.14`））

输出

{“调试”：true，“msg”：“你好，世界”，“title”：“测试”，“desc”：“演示”，“打开”：true，“级别”：5，“MyFloat”：3.14}

代码

纯javascript，无需依赖性

// 👇 下面是测试(() => {window.onload=（）=>{const测试数组=[`--debug--msg=“Hello World”--title=“Test”--desc=demo-open--level=5--MyFloat=3.14`，]for（testArray的const testData）{尝试{const obj=参数分析器（testData）控制台.log（obj）}捕捉（e）{控制台错误（e.message）}}}})()// 👇 脚本类ParserError扩展错误{}函数光标（str，pos）{this.str=字符串this.pos=位置这个。向右移动=（步长=1）=>{this.pos+=步骤}这个。移动到下一个Para=（）=>{const curStr=this.str.substring（this.pos）常量匹配=/^（？<全部>*--？（？<名称>[a-zA-Z_][a-zA-Z0-9_]*）（=（？<值>[^-]*）？）/g.exec（curStr）//https://regex101.com/r/k004Gv/2if（匹配）{让{groups:{all，name，value}}=matchif（值！==未定义）{value=value.trim（）if（value.slice（0，1）===“”）{//stringif（value.slice（-1）！=='"') {throw new ParserError（应为“Parsing error:”“”）}value=value.slice（1，-1）}else{//数字或字符串（不带“”）value=isNaN（数字（值））？字符串（值）：数字（值）}}这个。向右移动（全部长度）return[name，value？？true]//如果值未定义，则将其设置为true。}抛出新的ParserError（`检测到非法格式。$｛curStr｝`）}}函数ArgumentParser（str）{常量obj=｛｝常量光标=新光标（str，0）而（1）{const[name，value]=光标。移至下一段落（）obj[名称]=值if（cursor.pos===str.length）{返回对象}}}