Command Line Input

If you want your Kotlin program to use command line arguments, you must modify the definition of main() so that it has an array of strings as its sole parameter. The type of this parameter must be declared as Array<String>. The name given to it has no special significance, but args or argv are common and sensible choices.

You will also need to check that the correct number of arguments have been supplied to the program. Arrays in Kotlin have a size property that you can examine in order to check this. If the required number of arguments haven’t been provided, it will be necessary to terminate the program prematurely, with a suitable error message.

For example, if a program requires a filename as a single command line argument, you could check that this argument is present in the manner shown below. (Equivalent code in C and Python is also provided, for comparison.)

import kotlin.system.exitProcess

fun main(args: Array<String>) {
    if (args.size != 1) {
        println("Error: filename required as sole argument")
        exitProcess(1)
    }

    // required argument available as args[0]
}

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char* argv[]) {
  if (argc != 2) {
    printf("Error: filename required as sole argument");
    exit(1);
  }

  // required argument available as argv[1]
}

import sys

if len(sys.argv) != 2:
    sys.exit("Error: filename required as sole argument")

# required argument available as sys.argv[1]

If you are wondering about exitProcess(1) in the example above, its purpose is to halt program execution, setting the program’s exit status to 1.

Task 3.1

1. Edit the file named Args.kt, in the tasks/task3_1 subdirectory of your repository.

   In this file, write a small Kotlin program that accepts command line arguments. Your main() function should contain only two lines of code, which should print out the first and second command line arguments. Do not add anything else at this stage.

2. Compile the program, then run it without supplying any arguments on the command line:

   kotlin ArgsKt
   

   What happens?

3. Run the program with two command line arguments, e.g.,

   kotlin ArgsKt arg1 arg2
   

   Then try running it like this:

   kotlin ArgsKt 'arg1 arg2'
   

   What happens, and why do you see this behaviour?

4. Modify the program so that it tests for the existence of the two required command line arguments before attempting to print them. Use the code example above as a guide.

   If the required arguments are not present, your code should call exitProcess(), with a non-zero exit status.

   Recompile the program, then use the following commands to run it with varying numbers of command line arguments, displaying exit status each time:

   kotlin ArgsKt arg1
   echo $?
   kotlin ArgsKt arg1 arg2
   echo $?
   kotlin ArgsKt arg1 arg2 arg3
   echo $?
   

   Here, $? is a shell variable that holds the exit status of the last command. This is what you would use in shell scripts to decide whether script execution should continue.

   Note

   This shell variable is different on Windows systems. If cmd.exe is your command shell, then you’ll need to use %ERRORLEVEL% instead of $?. If you are running Powershell, you’ll need to use $LastExitCode.

1. An exit status of 0 is the default. Thus you do not need to have an explicit exitProcess(0) at the end of your program. You’d only need to use this if you wanted to halt the program before the end of main() and signal that this was a normal termination rather than an error of some kind. ↩