JavaScript's answer to getopts. Simple, obvious, and direct. 

alhadis

get-options

	 * @param {String|Array} names  - Comma-separated list of names (e.g., "-l, --long-list, --length")

* @param {String} params - List of args the option expects (e.g., "<num> <type>" or "[num] [type]", etc)

		/** Define the Option's names, both long and short forms */

			else longNames[i.replace(/^-+/, "")] = true;

		this.shortNames  = Object.keys(shortNames);

		this.longNames   = Object.keys(longNames);

		/** Parameters accepted/expected by this Option */

		/** Split our parameter list by whitespace */

		/** Remove punctuation added for readability */

params = params.map(e => e.replace(/^<(.+?)>$|^\[(.+?)\]$|^$(.+?)$$/gm, function(){

			return [].slice.call(arguments, 1, 4).filter(e => e).join("");

			/** Make sure the parameter isn't blank */

				/** Check for an additional regex pattern to use for disambiguating bundled options */

				let splitName = name.match(/^([^=]+)(?:=(.+)?)?$/);

	 * Return a regex string for matching this option when expressed in bundled short-form.

		/** We've already generated this regex before; just return the cached result */

		let param = this.params.map(p => "("+p.pattern+")?").join("");

		let names = this.shortNames.length === 1 ? this.shortNames[0] : ("[" + this.shortNames.join("") + "]");

		return (this._bundlePattern = names + param);

	 * Return the number of parameters this option expects/accepts.

		return this.params ? this.params.length : 0;

		/** Don't store solitary values in an array. Store them directly as strings */

		if(currentOption.arity === 1 && !currentOption.variadic)

	/** Reverses the argument order of the given array, keeping options and their parameter lists intact */

		/** Flip any options back into the right order */

for(let i = 0, l = input.length; i < l; ++i){

			let opt = shortNames[arg] || longNames[arg];

				let from    = Math.max(0, i - opt.arity);

				let extract = input.slice(from, to).reverse();

				input.splice(from, extract.length, ...extract);

	/** Tackle bundling: make sure there's at least one option with a short name to work with */

		bundlePatterns  = nameKeys.map(n => shortNames[n].getBundlePattern()).join("|");

		bundleMatch     = new RegExp("^-("+bundlePatterns+")+", "g");

		bundlePatterns  = new RegExp(bundlePatterns, "g");

	/** Is pre-processing of the argument list necessary? */

		/** Limit equals-sign expansion to items that begin with recognised option names */

		let legalNames = new RegExp("^(?:" + Object.keys(longNames).join("|") + ")=");

			/** Expand bundled option clusters ("-mvl2" -> "-m -v -l 2") */

				let segments = arg.match(bundlePatterns).map(m => {

					/** Obtain a pointer to the original Option instance that defined this short-name */

					/** This option doesn't accept any arguments, so just keep it simple */

					let matches = m.match(new RegExp(opt.getBundlePattern())).slice(1).filter(i => i);

			/** Expand "--option=value" sequences to become "--option value" */

				let match = arg.match(/^([^=]+)=(.+)$/);

				input.splice(i, 1, match[1], match[2]);

	/** If we're handling duplicate options with "limit-last", flip the input order */

	/** Start processing the arguments we were given to handle */

for(let i = 0, l = input.length; i < l; ++i){

		let opt = shortNames[arg] || longNames[arg];

		/** This argument matches a recognised option name */

			/** Record the name given on command-line that matched the option */

	"description": "JavaScript's answer to getopts. Simple, obvious, and direct.",

	"keywords": ["CLI", "getopt", "getopts", "options", "argv", "command-line", "configuration", "config"],

	"repository": "https://github.com/Alhadis/GetOptions",

The JavaScript equivalent of `getopts`. No frills, no bullshit; nothing but cold, hard option extraction.

* Are happy validating and type-checking input yourself

* Don't mind writing your own documentation

* Prefer a hands-on approach without pointless array-fiddling

<pre><code>$ program --log-path <ins>/var/log/stuff.txt</ins> generate all-files <ins>--verbose</ins></code></pre>

<pre><code>$ program generate all-files</code></pre>

... with everything neatly sorted into one little object:

"-s, --set-config": "<name> <value>",

"-f, --files": "<search-path> <variadic-file-list...>"

Short and long forms of each defined option, separated by commas.

Note: There's no requirement to enclose each parameter's name with `< > [ ] ( )`. These characters are just permitted for readability, and are ignored by the function when it runs. They're allowed because some authors might find them easier on the eyes than simple space-separation.

The value that's assigned to each corresponding `.options` property is either:  

* **Boolean `true`** if the option doesn't take any parameters (e.g., `"--verbose": ""`)

* **A string** holding the value of the option's only argument (e.g., `"--log-path": "path"`)

* **An array** if more than one parameter was specified. (e.g., `"-s, --set-config": "name value"`)

Given the earlier example, the following line...

<pre><code>program --files <ins>/search/path</ins> <ins>1.jpg</ins> <ins>2.txt</ins> <ins>3.gif</ins> --log-path <ins>/path/to/</ins> subcommand param --verbose</code></pre>

        files:   ["/search/path", "1.jpg", "2.txt", "3.gif"],

Yeah, that's it. You want fancy subcommands? Just leverage the `.argv` property of the returned object:

        console.log("Let's generate... " + whichFiles);

subcommands[ result.argv[0] ].apply(null, result.argv.slice(1));

* No typecasting is performed on user input. Values will *always* be stored as strings.

* This is pure JavaScript, so it's not reliant on Node to work. Feel free to use it in a browser environment or whatever.

* The array that's passed to the function isn't modified. If you want to overwrite the values stored in `process.argv`, do so by assignment:

<pre><code>process.argv = result.argv;</code></pre>

This is by design. It's not reasonable to assume developers will expect the contents of the array to be automatically shifted as options are being plucked from it.

* As you'd expect, the first two values in `process.argv` contain the paths of the Node executable and the currently-running script.

  These have been omitted from the examples documented here (perhaps misleadingly, but done so for brevity's sake).

  In production, you'd probably want to pass `process.argv.slice(2)` to `getOpts` or something.

Yeah, there's billions of CLI-handling modules on NPM. Among the most well-known and popular are [Commander.JS](https://github.com/tj/commander.js) and [yargs](https://www.npmjs.com/package/yargs). Since I'm a control freak, though, I prefer doing things my way. So I developed a solution that'd permit more idiosyncratic approaches than those offered by "mainstream" option modules.

	it("Parse bundled short-options", function(){

			let result = getOpts(i.input.split(/\s+/g), {

"-n, --number-of-lines": "<number=\\d+>",

"-l, --level": "<number=\\d+>",

"-d, --debug-level": "<number=\\d+>",

"-c, --config": "<key> <value>",

"-r, --range": "<min=\\d+> <max=\\d+>"

			}, {noAliasPropagation: "first-only"});

	it("Maintain correct argument and option order", function(){

			input: "-l 2 --set-size 640 480 -s alpha beta gamma",

			input: "foo -l 2 bar --set-size 640 480 760 -s alpha beta gamma",

				"-z, --set-size":         "[width=\\d+] [height=\\d+]",

"-c, --set-config": "<numbers=\\d+> <letters=[A-Za-z]+>",

"-d, --delete-files": "<safely> <files...>",

"-s, -T, --set-type": "<key> <type>"

	it("Parse variadic options", function(){

					files: ["one", "two", "three", "four", "five"]

			input: "-f one two three 4 5 -lA3 uno dos tres cuatro -n Ajaja",

					files: ["one", "two", "three", "4", "5"],

					list:  ["A", "3", "uno", "dos", "tres", "cuatro"],

"-l, --list": "<letter=[A-Za-z]> <integer=\\d+> <mystery...>",

		@@ -353,3 +353,3 @@ #!/usr/local/bin/node --es_staging
		/** Don't store solitary values in an array. Store them directly as strings */
		if(currentOption.arity === 1)
		if(currentOption.arity === 1 && !currentOption.variadic)
		optValue = optValue[0];
		@@ -356,0 +356,0 @@

		{
		"name": "get-options",
		"version": "1.0.0",
		"version": "1.0.1",
		"description": "JavaScript's answer to getopts. Simple, obvious, and direct.",
		@@ -5,0 +5,0 @@ "keywords": ["CLI", "getopt", "getopts", "options", "argv", "command-line", "configuration", "config"],

		@@ -125,2 +125,3 @@ GetOptions
		---------
		* No typecasting is performed on user input. Values will always be stored as strings.<br/><br/>
		* This is pure JavaScript, so it's not reliant on Node to work. Feel free to use it in a browser environment or whatever.<br/><br/>
		@@ -127,0 +128,0 @@ * The array that's passed to the function isn't modified. If you want to overwrite the values stored in `process.argv`, do so by assignment:

		@@ -97,2 +97,37 @@ "use strict";



		it("Parse variadic options", function(){

		let tests = [{
		input: "-f one two three four five",
		expected: {
		options: {
		files: ["one", "two", "three", "four", "five"]
		},
		argv: []
		}
		}, {
		input: "-f one two three 4 5 -lA3 uno dos tres cuatro -n Ajaja",
		expected: {
		options: {
		files: ["one", "two", "three", "4", "5"],
		list: ["A", "3", "uno", "dos", "tres", "cuatro"],
		name: "Ajaja"
		},
		argv: []
		}
		}];

		for(let i of tests){
		let result = getOpts(i.input.split(/\s+/g), {
		"-f, --files": "<list...>",
		"-l, --list": "<letter=[A-Za-z]> <integer=\\d+> <mystery...>",
		"-n, --name": "<name>"
		}, {noAliasPropagation: "first-only"});

		assert.deepEqual(result, i.expected);
		}
		});

		});

Improved metrics