month=1                                
while echo Checking limit against month ${month}
  [ ${month} -le 12 ]   # The test is the last command in list1
do
   echo Performing action for month ${month}
   month=$(( ${month} + 1))
done 
echo Value of month outside loop is ${month}

Notes and observations

1. The last command of list1 is a test command using the left bracket synonym.
2. The -le is a test command option for the numeric comparison less than or equal to.
3. As Unix program variables hold strings, to perform arithmetic operations, one must use the $(( .. )) syntax with dollar sign and double parentheses.
4. The formal spelling of Unix variables requires enclosure in set braces { }.  Where there is no ambiguity, it is common practice in Unix to omit the set braces.
5. Try running this code and see that the value of month never exceeds 12 in the line “echo Performing action …”.

The objective is to read a file one line at a time.  Here is a newbie’s first attempt.

$ cat badwhile
while read wholeline < novel
do
        something $wholeline         #e.g. echo $wholeline
done
$ ./badwhile
It was a
It was a
It was a
It was a
...

What happened?  The redirection operator applies to the read command.  Each time the read command is run, redirection is applied anew and only the first line of the file is ever read.

To have redirection apply to the entire duration of the while loop and not just the read command, it is necessary to establish redirection and associate it with the while loop.

Here is a template which you can use to read lines from a file one-at-a-time.

while read wholeline
do
        something $wholeline  #e.g. echo $wholeline
done < inputfile

To make this work, one must position the redirection operator after the command to which it should be applied.  The correct position is after the while command, in particular the keyword done.  Unix is smart enough to look ahead for redirection when it starts executing the while command.  Any commands within the while command which draw from STDIN (e.g. read) will draw from the redirected file. (If you are having difficulty understanding redirection, refer to the chapter on Redirection and Pipes.)

Recall that the cat command will accept any number of command line arguments like this:

cat ch1 ch2 ch3 ...

Let’s say that you want to write your own Unix script that will accept any number of command line arguments:

mycmd parm1 parm2 ...

The key requirement here is that you will not know beforehand how many command-line arguments the user will supply when the user runs your program.  Your program must be flexible enough to handle zero or more command line arguments.

Here is a template of code to solve this problem:

while [ $1 ]
do
   someprocess $1
   shift
done

Explanatory notes:

1. The last command in the while list is a test command (using the left square bracket synonym).
2. With no specific test operator (e.g. -r, etc.), the default behaviour of the test command is to check if the string is null.  The return code ($?) is TRUE for a non-null string (something is there), and FALSE for a null string.
3. The shift command slides all command line parameters to the left, in this case moving the next unprocessed command line argument into the $1 position.  (The shift command also has the side-effect of decrementing the $# variable.)
4. Once there are no more command line arguments, the loop terminates.  Note that if there were no command line arguments to begin with ($1 is NULL), the loop immediately terminates without entry into the body.  

Consider the problem of adding a suffix to several files.

Those familiar with a DOS or Windows Power Shell environment could use a command like this:

ren assig* assig*.bak

Unfortunately a similar command does not work in Unix:

mv assig* assig*.backup

Nevertheless, this problem can be solved with the simple use of a for command:

for filevar in assig*
do
   mv ${filevar} ${filevar}.backup
done 

Explanatory notes

1. The word list is the wildcard file specification assig*.  On expansion, for the purposes of this example, assume that the result is three matching files: assig1, assig2, assig3.
2. Each of these words is substituted one-at-a-time in the loop variable filevar, and the body of the loop is run (code between do and done).
3. When the body of the loop is run with the variable substitutions, the effective commands generated are:

• mv assig1 assig1.backup

• mv assig2 assig2.backup

• mv assig3 assig3.backup

Additional Notes

1. There is no specific string concatenation operator in Unix.  Simply placing text adjacently achieves the desired result.  Here the string “.backup” is appended to the “assig1”, etc.
2. As stated earlier, while the use of set braces { } is often omitted when spelling variables, here it helps to clarify the distinction between the variable name and surrounding text.

Print the number of entries in the /etc directory.

count=0
for files in $(ls /etc)
do
   count=$(( $count +1 ))
done
echo The number of entries is $count 

Explanatory notes

1. The word list consists of a command substitution call of the ls command on the /etc directory.
2. Expansion of this word list is the names of the entries in the /etc directory.
3. Each name is substituted into the loop variable files.
4. The body of the loop consists of incrementing a counter which will eventually hold the number of entries.
5. Outside the loop, the total number of entries is printed in an appropriate message.

Let’s say that you want to write your own Unix script that will accept any number of command line arguments:

mycmd parm1 parm2 …

Here is another method, this one using the for command

for cmdarg in $*
do
        myprocess $cmdarg
done
 

Explanatory notes

1. The special variable $* expands to all command line arguments present starting with $1.
2. Each of these words is substituted into the loop variable cmdarg.
3. The body of the loop is run against each command line argument (myprocess is a fictitious Unix command or script).
4. Unlike the while command example, there is no need for the shift command.
5. The value of $# is intact after the completion of the for loop.