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

Posted 2023-03-07

【中文标题】如何将命令行参数传递给 Node.js 程序？

【英文标题】：How do I pass command line arguments to a Node.js program?

【发布时间】：2011-05-20 02:06:05

【问题描述】：

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

$ node server.js folder

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

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

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

【问题讨论】：

使用 nconf github.com/flatiron/nconf 之类的方式集中管理配置可能是个好主意，它可以帮助您处理配置文件、环境变量、命令行参数.

这里是configvention，我自己的、最小的、只读的nconf接口。

【参考方案1】：

标准方法（无库）

参数存储在process.argv

这里是the node docs on handling command line args:

process.argv 是一个包含命令行参数的数组。第一个元素是“节点”，第二个元素是 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

【讨论】：

第二个元素（process.argv[1]）可能是也可能不是js文件。节点命令语法为 node [options] [ -e script | script.js ] [arguments] 或 node debug script.js [arguments]。例如：node --harmony script.js balala 或 node --no-deprecation --enable-ssl2 script.js balala ，我们可以使用 process.execArgv 和 process.argv

【参考方案2】：

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

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

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

【讨论】：

请注意，我在 4 年前写了这个答案，而我正在运行的代码今天仍然可以 100% 运行。仍然与最新版本的节点保持同步，并且仍然是零问题：这只是一个简单的 shell 脚本。不是一个充满 JS 库的大型全局对象的一部分。我今天仍然支持我的答案。我将在 4 年后再次更新。

已经6年多了。有更新吗？

【参考方案3】：

最新的正确答案是使用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' 

【讨论】：

实际上，这个解决方案对于开发具有更多标志和参数的命令行工具更有帮助，应该更多地支持恕我直言。

【参考方案4】：

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

---

原版 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：具有参数解析的成熟/交互式命令行应用程序。

【讨论】：

"$ npm install -g yargs" 产生了 1.9 MB 的 JavaScript 代码。当一个 argv 解析器库需要两兆字节的代码时，这种疯狂何时结束？增加攻击面，浪费内存等......

选择自定义 arg 的简单方法： const list_arg = process.argv.filter((arg) => (['-list', '-l'].includes(arg))).toString ();

【参考方案5】：

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

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

更新

乐观主义者已被弃用。试试yargs，它是乐观主义者的活跃分支。

【讨论】：

链接+1。在github.com/joyent/node/wiki/modules#wiki-parsers-commandline

有很长的命令行选项解析器列表

【参考方案6】：

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

【参考方案7】：

Commander.js

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

Promptly

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

Co-Prompt

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

【讨论】：

@Evan Carroll 请不要编辑我的答案来推广我不使用***.com/posts/7483600/revisions 的库，尤其是因为你缺少一个功能，这些意见应该保存给 cmets 或 pull向模块作者提出请求，而不是编辑其他人的答案。

【参考方案8】：

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

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'

【讨论】：

.slice(2, process.argv.length) 第二个参数不是多余的吗？ .slice() 默认跳转到字符串的末尾。

【参考方案9】：

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

【参考方案10】：

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

【参考方案11】：

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 函数（提供的值通过 this 传递），让您可以完全控制接收到的值。

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-line-args 以接受更高级的语法形式。

Command-based syntax（git 风格）的形式：

$ 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。

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

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

进一步阅读

还有很多要学习的内容，请参阅 the wiki 获取示例和文档。

【参考方案12】：

这是我的命名参数的 0-dep 解决方案：

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】：

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

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

【参考方案14】：

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.

说明：

你机器中node.exe的目录(C:\Program Files\nodejs\node.exe) 项目文件的目录 (proj.js) 节点的第一个参数 (arg1) 节点的第二个参数 (arg2) 节点的第三个参数 (arg3)

---

你的实际参数从argv数组的second索引开始，即process.argv[2]。

【参考方案15】：

基于标准输入（--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=*** --id=10 another-argument --text="Hello World"

argv 的结果：console.log(argv)

    name: "***",
    id: "10",
    text: "Hello World"

【参考方案16】：

没有库：使用 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' 

【参考方案17】：

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

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

$ node args.js arg1 arg2

文件：args.js

console.log(process.argv)

你会得到像这样的数组

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

【参考方案18】：

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'

【参考方案19】：

简单 + 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 =` , '' );

输出：

如果使用node app.js 调用，则argv('foo') 将返回null 如果使用node app.js --foo 调用，则argv('foo') 将返回true 如果使用node app.js --foo= 调用，则argv('foo') 将返回'' 如果使用node app.js --foo=bar 调用，则argv('foo') 将返回'bar'

【讨论】：

您的解决方案非常时尚。谢谢！

【参考方案20】：

您可以使用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 这样的命名参数来使用 这个解决方案。

【参考方案21】：

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

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

【参考方案22】：

传递参数很容易，接收它们只需读取 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"

【参考方案23】：

虽然上面的答案是完美的，并且有人已经建议了 yargs，但是使用这个包真的很容易。 这是一个很好的包，它使向命令行传递参数变得非常容易。

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

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

【讨论】：

Yargs 不会影响参数在命令行中的传递方式，它只会帮助在代码中读取它们。

【参考方案24】：

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

【参考方案25】：

没有库

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

附言请更正map和reduce函数中的代码 如果您找到更优雅的解决方案，谢谢;)

【讨论】：

我同意，但它可以更短吗？ let args = process.argv.slice(2).reduce((acc, arg) => let [k, v] = arg.split('=') acc[k] = v return acc , )

【参考方案26】：

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

【参考方案27】：

process.argv 是你的朋友，Node JS 原生支持捕获命令行参数。见下面的例子::

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

【参考方案28】：

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

【讨论】：

这样写太多 es6 会让人第一眼觉得代码不可读

【参考方案29】：

我扩展了getArgs 函数只是为了获取命令、标志（-f、--anotherflag）和命名参数（--data=blablabla）：

模块

/**
 * @module getArgs.js
 * get command line arguments (commands, named arguments, flags)
 *
 * @see https://***.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 

使用示例：

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

【参考方案30】：

您可以从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