- •Advanced Bash-Scripting Guide
- •Dedication
- •Table of Contents
- •Part 1. Introduction
- •Advanced Bash-Scripting Guide
- •Chapter 2. Starting Off With a Sha-Bang
- •2.1. Invoking the script
- •2.2. Preliminary Exercises
- •Part 2. Basics
- •Chapter 3. Exit and Exit Status
- •Chapter 4. Special Characters
- •Chapter 5. Introduction to Variables and Parameters
- •5.1. Variable Substitution
- •5.2. Variable Assignment
- •5.3. Bash Variables Are Untyped
- •5.4. Special Variable Types
- •Chapter 6. Quoting
- •Chapter 7. Tests
- •7.1. Test Constructs
- •7.2. File test operators
- •7.3. Comparison operators (binary)
- •7.4. Nested if/then Condition Tests
- •7.5. Testing Your Knowledge of Tests
- •8.1. Operators
- •8.2. Numerical Constants
- •Part 3. Beyond the Basics
- •Chapter 9. Variables Revisited
- •9.1. Internal Variables
- •9.2. Manipulating Strings
- •9.3. Parameter Substitution
- •9.4. Typing variables: declare or typeset
- •9.5. Indirect References to Variables
- •9.6. $RANDOM: generate random integer
- •9.7. The Double Parentheses Construct
- •Chapter 10. Loops and Branches
- •10.1. Loops
- •10.2. Nested Loops
- •10.3. Loop Control
- •10.4. Testing and Branching
- •Chapter 11. Internal Commands and Builtins
- •12.1. Basic Commands
- •12.2. Complex Commands
- •12.3. Time / Date Commands
- •12.4. Text Processing Commands
- •12.5. File and Archiving Commands
- •12.6. Communications Commands
- •12.7. Terminal Control Commands
- •12.8. Math Commands
- •12.9. Miscellaneous Commands
- •Chapter 13. System and Administrative Commands
- •Chapter 14. Command Substitution
- •Chapter 15. Arithmetic Expansion
- •Chapter 16. I/O Redirection
- •16.1. Using exec
- •16.2. Redirecting Code Blocks
- •16.3. Applications
- •Chapter 17. Here Documents
- •Chapter 18. Recess Time
- •Part 4. Advanced Topics
- •Chapter 19. Regular Expressions
- •19.1. A Brief Introduction to Regular Expressions
- •19.2. Globbing
- •Chapter 20. Subshells
- •Chapter 21. Restricted Shells
- •Chapter 22. Process Substitution
- •Chapter 23. Functions
- •23.1. Complex Functions and Function Complexities
- •23.2. Local Variables
- •Chapter 24. Aliases
- •Chapter 25. List Constructs
- •Chapter 26. Arrays
- •Chapter 27. Files
- •Chapter 28. /dev and /proc
- •28.2. /proc
- •Chapter 29. Of Zeros and Nulls
- •Chapter 30. Debugging
- •Chapter 31. Options
- •Chapter 32. Gotchas
- •Chapter 33. Scripting With Style
- •Chapter 34. Miscellany
- •34.2. Shell Wrappers
- •34.3. Tests and Comparisons: Alternatives
- •34.4. Optimizations
- •34.5. Assorted Tips
- •34.6. Oddities
- •34.7. Security Issues
- •34.8. Portability Issues
- •34.9. Shell Scripting Under Windows
- •Chapter 35. Bash, version 2
- •36. Endnotes
- •36.1. Author's Note
- •36.2. About the Author
- •36.3. Tools Used to Produce This Book
- •36.4. Credits
- •List of Tables
- •List of Examples
- •Bibliography
List Constructs
Advanced Bash-Scripting Guide:
Prev |
Next |
Chapter 25. List Constructs
The "and list" and "or list" constructs provide a means of processing a number of commands consecutively. These can effectively replace complex nested if/then or even case statements.
Chaining together commands
and list
command-1 && command-2 && command-3 && ... command-n
Each command executes in turn provided that the previous command has given a return value of true (zero). At the first false (non-zero) return, the command chain terminates (the first command returning false is the last one to execute).
Example 25-1. Using an "and list" to test for command-line arguments
#!/bin/bash
# "and list"
if [ ! -z "$1" ] && echo "Argument #1 = $1" && [ ! -z "$2" ] && echo "Argument #2 = $2"
then
echo "At least 2 arguments passed to script."
#All the chained commands return true.
else
echo "Less than 2 arguments passed to script."
#At least one of the chained commands returns false.
fi
#Note that "if [ ! -z $1 ]" works, but its supposed equivalent,
#if [ -n $1 ] does not. However, quoting fixes this.
#if [ -n "$1" ] works. Careful!
#It is best to always quote tested variables.
#This accomplishes the same thing, using "pure" if/then statements. if [ ! -z "$1" ]
then
echo "Argument #1 = $1"
fi
if [ ! -z "$2" ] then
echo "Argument #2 = $2"
echo "At least 2 arguments passed to script." else
echo "Less than 2 arguments passed to script."
fi
#It's longer and less elegant than using an "and list".
exit 0
http://tldp.org/LDP/abs/html/list-cons.html (1 of 3) [7/15/2002 6:34:38 PM]
List Constructs
Example 25-2. Another command-line arg test using an "and list"
#!/bin/bash |
|
|
ARGS=1 |
# |
Number of arguments expected. |
E_BADARGS=65 |
# |
Exit value if incorrect number of args passed. |
test $# -ne $ARGS && echo "Usage: `basename $0` $ARGS argument(s)" && exit $E_BADARGS
#If condition-1 true (wrong number of args passed to script),
#then the rest of the line executes, and script terminates.
#Line below executes only if the above test fails.
echo "Correct number of arguments passed to this script."
exit 0
# To check exit value, do a "echo $?" after script termination.
or list
command-1 || command-2 || command-3 || ... command-n
Each command executes in turn for as long as the previous command returns false. At the first true return, the command chain terminates (the first command returning true is the last one to execute). This is obviously the inverse of the "and list".
Example 25-3. Using "or lists" in combination with an "and list"
#!/bin/bash
#delete.sh, not-so-cunning file deletion utility.
#Usage: delete filename
E_BADARGS=65
if [ -z "$1" ] then
echo "Usage: `basename $0` filename"
exit $E_BADARGS |
# No arg? Bail out. |
else |
|
file=$1 |
# Set filename. |
fi |
|
[ ! -f "$file" ] && echo "File \"$file\" not found. \ Cowardly refusing to delete a nonexistent file."
#AND LIST, to give error message if file not present.
#Note echo message continued on to a second line with an escape.
[ ! -f "$file" ] || (rm -f $file; echo "File \"$file\" deleted.")
#OR LIST, to delete file if present.
#( command1 ; command2 ) is, in effect, an AND LIST variant.
#Note logic inversion above.
#AND LIST executes on true, OR LIST on false.
exit 0
http://tldp.org/LDP/abs/html/list-cons.html (2 of 3) [7/15/2002 6:34:38 PM]
List Constructs
If the first command in an "or list" returns true, it will execute.
The exit status of an and list or an or list is the exit status of the last command executed.
Clever combinations of "and" and "or" lists are possible, but the logic may easily become convoluted and require extensive debugging.
false && true |
|| echo false |
# false |
||
# Same result |
as |
|
|
|
( false && true |
) || echo false |
# false |
||
# But |
*not* |
|
|
|
false |
&& ( true |
|| echo false ) |
# (nothing echoed) |
#Note left-to-right grouping and evaluation of statements,
#since the logic operators "&&" and "||" have equal precedence.
#It's best to avoid such complexities, unless you know what you're doing.
#Thanks, S.C.
See Example A-8 for an illustration of using an and / or list to test variables.
Prev |
Home |
Next |
Aliases |
Up |
Arrays |
http://tldp.org/LDP/abs/html/list-cons.html (3 of 3) [7/15/2002 6:34:38 PM]