A light, featureful and explicit option parsing library for node.js.
Why another one? See below. tl;dr: The others I've tried are one of too loosey goosey (not explicit), too big/too many deps, or ill specified. YMMV.
Some example output from this script (foo.js):
See the "examples" dir for a number of starter examples using some of dashdash's features.
then the "FOOVERBOSE" environment variable can be used to set this option:
Boolean options will interpret the empty string as unset, '0' as false and anything else as true.
Non-booleans can be used as well. Strings:
Numbers:
With the
Dashdash will return bash completion file content given a parser instance:
You could add a
See examples/ddcompletion.js for a complete example, including how one can define bash functions for completion of custom option types. Also see node-cmdln for how it uses this for Bash completion for full multi-subcommand tools.
Caveat: When a shortopt group, such as
Consider if you have a known short option
Each option spec in the
An environment variable is only used as a fallback, i.e. it is ignored if the associated option is given in
Note: You can use an empty string,
Why another one? See below. tl;dr: The others I've tried are one of too loosey goosey (not explicit), too big/too many deps, or ill specified. YMMV.
Install
npm install dashdash
Active Versions
- 2.x - Version 2.x
- 1.x - This version
Usage
var dashdash = require('dashdash');
// Specify the options. Minimally `name` (or `names`) and `type`
// must be given for each.
var options = [
{
// `names` or a single `name`. First element is the `opts.KEY`.
names: ['help', 'h'],
// See "Option specs" below for types.
type: 'bool',
help: 'Print this help and exit.'
}
];
// Shortcut form. As called it infers `process.argv`. See below for
// the longer form to use methods like `.help()` on the Parser object.
var opts = dashdash.parse({options: options});
console.log("opts:", opts);
console.log("args:", opts._args);
Longer Example
A more realistic starter script "foo.js" is as follows.
This also shows using parser.help()
for formatted option help.var dashdash = require('dashdash');
var options = [
{
name: 'version',
type: 'bool',
help: 'Print tool version and exit.'
},
{
names: ['help', 'h'],
type: 'bool',
help: 'Print this help and exit.'
},
{
names: ['verbose', 'v'],
type: 'arrayOfBool',
help: 'Verbose output. Use multiple times for more verbose.'
},
{
names: ['file', 'f'],
type: 'string',
help: 'File to process',
helpArg: 'FILE'
}
];
var parser = dashdash.createParser({options: options});
try {
var opts = parser.parse(process.argv);
} catch (e) {
console.error('foo: error: %s', e.message);
process.exit(1);
}
console.log("# opts:", opts);
console.log("# args:", opts._args);
// Use `parser.help()` for formatted options help.
if (opts.help) {
var help = parser.help({includeEnv: true}).trimRight();
console.log('usage: node foo.js [OPTIONS]\n'
+ 'options:\n'
+ help);
process.exit(0);
}
// ...
Some example output from this script (foo.js):
$ node foo.js -h
# opts: { help: true,
_order: [ { name: 'help', value: true, from: 'argv' } ],
_args: [] }
# args: []
usage: node foo.js [OPTIONS]
options:
--version Print tool version and exit.
-h, --help Print this help and exit.
-v, --verbose Verbose output. Use multiple times for more verbose.
-f FILE, --file=FILE File to process
$ node foo.js -v
# opts: { verbose: [ true ],
_order: [ { name: 'verbose', value: true, from: 'argv' } ],
_args: [] }
# args: []
$ node foo.js --version arg1
# opts: { version: true,
_order: [ { name: 'version', value: true, from: 'argv' } ],
_args: [ 'arg1' ] }
# args: [ 'arg1' ]
$ node foo.js -f bar.txt
# opts: { file: 'bar.txt',
_order: [ { name: 'file', value: 'bar.txt', from: 'argv' } ],
_args: [] }
# args: []
$ node foo.js -vvv --file=blah
# opts: { verbose: [ true, true, true ],
file: 'blah',
_order:
[ { name: 'verbose', value: true, from: 'argv' },
{ name: 'verbose', value: true, from: 'argv' },
{ name: 'verbose', value: true, from: 'argv' },
{ name: 'file', value: 'blah', from: 'argv' } ],
_args: [] }
# args: []
See the "examples" dir for a number of starter examples using some of dashdash's features.
Environment variable integration
If you want to allow environment variables to specify options to your tool,
dashdash makes this easy. We can change the 'verbose' option in the example
above to include an 'env' field:{
names: ['verbose', 'v'],
type: 'arrayOfBool',
env: 'FOO_VERBOSE', // <--- add this line
help: 'Verbose output. Use multiple times for more verbose.'
},
then the "FOOVERBOSE" environment variable can be used to set this option:
$ FOO_VERBOSE=1 node foo.js
# opts: { verbose: [ true ],
_order: [ { name: 'verbose', value: true, from: 'env' } ],
_args: [] }
# args: []
Boolean options will interpret the empty string as unset, '0' as false and anything else as true.
$ FOO_VERBOSE= node examples/foo.js # not set
# opts: { _order: [], _args: [] }
# args: []
$ FOO_VERBOSE=0 node examples/foo.js # '0' is false
# opts: { verbose: [ false ],
_order: [ { key: 'verbose', value: false, from: 'env' } ],
_args: [] }
# args: []
$ FOO_VERBOSE=1 node examples/foo.js # true
# opts: { verbose: [ true ],
_order: [ { key: 'verbose', value: true, from: 'env' } ],
_args: [] }
# args: []
$ FOO_VERBOSE=boogabooga node examples/foo.js # true
# opts: { verbose: [ true ],
_order: [ { key: 'verbose', value: true, from: 'env' } ],
_args: [] }
# args: []
Non-booleans can be used as well. Strings:
$ FOO_FILE=data.txt node examples/foo.js
# opts: { file: 'data.txt',
_order: [ { key: 'file', value: 'data.txt', from: 'env' } ],
_args: [] }
# args: []
Numbers:
$ FOO_TIMEOUT=5000 node examples/foo.js
# opts: { timeout: 5000,
_order: [ { key: 'timeout', value: 5000, from: 'env' } ],
_args: [] }
# args: []
$ FOO_TIMEOUT=blarg node examples/foo.js
foo: error: arg for "FOO_TIMEOUT" is not a positive integer: "blarg"
With the
includeEnv: true
config to parser.help()
the environment
variable can also be included in help output:usage: node foo.js [OPTIONS]
options:
--version Print tool version and exit.
-h, --help Print this help and exit.
-v, --verbose Verbose output. Use multiple times for more verbose.
Environment: FOO_VERBOSE=1
-f FILE, --file=FILE File to process
Bash completion
Dashdash provides a simple way to create a Bash completion file that you
can place in your "bashcompletion.d" directory -- sometimes that is
"/usr/local/etc/bashcompletion.d/"). Features:- Support for short and long opts
- Support for knowing which options take arguments
- Support for subcommands (e.g. 'git log ' to show just options for the
- Does the right thing with "--" to stop options.
- Custom optarg and arg types for custom completions.
Dashdash will return bash completion file content given a parser instance:
var parser = dashdash.createParser({options: options});
console.log( parser.bashCompletion({name: 'mycli'}) );
or directly from a options
array of options specs:var code = dashdash.bashCompletionFromOptions({
name: 'mycli',
options: OPTIONS
});
Write that content to "/usr/local/etc/bashcompletion.d/mycli" and you will
have Bash completions for mycli
. Alternatively you can write it to
any file (e.g. "~/.bashrc") and source it.You could add a
--completion
hidden option to your tool that emits the
completion content and document for your users to call that to install
Bash completions.See examples/ddcompletion.js for a complete example, including how one can define bash functions for completion of custom option types. Also see node-cmdln for how it uses this for Bash completion for full multi-subcommand tools.
- TODO: document specExtra
- TODO: document includeHidden
- TODO: document custom types,
function complete\_FOO
guide, completionType - TODO: document argtypes
Parser config
Parser construction (i.e. dashdash.createParser(CONFIG)
) takes the
following fields:options
(Array of option specs). Required. See the
interspersed
(Boolean). Optional. Default is true. If true this allows
node ./tool.js -v arg1 arg2 -h # '-h' is after interspersed args
Set it to false to have '-h' not get parsed as an option in the above
example.allowUnknown
(Boolean). Optional. Default is false. If false, this causes
node ./tool.js -v arg1 --afe8asefksjefhas
Set it to true to treat the unknown option as a positional
argument.Caveat: When a shortopt group, such as
-xaz
contains a mix of
known and unknown options, the entire group is passed through
unmolested as a positional argument.Consider if you have a known short option
-a
, and parse the
following command line:node ./tool.js -xaz
where -x
and -z
are unknown. There are multiple ways to
interpret this:1. `-x` takes a value: `{x: 'az'}`
2. `-x` and `-z` are both booleans: `{x:true,a:true,z:true}`
Since dashdash does not know what -x
and -z
are, it can't know
if you'd prefer to receive {a:true,_args:['-x','-z']}
or
{x:'az'}
, or {_args:['-xaz']}
. Leaving the positional arg unprocessed
is the easiest mistake for the user to recover from.Option specs
Example using all fields (required fields are noted):{
names: ['file', 'f'], // Required (one of `names` or `name`).
type: 'string', // Required.
completionType: 'filename',
env: 'MYTOOL_FILE',
help: 'Config file to load before running "mytool"',
helpArg: 'PATH',
helpWrap: false,
default: path.resolve(process.env.HOME, '.mytoolrc')
}
Each option spec in the
options
array must/can have the following fields:name
(String) ornames
(Array). Required. These give the option name
opts
object.type
(String). Required. One of:
- bool
- string
- number
- integer
- positiveInteger
- date (epoch seconds, e.g. 1396031701, or ISO 8601 format
`YYYY-MM-DD[THH:MM:SS[.sss][Z]]`, e.g. "2014-03-28T18:35:01.489Z")
- arrayOfBool
- arrayOfString
- arrayOfNumber
- arrayOfInteger
- arrayOfPositiveInteger
- arrayOfDate
FWIW, these names attempt to match with asserts on
assert-plus.
You can add your own custom option types with dashdash.addOptionType
.
See below.completionType
(String). Optional. This is used for Bash
type
is used. Any string may be specified, but only the
following values have meaning:- `none`: Provide no completions.
- `file`: Bash's default completion (i.e. `complete -o default`), which
includes filenames.
- *Any string FOO for which a `function complete_FOO` Bash function is
defined.* This is for custom completions for a given tool. Typically
these custom functions are provided in the `specExtra` argument to
`dashdash.bashCompletionFromOptions()`. See
["examples/ddcompletion.js"](examples/ddcompletion.js) for an example.
env
(String or Array of String). Optional. An environment variable name
var options = [{names: ['dry-run', 'n'], env: 'FOO_DRY_RUN'}];
var opts = dashdash.parse({options: options});
Both node foo.js --dry-run
and FOO_DRY_RUN=1 node foo.js
would result
in opts.dry_run = true
.An environment variable is only used as a fallback, i.e. it is ignored if the associated option is given in
argv
.help
(String). Optional. Used forparser.help()
output.
helpArg
(String). Optional. Used in help output as the placeholder for
...
-f PATH, --file=PATH File to process
...
helpWrap
(Boolean). Optional, default true. Set this tofalse
to have
help
not be text wrapped in <parser>.help()
output.default
. Optional. A default value used for this option, if the
hidden
(Boolean). Optional, default false. If true, help output will not
includeHidden
option to
bashCompletionFromOptions()
for Bash completion.Option group headings
You can add headings between option specs in the options
array. To do so,
simply add an object with only a group
property -- the string to print as
the heading for the subsequent options in the array. For example:var options = [
{
group: 'Armament Options'
},
{
names: [ 'weapon', 'w' ],
type: 'string'
},
{
group: 'General Options'
},
{
names: [ 'help', 'h' ],
type: 'bool'
}
];
...
Note: You can use an empty string,
{group: ''}
, to get a blank line in help
output between groups of options.Help config
The parser.help(...)
function is configurable as follows:Options:
Armament Options:
^^ -w WEAPON, --weapon=WEAPON Weapon with which to crush. One of: |
/ sword, spear, maul |
/ General Options: |
/ -h, --help Print this help and exit. |
/ ^^^^ ^ |
\ `-- indent `-- helpCol maxCol ---'
`-- headingIndent
indent
(Number or String). Default 4. Set to a number (for that many
headingIndent
(Number or String). Default half length ofindent
. Set to
nameSort
(String). Default is 'length'. By default the names are
maxCol
(Number). Default 80. Note that reflow is just done on whitespace
helpCol
(Number). If not set a reasonable value will be determined
minHelpCol
and maxHelpCol
.minHelpCol
(Number). Default 20.maxHelpCol
(Number). Default 40.helpWrap
(Boolean). Default true. Set tofalse
to have optionhelp
includeEnv
(Boolean). Default false. If the option has associated
env
option spec attribute), then
append mentioned of those envvars to the help string.includeDefault
(Boolean). Default false. If the option has a default value
default
option spec attribute, or a default on the option's type),
then a "Default: VALUE" string will be appended to the help string.Custom option types
Dashdash includes a good starter set of option types that it will parse for
you. However, you can add your own via:var dashdash = require('dashdash');
dashdash.addOptionType({
name: '...',
takesArg: true,
helpArg: '...',
parseArg: function (option, optstr, arg) {
...
},
array: false, // optional
arrayFlatten: false, // optional
default: ..., // optional
completionType: ... // optional
});
For example, a simple option type that accepts 'yes', 'y', 'no' or 'n' as
a boolean argument would look like:var dashdash = require('dashdash');
function parseYesNo(option, optstr, arg) {
var argLower = arg.toLowerCase()
if (~['yes', 'y'].indexOf(argLower)) {
return true;
} else if (~['no', 'n'].indexOf(argLower)) {
return false;
} else {
throw new Error(format(
'arg for "%s" is not "yes" or "no": "%s"',
optstr, arg));
}
}
dashdash.addOptionType({
name: 'yesno'
takesArg: true,
helpArg: '<yes|no>',
parseArg: parseYesNo
});
var options = {
{names: ['answer', 'a'], type: 'yesno'}
};
var opts = dashdash.parse({options: options});
See "examples/custom-option-\*.js" for other examples.
See the addOptionType
block comment in "lib/dashdash.js" for more details.
Please let me know with an
issue if you write a
generally useful one.Why
Why another node.js option parsing lib?nopt
really is just for "tools like npm". Implicit opts (e.g. '--no-foo'
optimist
has surprise interpretation of options (at least to me).
process.exit
calls makes it hard to use as a library.optparse
Incomplete docs. Is this an attempted clone of Python'soptparse
.
parser.on("name", ...)
API is weird.argparse
Dep on underscore. No thanks just for option processing.
find lib | wc -l
-> 26
. Overkill.
Argparse is a bit different anyway. Not sure I want that.posix-getopt
No type validation. Though that isn't a killer. AFAIK can't
getopt_long
semantics.
Also, no whizbang features like generated help output.- "commander.js": I wrote
License
MIT. See LICENSE.txt.