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

时间:2010-12-04 01:56:46

标签: javascript node.js arguments command-line-arguments

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

$ node server.js folder

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

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

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

35 个答案:

答案 0 :(得分:2770)

标准方法(无库)

参数存储在process.argv

以下是the node docs on handling command line args:

  

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

答案 1 :(得分:584)

为了规范化常规javascript函数会收到的参数,我在node.js shell脚本中执行此操作:

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

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

答案 2 :(得分:304)

最新的正确答案,以便使用minimist库。我们曾经使用过node-optimist,但后来被弃用了。

以下是直接从最小化文档中使用它的示例:

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

答案 3 :(得分:270)

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

Vanilla javascript参数解析:

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

返回:

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

Official docs

最常用的NPM包用于参数解析:

Minimist :用于最小化参数解析。

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

Meow :更轻松的替代Commander.js

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

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

答案 4 :(得分:115)

Optimist(节点乐观主义者)

查看optimist library,它比手动解析命令行选项要好得多。

<强>更新

不推荐使用Optimist。试试yargs这是乐观主义者的活跃分支。

答案 5 :(得分:85)

这里有几个很好的答案,但这一切似乎都非常复杂。这与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"

答案 6 :(得分:72)

Commander.js

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

Promptly

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

Co-Prompt

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

答案 7 :(得分:42)

Stdio Library

在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, mandatory: 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),则还会显示上一条消息。

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

npm install stdio

答案 8 :(得分:38)

如果您的脚本名为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'

答案 9 :(得分:24)

command-line-args值得一看!

您可以使用主要标记标准(learn more)设置选项。这些命令都是等效的,设置相同的值:

$ 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

要访问这些值,请先创建一个option definitions列表,说明您的应用程序接受的选项。 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
}

高级用法

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

Command-based syntax(git style)格式:

$ executable <command> [options]

例如。

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

Command and sub-command syntax(码头工具样式)格式为:

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

例如。

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

使用指南生成

可以使用command-line-usage生成使用指南(通常在设置--help时打印)。请参阅下面的示例和read the documentation,了解如何创建它们的说明。

典型的使用指南示例。

usage

polymer-cli使用指南是一个很好的现实生活示例。

usage

进一步阅读

还有很多需要学习的内容,请参阅the wiki了解示例和文档。

答案 10 :(得分:23)

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

if(!file_exists($file)){
    continue;
}            

$reader = \PhpOffice\PhpSpreadsheet\IOFactory::createReader("Xlsx");
$reader-&gt;setReadDataOnly(true);
$spreadsheet = $reader-&gt;load($file);

foreach($spreadsheet-&gt;getSheetNames() as $sheet_name ){
    $clonedWorksheet = clone $spreadsheet-&gt;getSheetByName($sheet_name);
    $clonedWorksheet-&gt;setTitle($sheet_name);
    $merge_spreadsheet-&gt;addSheet($clonedWorksheet);                
}

示例

简单

输入

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

答案 11 :(得分:21)

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

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

答案 12 :(得分:11)

这是我的0-dep解决方案,用于命名参数:

package-lock.json

示例:

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 时,自然会失败。这仅是非常简单的用法。

答案 13 :(得分:10)

没有librairies:使用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

自动解析布尔&amp;编号

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

答案 14 :(得分:9)

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

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

$ node args.js arg1 arg2

档案:args.js

console.log(process.argv)

您将获得类似

的数组
 ['node','args.js','arg1','arg2']

答案 15 :(得分:9)

使用 nconf https://github.com/flatiron/nconf

等内容集中管理配置可能是一个好主意。

它可以帮助您处理配置文件,环境变量,命令行参数。

答案 16 :(得分:7)

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'

答案 17 :(得分:7)

您可以使用$config['components']['urlManager'] = [ ... 'rules' => [ 'GET myContlr/<id:\d+>' => 'myContlr/view', 'PUT myContlr/<id:\d+>' => 'myContlr/update', 'DELETE myContlr/<id:\d+>' => 'myContlr/delete', 'GET myContlr' => 'myContlr/index', 访问命令行参数。我使用下面的解决方案将参数解析为一个对象,所以我可以通过名称得到我想要的那个。

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之类的命名参数   这个解决方案。

答案 18 :(得分:6)

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

file: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']);

答案 19 :(得分:6)

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:节点(arg2)的第二个参数

4:您对节点(arg3)的第三个参数

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

答案 20 :(得分:4)

没有库

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

仅适用于 NodeJS&gt; 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

P.S。请更正地图中的代码并减少功能 如果你找到更优雅的解决方案,谢谢;)

答案 21 :(得分: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参数。

答案 22 :(得分:3)

没有库的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' }

答案 23 :(得分:1)

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

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

请访问https://yargs.js.org/以获取更多信息。

答案 24 :(得分:1)

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

Joseph Merdrignac发布了一个使用reduce的漂亮文章,但是它依靠key=value语法而不是-k value--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"
}

答案 25 :(得分:0)

process.argv是你的朋友,在Node JS中本机支持捕获命令行args。见下面的例子::

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

答案 26 :(得分: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

答案 27 :(得分: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

答案 28 :(得分:0)

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

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

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

答案 29 :(得分: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());

答案 30 :(得分:0)

我扩展了getArgs函数只是为了获得命令,标志(-f--anotherflag)和命名参数(--data=blablabla):

  1. 模块
/**
 * @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 }

  1. 用法示例:
$ 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' ]
}

答案 31 :(得分:0)

如果您想使用像 server -f fileURI 这样的 unix 样式标志,请使用 NodeJS 的 ray-fs 库。它非常易于使用!

答案 32 :(得分:0)

您可以从 process.argv()

获取命令行信息

而且我不想将问题限制在 node.js。相反,我想把它变成如何将字符串解析为参数。

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

输出

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

代码

纯javascript,不需要依赖

// ? 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
    }
  }
}

答案 33 :(得分:-1)

基于标准输入(--key=value)解析参数

const argv = (() => {
    const arguments = {};
    process.argv.slice(2).map( (element) => {
        const matches = element.match( '--([a-zA-Z0-9]+)=(.*)');
        if ( matches ){
            arguments[matches[1]] = matches[2]
                .replace(/^['"]/, '').replace(/['"]$/, '');
        }
    });
    return arguments;
})();

命令示例

node app.js --name=stackoverflow --id=10 some-another-argument --text="Hello World"

argv的结果:console.log(argv)

{
    name: "stackoverflow",
    id: "10",
    text: "Hello World"
}

答案 34 :(得分:-4)

一个简单的片段,如果有的话:

var fs = require('fs'), objMod = {};

process.argv.slice(2).map(function(y, i) {
  y = y.split('=');
  if (y[0] && y[1]) objMod[y[0]] = y[1];
  else console.log('Error in argument number ' + (i+1));
});