yargs vs arg

Command-Line Argument Parsers Comparison

Command-line argument parsers are libraries that help developers easily handle command-line inputs in Node.js applications. They simplify the process of parsing arguments, managing options, and providing a user-friendly interface for command-line tools. These libraries enhance the usability of command-line applications by allowing developers to define expected inputs, handle defaults, and provide help documentation automatically. This is crucial for creating robust CLI tools that are easy to use and maintain.

Package	Downloads	Stars	Size	Issues	Publish	License

yargs	147,393,384	11,287	231 kB	293	a month ago	MIT
arg	55,148,531	1,283	13.7 kB	17	-	MIT

Complexity

yargs:
Yargs offers a more complex API with extensive features for building sophisticated command-line applications. It supports commands, middleware, and advanced parsing options, making it suitable for larger projects.
arg:
Arg is designed to be simple and straightforward, focusing on minimalism. It provides a clean API for defining options and parsing arguments, making it easy to integrate into small scripts without additional overhead.

Help Documentation

yargs:
Yargs automatically generates help documentation based on the defined options and commands. This feature is beneficial for improving user experience and ensuring that users understand how to use the CLI tool.
arg:
Arg does not automatically generate help documentation. Developers need to manually implement help messages, which can be a limitation for larger applications that require user guidance.

Command Handling

yargs:
Yargs excels in command handling, allowing developers to define multiple commands with their own options and behaviors. This is particularly useful for applications that require distinct functionalities.
arg:
Arg does not support command handling natively. It is primarily focused on parsing options and arguments, which may require additional coding for command management.

Middleware Support

yargs:
Yargs supports middleware functions, enabling developers to execute code before a command is processed. This feature allows for enhanced control over command execution and input validation.
arg:
Arg does not provide middleware support, which limits its ability to handle pre-processing of commands or options before they are executed.

Learning Curve

yargs:
Yargs has a steeper learning curve because of its extensive features and capabilities. While powerful, it may require more time to fully grasp all its functionalities.
arg:
Arg has a gentle learning curve due to its simplicity. Developers can quickly understand how to define and parse arguments without extensive documentation.

yargs:
Choose yargs if you require a more feature-rich solution that includes built-in help generation, command handling, and advanced parsing capabilities. It is suitable for complex CLI applications that need comprehensive command management.
arg:
Choose arg if you need a lightweight, minimalistic solution for parsing command-line arguments without many dependencies. It is ideal for simple scripts or applications where performance and simplicity are key.

yargs

arg

Yargs

Yargs be a node.js library fer hearties tryin' ter parse optstrings

Description

Yargs helps you build interactive command line tools, by parsing arguments and generating an elegant user interface.

It gives you:

commands and (grouped) options (my-program.js serve --port=5000).
a dynamically generated help menu based on your arguments:

mocha [spec..]

Run tests with Mocha

Commands
  mocha inspect [spec..]  Run tests with Mocha                         [default]
  mocha init <path>       create a client-side Mocha setup at <path>

Rules & Behavior
  --allow-uncaught           Allow uncaught errors to propagate        [boolean]
  --async-only, -A           Require all tests to use a callback (async) or
                             return a Promise                          [boolean]

generate completion scripts for Bash and Zsh for your command
and tons more.

Installation

Stable version:

npm i yargs

Bleeding edge version with the most recent features:

npm i yargs@next

Usage

Simple Example

#!/usr/bin/env node
import yargs from 'yargs';
import { hideBin } from 'yargs/helpers';
const argv = yargs(hideBin(process.argv)).parse()

if (argv.ships > 3 && argv.distance < 53.5) {
  console.log('Plunder more riffiwobbles!')
} else {
  console.log('Retreat from the xupptumblers!')
}

$ ./plunder.js --ships=4 --distance=22
Plunder more riffiwobbles!

$ ./plunder.js --ships 12 --distance 98.7
Retreat from the xupptumblers!

Note: hideBin is a shorthand for process.argv.slice(2). It has the benefit that it takes into account variations in some environments, e.g., Electron.

Complex Example

#!/usr/bin/env node
import yargs from 'yargs';
import { hideBin } from 'yargs/helpers';

yargs(hideBin(process.argv))
  .command('serve [port]', 'start the server', (yargs) => {
    return yargs
      .positional('port', {
        describe: 'port to bind on',
        default: 5000
      })
  }, (argv) => {
    if (argv.verbose) console.info(`start server on :${argv.port}`)
    serve(argv.port)
  })
  .option('verbose', {
    alias: 'v',
    type: 'boolean',
    description: 'Run with verbose logging'
  })
  .parse()

Run the example above with --help to see the help for the application.

Supported Platforms

TypeScript

yargs has type definitions at @types/yargs.

npm i @types/yargs --save-dev

See usage examples in docs.

Deno

As of v16, yargs supports Deno:

import yargs from 'https://deno.land/x/yargs@v17.7.2-deno/deno.ts'
import { Arguments } from 'https://deno.land/x/yargs@v17.7.2-deno/deno-types.ts'

yargs(Deno.args)
  .command('download <files...>', 'download a list of files', (yargs: any) => {
    return yargs.positional('files', {
      describe: 'a list of files to do something with'
    })
  }, (argv: Arguments) => {
    console.info(argv)
  })
  .strictCommands()
  .demandCommand(1)
  .parse()

Note: If you use version tags in url then you also have to add -deno flag on the end, like @17.7.2-deno

Usage in Browser

See examples of using yargs in the browser in docs.

Documentation

Table of Contents

Supported Node.js Versions

Libraries in this ecosystem make a best effort to track Node.js' release schedule. Here's a post on why we think this is important.