Command-line argument parsing

<h2 id="programming-languages">Programming languages</h2>
<h3>C</h3>
<p class="note">Main article: <a href="/facts/C_syntax/DB1393sn">C_syntax § Command-line_arguments</a></p>
<p>C uses argv to process command-line arguments.<a class="footnote-ref" id="fnref:1" href="#fn:1"><sup>1</sup></a><a class="footnote-ref" id="fnref:2" href="#fn:2"><sup>2</sup></a>
</p><p>An example of <a href="/facts/C_(programming_language)/Ky2No763">C</a> argument parsing would be:
</p>
#include <stdio.h>
int main (int argc, char *argv[])
{
    int count;
    for (count = 0; count < argc; count++)
        puts (argv[count]);
}

<p>C also has functions called <a href="/facts/Getopt/HJQPh5Sn">getopt</a> and getopt_long.
</p>
<h3>C#</h3>
<p>An example of <a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a> argument parsing would be:
</p>
class Program
{
    static void Main(string[] args)
    {
        foreach (var arg in args)
            Console.WriteLine(arg);
    }
}

<h3>Java</h3>
<p>An example of <a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a> argument parsing would be:
</p>
public class Echo {
    public static void main (String[] args) {
        for (String s: args) {
            System.out.println(s);
        }
    }
}

<h3>Kotlin</h3>
<p>Here are some possible ways to print arguments in <a href="/facts/Kotlin_(programming_language)/CrAqIFLn">Kotlin</a>:<a class="footnote-ref" id="fnref:3" href="#fn:3"><sup>3</sup></a>
</p>
fun main(args: Array<String>) = println(args.joinToString())

fun main(args: Array<String>) = println(args.contentToString())

fun main(args: Array<String>) {
    for (arg in args)
        println(arg)
}

<h3>Perl</h3>
<p><a href="/facts/Perl/fx31kjlT">Perl</a> uses @ARGV.
</p>
foreach $arg (@ARGV)
{
    print $arg;
}

<p>or
</p>
foreach $argnum (0 .. $#ARGV)
{
    print $ARGV[$argnum];
}

<h3>AWK</h3>
<p><a href="/facts/AWK/lAQ0leyj">AWK</a> uses ARGV also.
</p>
BEGIN {
   for ( i = 0; i < ARGC; i++ )
   {
       print ARGV[i]
   }
}

<h3>PHP</h3>
<p><a href="/facts/PHP/vU6YRJX0">PHP</a> uses argc as a count of arguments and argv as an <a href="/facts/Array_data_structure/BKGvF8AM">array</a> containing the values of the arguments.<a class="footnote-ref" id="fnref:4" href="#fn:4"><sup>4</sup></a><a class="footnote-ref" id="fnref:5" href="#fn:5"><sup>5</sup></a> To create an array from command-line arguments in the -foo:bar format, the following might be used:
</p>
$args = parseArgs($argv);
echo getArg($args, "foo");

function getArg(array $args, string $arg)
{
    if (isset($args[$arg])) {
        return $args[$arg];
    }
    return false;
}

<p>PHP can also use getopt().<a class="footnote-ref" id="fnref:6" href="#fn:6"><sup>6</sup></a>
</p>
<h3>Python</h3>
<p><a href="/facts/Python_(programming_language)/YbuGqofa">Python</a> uses sys.argv, e.g.:
</p>
import sys
for arg in sys.argv:
    print arg

<p>Python also has a module called argparse in the standard library for parsing command-line arguments.<a class="footnote-ref" id="fnref:7" href="#fn:7"><sup>7</sup></a>
</p>
<h3>Racket</h3>
<p><a href="/facts/Racket_(programming_language)/5n7LW08b">Racket</a> uses a current-command-line-arguments parameter, and provides a racket/cmdline<a class="footnote-ref" id="fnref:8" href="#fn:8"><sup>8</sup></a> library for parsing these arguments.  Example:
</p>
#lang racket

(require racket/cmdline)

(define smile? (make-parameter #t))
(define nose?  (make-parameter #false))
(define eyes   (make-parameter ":"))

(command-line #:program "emoticon"

#:once-any ; the following two are mutually exclusive
              [("-s" "--smile") "smile mode" (smile? #true)]
              [("-f" "--frown") "frown mode" (smile? #false)]

#:once-each
              [("-n" "--nose") "add a nose"  (nose? #true)]
              [("-e" "--eyes") char "use <char> for the eyes" (eyes char)])

(printf "~a~a~a\n"
        (eyes)
        (if (nose?) "-" "")
        (if (smile?) ")" "("))

<p>The library parses long and short flags, handles arguments, allows combining short flags, and handles -h and --help automatically:
</p>
$ racket /tmp/c -nfe 8
8-(

<h3>Rexx</h3>
<p><a href="/facts/Rexx/hAzh6FeR">Rexx</a> uses arg, e.g.:
</p>
do i=1 to words(arg(1))
	say word(arg(1), i)
end

<h3>Rust</h3>
<p>The args are in env::args().<a class="footnote-ref" id="fnref:9" href="#fn:9"><sup>9</sup></a>
</p>
use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();

let query = &args[1];
    let file_path = &args[2];

println!("Searching for {}", query);
    println!("In file {}", file_path);
}

<h3>JavaScript</h3>
<h4>Node.js</h4>
<p><a href="/facts/JavaScript/XhhIIEsl">JavaScript</a> programs written for <a href="/facts/Node.js/FKzhV4Qa">Node.js</a> use the process.argv global variable.<a class="footnote-ref" id="fnref:10" href="#fn:10"><sup>10</sup></a>
</p>
// argv.js
console.log(process.argv);

$ node argv.js one two three four five
[ 'node',
  '/home/avian/argvdemo/argv.js',
  'one',
  'two',
  'three',
  'four',
  'five' ]

<p><a href="/facts/Node.js/FKzhV4Qa">Node.js</a> programs are invoked by running the interpreter node interpreter with a given file, so the first two arguments will be node and the name of the JavaScript source file. It is often useful to extract the rest of the arguments by slicing a sub-array from process.argv.<a class="footnote-ref" id="fnref:11" href="#fn:11"><sup>11</sup></a>
</p>
// process-args.js
console.log(process.argv.slice(2));

$ node process-args.js one two=three four
[ 
  'one',
  'two=three',
  'four' ]

<h4>Bun</h4>
<p>JavaScript written for <a href="/facts/Bun_(software)/StggJde8">Bun</a> use Bun.argv and the util.parseArgs function.<a class="footnote-ref" id="fnref:12" href="#fn:12"><sup>12</sup></a>
</p>
console.log(Bun.argv);

<h4>Deno</h4>
<p>JavaScript written for <a href="/facts/Deno_(software)/m1xyHIPE">Deno</a> use Deno.args<a class="footnote-ref" id="fnref:13" href="#fn:13"><sup>13</sup></a> and the parseArgs function.<a class="footnote-ref" id="fnref:14" href="#fn:14"><sup>14</sup></a>
</p>
console.log(Deno.args);

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>"The C Book — Arguments to main". Publications.gbdirect.co.uk. Retrieved 2010-05-31. <a href="http://publications.gbdirect.co.uk/c_book/chapter10/arguments_to_main.html" target="_blank">http://publications.gbdirect.co.uk/c_book/chapter10/arguments_to_main.html</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>An example of parsing C arguments and options <a href="http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/share/misc/style" target="_blank">http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/share/misc/style</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
<li id="fn:3"><p>"Kotlin: Basic syntax". Retrieved 2022-05-13. <a href="https://kotlinlang.org/docs/basic-syntax.html#program-entry-point" target="_blank">https://kotlinlang.org/docs/basic-syntax.html#program-entry-point</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li>
<li id="fn:4"><p>"PHP Manual". PHP. Retrieved 2010-05-31. <a href="http://php.net/manual/en/reserved.variables.argv.php" target="_blank">http://php.net/manual/en/reserved.variables.argv.php</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li>
<li id="fn:5"><p>wikibooks:PHP Programming/CLI <a href="https://en.wikibooks.org/wiki/PHP_Programming/CLI" target="_blank">https://en.wikibooks.org/wiki/PHP_Programming/CLI</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></p></li>
<li id="fn:6"><p>"PHP: Getopt - Manual". <a href="https://php.net/getopt" target="_blank">https://php.net/getopt</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></p></li>
<li id="fn:7"><p>"argparse — Parser for command-line options, arguments and sub-commands". Python v3.10.0 documentation. Archived from the original on 2012-11-01. Retrieved 15 October 2021. <a href="https://docs.python.org/3/library/argparse.html" target="_blank">https://docs.python.org/3/library/argparse.html</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></p></li>
<li id="fn:8"><p>The Racket reference manual, Command-Line Parsing <a href="http://docs.racket-lang.org/reference/Command-Line_Parsing.html" target="_blank">http://docs.racket-lang.org/reference/Command-Line_Parsing.html</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></p></li>
<li id="fn:9"><p>"Accepting Command Line Arguments - The Rust Programming Language". doc.rust-lang.org. Retrieved 22 December 2022. <a href="https://doc.rust-lang.org/book/ch12-01-accepting-command-line-arguments.html" target="_blank">https://doc.rust-lang.org/book/ch12-01-accepting-command-line-arguments.html</a> <a href="#fnref:9" class="footnote-back-ref">↩</a></p></li>
<li id="fn:10"><p>"process.argv". Node.js v10.16.3 Documentation. Retrieved 3 October 2019. <a href="https://nodejs.org/docs/latest-v10.x/api/process.html#process_process_argv" target="_blank">https://nodejs.org/docs/latest-v10.x/api/process.html#process_process_argv</a> <a href="#fnref:10" class="footnote-back-ref">↩</a></p></li>
<li id="fn:11"><p>"How to parse command line arguments". Node.js Foundation Documentation. Retrieved 3 October 2019. <a href="https://nodejs.org/en/knowledge/command-line/how-to-parse-command-line-arguments/" target="_blank">https://nodejs.org/en/knowledge/command-line/how-to-parse-command-line-arguments/</a> <a href="#fnref:11" class="footnote-back-ref">↩</a></p></li>
<li id="fn:12"><p>"Parse command-line arguments | Bun Examples". Bun. <a href="https://bun.sh/guides/process/argv" target="_blank">https://bun.sh/guides/process/argv</a> <a href="#fnref:12" class="footnote-back-ref">↩</a></p></li>
<li id="fn:13"><p>"Deno.args". docs.deno.com. <a href="https://docs.deno.com/api/deno/~/Deno.args" target="_blank">https://docs.deno.com/api/deno/~/Deno.args</a> <a href="#fnref:13" class="footnote-back-ref">↩</a></p></li>
<li id="fn:14"><p>"parseArgs from parse-args - @std/cli - JSR". jsr.io. <a href="https://jsr.io/@std/cli/doc/parse-args/~/parseArgs" target="_blank">https://jsr.io/@std/cli/doc/parse-args/~/parseArgs</a> <a href="#fnref:14" class="footnote-back-ref">↩</a></p></li>
</ol>

Command-line argument parsing open-in-new

Command-line argument parsing