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

我有一个写在web服务器，我想启动一个特定的文件夹。我不知道如何访问JavaScript中的参数。我运行的节点如下所示：

$ node server.js folder

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

这里

server.js

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

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

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

标准方法（无库） 参数存储在

process.argv

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

这是

---

process.argv

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

//print process.argv
process.argv.forEach（函数（val、索引、数组）{
log（索引+'：'+val）；
});

这将产生：

$node process-2.js一二=三四
0:节点
1:/Users/mjr/work/node/process-2.js
2:1
3:2=3
4:4

为了像常规javascript函数一样规范化参数，我在node.js shell脚本中执行以下操作：

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

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

Optimist（node Optimist） 请注意，这比手工解析命令行选项要好得多

更新

乐观主义者不受欢迎。试试哪一个是积极的乐观主义者

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

如果您喜欢回调方法，那么它非常适合从用户那里获取输入

---

如果您喜欢generator方法，那么它非常适合从用户处获取输入。

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

斯特迪奥图书馆 解析NodeJS中命令行参数的最简单方法是使用模块。受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'}
});

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

如果使用此命令运行上一个代码：

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

所以你可以随心所欲地使用它。例如：

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

---

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

文件：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;
}

---

这里有几个很好的答案，但看起来都很复杂。这与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"

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

最新的正确答案是使用图书馆。我们曾经使用过，但后来被弃用了

下面是一个如何使用它的示例，直接取自最低标准文档：

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

-

-

---

有一个应用程序。嗯，模块。嗯，不止一个，可能有几百个

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

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

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

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

值得一看

可以使用主符号标准（）设置选项。这些命令都是等效的，设置相同的值：

$ 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

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

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

接下来，使用以下命令分析选项：

选项

现在看起来像这样：

$ node server.js folder

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

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

（git样式）格式为：

$ executable <command> [options]

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

（docker样式）格式为：

$ executable <command> [options]

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

使用指南生成 可以使用生成使用指南（通常在设置了

--help

时打印）。请参阅下面的示例和有关如何创建它们的说明

一个典型的使用指南示例

《使用指南》是一个很好的现实例子

进一步阅读

---

还有很多内容需要学习，请参阅示例和文档。

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

如果您使用下面的atguments运行脚本

$ node args.js arg1 arg2

文件：args.js

console.log(process.argv)

你会得到一个数组

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

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

---

普通javascript参数解析： 这将返回：

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

---

用于参数解析的最常用NPM包： ：用于最小参数解析

npm install ps-grab

：参数解析最常用的模块

npm install ps-grab

：Commander.js的更轻替代品

：更复杂的参数解析（繁重）

：具有参数解析的成熟/交互式命令行应用程序

npm install ps-grab

如果要运行类似以下内容： --

---

或者类似于：

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

--

---

您可以使用

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.which那样使用它

注意：您应该使用像
file.js x=1 y=2这样的命名参数来使用
这个解决方案

没有图书馆
如果您想在vanilla JS/ES6中实现这一点，可以使用以下解决方案

只在
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'

var system = require('system');

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

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

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

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

}, {})

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

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

 $ 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

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

'use strict';

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

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

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.

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

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

   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
   },{})


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

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

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 another-argument --text="Hello World"

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

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