Command Line Arguments in Erlang

Command-line arguments are a common way to parameterize execution of programs. For example, erl -noshell -s hello_world main -s init stop uses -noshell, -s, hello_world, main, -s, init, and stop as arguments to the erl program.

-module(command_line_arguments).
-export([main/1]).

main(Args) ->
    % The first argument is the script name, which we can ignore
    ArgsWithoutProg = tl(Args),

    % You can get individual args with normal list operations
    Arg = lists:nth(3, Args),

    io:format("~p~n", [Args]),
    io:format("~p~n", [ArgsWithoutProg]),
    io:format("~p~n", [Arg]).

In Erlang, the command-line arguments are passed to the main/1 function as a list of strings. The first element of this list is typically the name of the script being run.

To experiment with command-line arguments, it’s best to compile the module first and then run it using the erl command.

$ erlc command_line_arguments.erl
$ erl -noshell -s command_line_arguments main a b c d -s init stop
["command_line_arguments","a","b","c","d"]
["a","b","c","d"]
"c"

In this example, we compile the Erlang module using erlc, then run it using erl. The -noshell option prevents the Erlang shell from starting, -s command_line_arguments main calls the main/1 function in our module, a b c d are the arguments we’re passing to our program, and -s init stop tells Erlang to exit after running our program.

Erlang doesn’t have a direct equivalent to Go’s os.Args, but instead passes the command-line arguments directly to the main/1 function. The tl/1 function is used to get all elements of the list except the first one, which is equivalent to os.Args[1:] in Go.

Next, we’ll look at more advanced command-line processing with option parsing libraries in Erlang.