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

Simple+ES6+无依赖项+支持布尔标志

const process = require( 'process' );

const argv = key => {
  // Return true if the key exists and a value is defined
  if ( process.argv.includes( `--${ key }` ) ) return true;

  const value = process.argv.find( element => element.startsWith( `--${ key }=` ) );

  // Return null if the key does not exist and a value is not defined
  if ( !value ) return null;
  
  return value.replace( `--${ key }=` , '' );
}

输出：

如果使用节点app.js调用，则argv（'fo'）将返回null如果使用节点app.js--foo调用，则argv（'fo'）将返回true如果使用节点app.js调用--foo=，则argv（'fo'）将返回“”如果使用节点app.js--foo=bar调用，则argv（'fo'）将返回'bar'

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

文件：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']);

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

没有库

如果您想在vanilla 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

p.s.请更正map和reduce函数中的代码如果您找到更优雅的解决方案，谢谢；）

在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等库来处理命令行参数。