Verifying bash script arguments | Network Earth

Several bash scripts use arguments to handle the instructions that they will operate and the data that will be furnished to the folks operating them. This write-up examines a number of methods that you can validate arguments when you put together a script and want to make confident that it will do just what you intend it to do – even when a person jogging it can make a mistake.

Displaying the script name, and many others.

To show the identify of a script when it’s operate, use a command like echo $. Although any individual running a script will unquestionably know what script they just invoked, applying the script identify in a use command can support remind them what command and arguments they really should be furnishing.

Script names can be displayed together with the expected arguments like this:

echo Use: $ thirty day period calendar year

The $ argument signifies the identify of the script.

Utilization statements are typically exhibited when a consumer doesn’t enter the proper arguments to run a script. A utilization statement will remind folks what is predicted – especially when they operate the script pretty occasionally.

Examining the variety of arguments furnished

To show the range of arguments supplied by the user, you can use a command like echo $#. That $# represents the selection of arguments furnished by the person. Your script can validate that it is what the script involves. Here’s an illustration:

if [ $# != 2 ] then
  echo $ username date (e.g., 12/01/2023)

The code earlier mentioned asks if the quantity of arguments provided is not equal to two. You can also use commands like these

if [ $# == 2]        # if quantity of arguments equals 2
if [ $# -lt 3 ]      # if range of arguments is much less than 3
if [ $# -gt 4 ]      # if amount of arguments is extra than 4

The == (equals), lt (a lot less than) and gt (better than) comparisons are normally applied to verify that the proper amount of arguments have been provided by the individual working the script.

Verifying the arguments

If a script is heading to operate with a file, you might want to examine that the specified file exists right before the script operates a command that is intended to course of action or study it. For instance:

filename=$1     # to start with argument must be filename
if [ ! -e $filename ] then
  echo “No these file: $filename”
fi

The ! -e aspect of the command over assessments “if there is no file with the identify”. You can also have a script verify file permissions. For case in point, to test whether or not the person jogging the script can go through, write or execute a file, you can use instructions these as these:

if [ ! -r $1 ] then
  echo are unable to read $1
fi
if [ ! -x $1 ] then
  echo can not operate $1
fi
if [ ! -w $1 ] then
echo are not able to publish to $1
fi

The person functioning the script might see one thing like this:

$ countlines thatfile
can not examine thatfile

Verifying argument sorts

There are a variety of means that you can confirm the sort of arguments presented to a script. For instance, you can check irrespective of whether an argument is a selection or a string of letters. You can even examine if the arguments incorporate a thirty day period and a calendar year. In this article are some illustrations of how to do these matters:

Look at if numeric

The code beneath makes sure the argument supplied is a solitary string of digits. The $re variable sets up the sample (all digits).

# test if argument is numeric
re="^[0-9]+$"
if ! [[ $2 =~ $re ]]  then
   echo "error: Not a variety"
   exit 2
fi

Look at if a string of people

The code under assures that the argument is a string of people. You can elect to check if it includes only lowercase or uppercase letters.

To verify if an argument contains only lowercase letters:

# verify argument is people
re="^[a-z]+$"
if ! [[ $1 =~ $re ]]  then
   echo "error: Not alphabetic"
   exit 3
fi

To check if an argument has only uppercase letters:

# check out argument is people
re="^[A-Z]+$"
if ! [[ $1 =~ $re ]]  then
   echo "error: Not alphabetic"
   exit 3
fi

To examine if an argument includes only letters (uppercase or lowercase):

# verify argument is characters
re="^[a-zA-Z]+$"
if ! [[ $1 =~ $re ]]  then
   echo "error: Not alphabetic"
   exit 3
fi

Take note: The order of the letters in the argument offered is unimportant for these exams. The “re” (frequent expression) checks simply be certain that the argument delivers only characters in the variety specified.

Looping as a result of script arguments

The command under will loop by means of all of the arguments that are provided when a script is run.

# exhibit checklist of arguments
for arg in "$@"
do
    echo "$arg"
carried out

The $@ string represents the list of arguments furnished. The for command then loops as a result of them, exhibiting them 1 at a time.

Examining command-distinct syntax

The command proven under will validate that the syntax for a certain command that the script is anticipated to run – in this circumstance, the cal (calendar) command – is proper. It does this in a incredibly fascinating way. It runs the command and sends its output to /dev/null (the “bit bucket”). If the error code returned indicates that the command failed in some way (i.e., the return code is better than zero), the script tells the person the command failed. Usually, it operates the command yet again, displaying the output expected.

# verify if yr/thirty day period are valid
cal $1 $2 >/dev/null
if [ $? != 0 ] then          # mistake encountered
echo Invalid month and/or yr
  exit 4
else
  cal $1 $2
fi

Wrap-up

There are several means to verify the arguments presented to a script when it is run. This is especially helpful when you are preparing scripts that other men and women – particularly much less script-savvy persons than yourself – will finish up running.