| |
A loop is a block of code that iterates
(repeats) a list of commands as long as the loop control condition is
true. - for (in)
This is the basic looping construct. It differs significantly
from its C counterpart. for [arg] in [list]
do
command...
done Note that list may contain wild cards. Note further that if do is on same line as
for, there needs to be a semicolon before list. for [arg] in [list] ; do
Example 3-26. Simple for loops #!/bin/bash
for planet in Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune Pluto
do
echo $planet
done
echo
# Entire 'list' enclosed in quotes creates a single variable.
for planet in "Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune Pluto"
do
echo $planet
done
exit 0 |
Note: Each [list] element
may contain multiple parameters. This is useful when
processing parameters in groups. In such cases, use the
set command (see Example 3-40)
to force parsing of each [list]
element and assignment of each component to the positional
parameters.
Example 3-27. for loop with two parameters in each
[list] element #!/bin/bash
# Planets revisited.
# Want to associate name of each planet with its distance from the sun.
for planet in "Mercury 36" "Venus 67" "Earth 93" "Mars 142" "Jupiter 483"
do
set $planet # Parses variable "planet" and sets positional parameters.
# May need to save original positional parameters, since they get overwritten.
echo "$1 $2,000,000 miles from the sun"
#-------two tabs---concatenate zeroes onto parameter $2
done
exit 0 |
Omitting the in [list] part of a
for loop causes the loop to operate on
$*, the list of arguments given on the command line
to the script. Example 3-28. Missing in [list] in a
for loop #!/bin/bash
# Invoke both with and without arguments,
# and see what happens.
for a
do
echo $a
done
# 'in list' missing, therefore operates on '$*'
# (command-line argument list)
exit 0 |
Example 3-29. Using efax in batch mode #!/bin/bash
if [ $# -ne 2 ]
# Check for proper no. of command line args.
then
echo "Usage: `basename $0` phone# text-file"
exit 1
fi
if [ ! -f $2 ]
then
echo "File $2 is not a text file"
exit 2
fi
# Create fax formatted files from text files.
fax make $2
for file in $(ls $2.0*)
# Concatenate the converted files.
# Uses wild card in variable list.
do
fil="$fil $file"
done
# Do the work.
efax -d /dev/ttyS3 -o1 -t "T$1" $fil
exit 0 |
- while
This construct tests for a condition at the top of a loop, and keeps
looping as long as that condition is true. while [condition]
do
command...
done As is the case with for/in loops, placing the
do on the same line as the condition test
requires a semicolon. while [condition] ; do Note that certain specialized while loops, as,
for example, a getopts construct, deviate
somewhat from the standard template given here (see Section 3.9). Example 3-30. Simple while loop #!/bin/bash
var0=0
while [ "$var0" -lt 10 ]
do
echo -n "$var0 "
# -n suppresses newline.
var0=`expr $var0 + 1`
# var0=$(($var0+1)) also works.
done
echo
exit 0 |
Example 3-31. Another while loop #!/bin/bash
echo
while [ "$var1" != end ]
do
echo "Input variable #1 (end to exit) "
read var1
# It's not 'read $var1' because value of var1 is being set.
echo "variable #1 = $var1"
# Need quotes because of #
echo
done
# Note: Echoes 'end' because termination condition tested for at top of loop.
exit 0 |
Note: A while loop may have multiple
conditions. Only the final condition determines when the loop
terminates. This necessitates a slightly different loop syntax,
however.
Example 3-32. while loop with multiple conditions #!/bin/bash
var1=unset
previous=$var1
while echo "previous-variable = $previous"
echo
previous=$var1
[ "$var1" != end ] # Keeps track of what "var1" was previously.
# Four conditions on "while", but only last one controls loop.
# Controlling condition has [ test ] brackets.
do
echo "Input variable #1 (end to exit) "
read var1
echo "variable #1 = $var1"
done
# Try to figure out how this all works.
# It's a wee bit tricky.
exit 0 |
Note: A while loop may have its
stdin redirected to a file by a
< at its end (see Example 3-73).
- until
This construct tests for a condition at the top of a loop, and keeps
looping as long as that condition is false (opposite of
while loop). until [condition-is-true]
do
command...
done Note that an until loop tests for the
terminating condition at the top of the loop, differing from a
similar construct in some programming languages. As is the case with for/in loops, placing the
do on the same line as the condition test
requires a semicolon. until [condition-is-true] ; do Example 3-33. until loop #!/bin/bash
until [ "$var1" = end ]
# Tests condition at top of loop.
do
echo "Input variable #1 "
echo "(end to exit)"
read var1
echo "variable #1 = $var1"
done
exit 0 |
- break, continue
The break and continue
loop control commands correspond exactly to their counterparts in
other programming languages. The break command
terminates the loop (breaks out of it), while continue
causes a jump to the next iteration of the loop, skipping all the
remaining commands in that particular loop cycle. Example 3-34. Effects of break and
continue in a loop #!/bin/bash
echo
echo Printing Numbers 1 through 20.
a=0
while [ $a -le 19 ]
do
a=$(($a+1))
if [ $a -eq 3 ] || [ $a -eq 11 ]
# Excludes 3 and 11
then
continue
# Skip rest of this particular loop iteration.
fi
echo -n "$a "
done
# Exercise for reader:
# Why does loop print up to 20?
echo
echo
echo Printing Numbers 1 through 20, but something happens after 2.
##################################################################
# Same loop, but substituting 'break' for 'continue'.
a=0
while [ $a -le 19 ]
do
a=$(($a+1))
if [ $a -gt 2 ]
then
break
# Skip entire rest of loop.
fi
echo -n "$a "
done
echo
echo
exit 0 |
- case (in) / esac
The case construct is the shell equivalent
of switch in C/C++.
It permits branching to one of a number of code blocks, depending
on condition tests. It serves as a kind of shorthand for multiple
if/then/else statements and is an appropriate tool
for creating menus. case "$variable" in
"$condition1" )
command...
;;
"$condition2" )
command...
;;
esac Note: Quoting the variables is recommended. Each test line ends with a left paren ). Each condition block ends with a double
semicolon ;;. The entire case block terminates with an
esac (case spelled
backwards).
Example 3-35. Using case #!/bin/bash
echo
echo "Hit a key, then hit return."
read Keypress
case "$Keypress" in
[a-z] ) echo "Lowercase letter";;
[A-Z] ) echo "Uppercase letter";;
[0-9] ) echo "Digit";;
* ) echo "Punctuation, whitespace, or other";;
esac
# Allows ranges of characters in [square brackets].
exit 0 |
Example 3-36. Creating menus using case #!/bin/bash
# Crude rolodex-type database
clear
# Clear the screen.
echo " Contact List"
echo " ------- ----"
echo "Choose one of the following persons:"
echo
echo "[E]vans, Roland"
echo "[J]ones, Mildred"
echo "[S]mith, Julie"
echo "[Z]ane, Morris"
echo
read person
case "$person" in
# Note variable is quoted.
"E" | "e" )
# Accept upper or lowercase input.
echo
echo "Roland Evans"
echo "4321 Floppy Dr."
echo "Hardscrabble, CO 80753"
echo "(303) 734-9874"
echo "(303) 734-9892 fax"
echo "revans@zzy.net"
echo "Business partner & old friend"
;;
# Note double semicolon to terminate
# each option.
"J" | "j" )
echo
echo "Mildred Jones"
echo "249 E. 7th St., Apt. 19"
echo "New York, NY 10009"
echo "(212) 533-2814"
echo "(212) 533-9972 fax"
echo "milliej@loisaida.com"
echo "Girlfriend"
echo "Birthday: Feb. 11"
;;
# Add info for Smith & Zane later.
* )
# Default option.
echo
echo "Not yet in database."
;;
esac
echo
exit 0 |
- select
The select construct, adopted from the Korn
Shell, is yet another tool for building menus. select variable [in list]
do
command...
break
done This prompts the user to enter one of the choices presented in the
variable list. Note that select uses the
PS3 prompt (#? ) by default,
but that this may be changed. Example 3-37. Creating menus using select #!/bin/bash
PS3='Choose your favorite vegetable: '
# Sets the prompt string.
echo
select vegetable in "beans" "carrots" "potatoes" "onions" "rutabagas"
do
echo
echo "Your favorite veggie is $vegetable."
echo "Yuck!"
echo
break
# if no 'break' here, keeps looping forever.
done
exit 0 |
If in list is
omitted, then select uses the list of command
line arguments ($@) passed to the script or to
the function in which the select construct is
embedded. (Compare this to the behavior of a
for variable [in list]
construct with the
in list
omitted.)Example 3-38. Creating menus using select in a function #!/bin/bash
PS3='Choose your favorite vegetable: '
echo
choice_of()
{
select vegetable
# [in list] omitted, so 'select' uses arguments passed to function.
do
echo
echo "Your favorite veggie is $vegetable."
echo "Yuck!"
echo
break
done
}
choice_of beans rice carrots radishes tomatoes spinach
# $1 $2 $3 $4 $5 $6
# passed to choice_of() function
exit 0 |
|
