DirectNET

OS X | UNIX

if-elif-elif-else-fi

The 'if' statement was discussed in Part 8 (Shell Scripting 1). In addition to the simple 'if-fi' and 'if-else-fi' variants, one is able to specify any number of alternatives. For example:

$ cat ifelif 
#!/bin/sh


read -p "Type a letter: " l


if [ "$l" = "a" ]; then
  echo "case a"
elif [ "$l" = "b" ]; then
  echo "case b"
elif [ "$l" = "c" ]; then
  echo "case c"
else
  echo "default case"
fi

Here there are four alternatives; thought there is no (sensible) upper limit. The first alternative is selected when the first 'if' condition is TRUE. If the first condition is FALSE, the second 'elif' condition (short for else if) is tried, and so on. If no conditions are TRUE the 'else' part is executed.

Running this script we get:

...which I guess is self-explanatory

More Conditions

So far, the conditions I have given to 'if' and 'elif' have been simple equality tests on strings. One can test strings, numeric values, and files.

Here are some other conditions you can use. I am assuming the existence of shell variables num1 and num2. It helps if these contain strings that can be interpreted as integer numbers such as "123", not "abc".

There are lots more conditions. They can be viewed with:

Read this fully. It shows all manner of tests, particularly on files, and is invaluable when writing scripts.

See the sidebar for an explanation of 'test condition' versus '[ condition ]'.

[ and 'test'

Have a look in /bin and you find an odd entry that is simply '['.

You will also see a command called 'test'

Now try this:

The test command evaluates the expression given to it, and returns TRUE (0) or FALSE (1).

To obtain the return value of the last command executed use the shell special variable $?. This variable can also be checked in shell scripts after calling an external command.

Now look at this simple shell script:

$ cat bkt
#!/bin/sh


if test "$1" = "" ; then
  echo "Empty"
else
  echo $1
fi


$ ./bkt
Empty


$ ./bkt Hello
Hello

The script executes the command 'test "$1" = ""' (after the shell has expanded $1) and the 'if' statement is tests the result of this (TRUE/FALSE).

This is exactly equivalent to the more usual:

except that the command '[' is executed instead of test. '[' additionally looks for a matching ']' and discards it. 'test' and '[' are otherwise equivalent.

Loops

A loop is a control construct that goes round and round, either forever, or more usually until a condition is met. The Bourne shell provides three kinds of loop:

'while' and 'until' are similar, but reverse the termination condition.

For Loops

Here is a very simple 'for' loop:

$ cat for1
#!/bin/sh


count=0
for var in one two three a b c
do
  echo "The value of var is now $var"
  count=$(expr $count + 1)
  echo "This is iteration number $count"
done

Executing script 'for1' gives:

The loop was executed six times, once for each value listed in:

Each iteration, the variable specified in the 'for' loop (in this case 'var') takes on the next value in the list (in this case 'one two three a b c'). When the list is exhausted the 'for' loop completes.

A 'for' loop is more useful when the list is generated dynamically, for example when it is the output of a program or expanded by the shell. This next example prints the type of each file in the current directory.

$ cat for2
#!/bin/sh
for var in * 
do
  if [ -d "$var" ]; then
    echo "$var - directory"
  elif [ -f "$var" ]; then
    echo "$var - file"
  else
    echo "$var - dunno"
  fi
done

The list is "*", which of course the shell expands to all files in the current directory.

Alternatively,

will generate a list containing all the parameters passed to the script, and:

will generate a list containing the output generated by 'command'.

Note that the list is space-separated.

While Loops

Here is a simple while loop:

$ cat while1
#!/bin/sh


read -p "Give a filename: " fn
while [ "$fn" != "" ]
do
  if [ -e $fn ]; then
    file $fn
  else
    echo "File $fn does not exist"
  fi


  read -p "Give a filename: " fn
done


echo "Bye."

The loop comprises the statements between 'do' and 'done'. They are executed while the condition given in:

remains TRUE. A 'while' condition is formed exactly as for an 'if' or 'elif' condition. In this example, the loop executes while the input filename is not empty. Note that two 'read' statements are required, one before the loop and one within the loop. Running the script gives:

The last request for a filename is responded to with a press of the return key, resulting in an empty string being assigned to fn, and thus the 'while' condition being FLASE. At this point the loop completes.

Note the use of command 'file', which attempts (with a little /etc/magic) to identify the type of the file passed to it.

Until Loops

An 'until' loop simply uses the keyword 'until' instead of 'while', and as one might guess from the linguistic sense of the construct, the condition for exiting the loop is reversed.

Here is the above example written as an 'until' loop:

$ cat until1
#!/bin/sh


read -p "Give a filename: " fn
until [ "$fn" = "" ]
do
  if [ -e $fn ]; then
    file $fn
  else
    echo "File $fn does not exist"
  fi


  read -p "Give a filename: " fn
done


echo "Bye."

Executing it:

Adding Up

Note the statement:

in the script 'for1'

The command 'expr' evaluates the expression given to it, in this case $count (which will be expanded by the shell before being passed to 'eval') plus 1. The output from the command is assigned back to 'count' (overwriting its previous value) using the $(command) technique to execute 'command' and place its output into a variable. See Shell Scripting 1.

will reveal the power of 'eval'.

Some 'for' list tricks

Here are some variants of the 'for' statement from the script 'for2':

1) filenames with spaces

Suppose we have a file called:

The 'for' loop:

will correctly produce:

whereas the supposedly equivalent:

will return:

This is because the shell expands "*" itself and understands which spaces are part of the filename, and which separate elements of the 'for' list. Using '$(ls)', the necessary information is lost because the shell sees only the output from the 'ls' command.

2) parameters with spaces

The special parameter '$@' is similar to '$*', but is useful when input parameters might contain spaces. This is most easily illustrated by an example.

The script:

$ cat for3
#!/bin/sh


echo "Using \$*"
for var in $* 
do
  echo "$var"
done


echo
echo "Using \"\$*\""
for var in "$*" 
do
  echo "$var"
done


echo
echo "Using \$@"
for var in $@ 
do
  echo "$var"
done


echo
echo "Using \"\$@\""
for var in "$@" 
do
  echo "$var"
done

will behave as below.

Note that the third parameter:

contains a space and is quoted to indicate that it is supposed to be a single parameter.

Note also the heavy use of escaping in the 'echo' commands.

"$@" is often the correct expression to use.