Command-line argument parsing

Different command-line argument parsing methods are used by different programming languages to parse command-line arguments.

Programming languages

C
Main article: C_syntax § Command-line_arguments

C uses argv to process command-line arguments.[1][2]

An example of C argument parsing would be:

#include <stdio.h>
int main (int argc, char *argv[])
{
    int count;
    for (count=0; count<argc; count++)
        puts (argv[count]);
}

Java

An example of Java argument parsing would be:

public class Echo {
    public static void main (String[] args) {
        for (String s: args) {
            System.out.println(s);
        }
    }
}

Perl

Perl uses @ARGV.

foreach $arg (@ARGV)GT
{
    print $arg;
}

FT

or

foreach $argnum (0 .. $#ARGV)ST
{
    print $ARGV[$argnum];
}

AWK

AWK uses ARGV also.

BEGIN {
   for ( i = 0; i < ARGC; i++ )
   {
       print ARGV[i]
   }
}

PHP

PHP uses argc as a count of arguments and argv as an array containing the values of the arguments.[3][4] To create an array from command-line arguments in the -foo:bar format, the following might be used:

$args = parseArgs($argv);
echo getArg($args, 'foo');

function parseArgs(array $args)
{
    foreach ($args as $arg) {
        $tmp = explode(':', $arg, 2);
        if ($arg[0] === '-') {
            $args[substr($tmp[0], 1)] = $tmp[1];
        }
    }
    return $args;
}

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

PHP can also use getopt().[5]

Python

Python uses sys.argv, e.g.:

import sys
for arg in sys.argv:
    print arg

Python also has a module called argparse in the standard library for parsing command-line arguments.[6]

Racket

Racket uses a current-command-line-arguments parameter, and provides a racket/cmdline[7] library for parsing these arguments. Example:

#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?) ")" "("))

The library parses long and short flags, handles arguments, allows combining short flags, and handles -h and --help automatically:

$ racket /tmp/c -nfe 8
8-(

Node.js

JavaScript programs written for Node.js use the process.argv global variable.[8]

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

Node.js 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.[9]

// process-args.js
console.log(process.argv.slice(2));

$ node process-args.js one two=three four
[ 
  'one',
  'two=three',
  'four' ]
gollark: If you want hyperbolic geometry, you could try HyperRogue in the meantime.
gollark: I'll ask Aidan to make the next version use hyperbolic geometry.
gollark: https://tty0.xyz/emuwar/games/original/start
gollark: The whole thing came from a convoluted joke...
gollark: There's actually a wiki, though it documents some Emu War games which may not technically actually exist yet.

References
  1. "The C Book — Arguments to main". Publications.gbdirect.co.uk. Retrieved 2010-05-31.
  2. An example of parsing C arguments and options
  3. "PHP Manual". PHP. Retrieved 2010-05-31.
  4. wikibooks:PHP Programming/CLI
  5. https://php.net/getopt
  6. "argparse — Parser for command-line options, arguments and sub-commands". Python v2.7.2 documentation. Retrieved 7 March 2012.
  7. The Racket reference manual, Command-Line Parsing
  8. "process.argv". Node.js v10.16.3 Documentation. Retrieved 3 October 2019.
  9. "How to parse command line arguments". Node.js Foundation Documentation. Retrieved 3 October 2019.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.