Work the Shell - Conditional Statements and Flow Control

 in
IF you need conditions in your scripts, THEN this is the column for you.

The last of the basic building blocks of shell scripting are conditional statements, allowing you to decide programmatically whether to execute a block of statements based on a logical test, and flow control statements, the great innovation from the earliest days of programming where you could have a block of code execute more than once. We explore both of these in this column and, finally, are done with the proverbial Lego blocks of scripting, allowing us to start exploring how to solve complex scripting problems with novel and unique combinations of simple statements.

The most obvious conditional statement is if-then-else, which in shell scripting looks like:

if condition ; then ; statements ; else ; statements2 ; fi

Of course, you'd usually see this on multiple lines, so it's more likely to look like this:

if condition; then
  statements
else
  statements2
fi

There are some variations on this, including safely omitting any sort of else clause, but more interestingly, you can “chain” conditionals together with an else if structure:

if condition; then
  statements
elif condition2 ; then
  statements2
fi

That's perfectly valid and, worth noting, functionally different from the structure:

if condition
then
  statements
  if condition2; then
      statements2
  fi
fi

The difference will be obvious to anyone who has programmed before. In the first example, statements2 would execute if condition was false and condition2 were true. In the latter example, however, statements2 would be executed only if condition were true and condition2 were true. Subtle, but very important!

Specific logical conditions can take on a wide variety of appearances, because the only requirement for a conditional expression is that it return zero if the evaluated condition is false and nonzero if it should be considered true. Indeed, there are commands in Linux called false and true, so you can use statements like “if true; then....” Most conditions, however, are built around the invaluable test command, with its many different flags and options.

Want to compare two string (text) values? You could use:

if  test $myvar = "exit" ; then

or its shortcut alternative of:

if [ $myvar = "exit" ] ; then

Compare two numeric values with:

if test $numval -lt 10 ; then

There's also a world of file and variable tests available in the test command too, including -r to test if a file is readable, -e to see if it exists at all, -s to see if the file exists and has a nonzero size, and -d to test for a directory and -f to test for a regular file.

So if you want to differentiate whether $filename is a file, directory or other file type, you could use a statement sequence like:

if test -f $filename ; then
  echo "$filename is a regular file"
elif test -d $filename ; then
  echo "$filename is a directory"
else
  echo "$filename is neither a file nor a directory."
fi

Check out the test man page (use man test) to read about all the many different conditionals you can use in a shell script.

Flow Control

There are a number of different looping and flow control structures above and beyond simply the if-then-else conditional, luckily, and here are the big three:

  • for x in y; do; statements; done

  • while x; do; statements; done

  • case x in ; condition1) statements ;; condition2) statements ;; esac

There are more conditional statements, but you'll find that in the vast majority of cases, having for loops, while loops, case statements and if-then-else statements will serve as the building blocks of even the most complex script.

The for loop is particularly useful in its variations. Want to step through the parameters given to the shell script itself? Use something like this:

for value ; do ; statements ; done

Want to step through a set of matching filenames for a given pattern? Here's how to do that in a script:

for filename in *.c ; do
  statements
done

Let's look at how a couple of these can be combined in useful ways, rather than just duplicate the man page, however. Here's a simple script that examines each entry in the current directory, indicating whether it's a file or directory:

for name in *
do
  if [ -f "$name" ] ; then
    echo "$name is a file"
  elif [ -d "$name" ] ; then
    echo "$name is a directory"
  else
    echo "$name is neither a file nor directory"
  fi
done

For illustrative purposes, let's try another version of this script, one that recognizes *.c as C source files, *.h as included header files and *.o as intermediate object files, but this time we'll use the case statement:

for name in *
do
  case "$name" in
    *.c ) echo "$name is a C source file"       ;;
    *.h ) echo "$name is a header file"         ;;
    *.o ) echo "$name is an object file"        ;;
  esac
done

From a readability perspective, the case statement is hard to beat!

______________________

Dave Taylor has been hacking shell scripts for over thirty years. Really. He's the author of the popular "Wicked Cool Shell Scripts" and can be found on Twitter as @DaveTaylor and more generally at www.DaveTaylorOnline.com.

White Paper
Linux Management with Red Hat Satellite: Measuring Business Impact and ROI

Linux has become a key foundation for supporting today's rapidly growing IT environments. Linux is being used to deploy business applications and databases, trading on its reputation as a low-cost operating environment. For many IT organizations, Linux is a mainstay for deploying Web servers and has evolved from handling basic file, print, and utility workloads to running mission-critical applications and databases, physically, virtually, and in the cloud. As Linux grows in importance in terms of value to the business, managing Linux environments to high standards of service quality — availability, security, and performance — becomes an essential requirement for business success.

Learn More

Sponsored by Red Hat

White Paper
Private PaaS for the Agile Enterprise

If you already use virtualized infrastructure, you are well on your way to leveraging the power of the cloud. Virtualization offers the promise of limitless resources, but how do you manage that scalability when your DevOps team doesn’t scale? In today’s hypercompetitive markets, fast results can make a difference between leading the pack vs. obsolescence. Organizations need more benefits from cloud computing than just raw resources. They need agility, flexibility, convenience, ROI, and control.

Stackato private Platform-as-a-Service technology from ActiveState extends your private cloud infrastructure by creating a private PaaS to provide on-demand availability, flexibility, control, and ultimately, faster time-to-market for your enterprise.

Learn More

Sponsored by ActiveState