Combining Multiple Conditions In Bash Script Conditionals

Checking Multiple Conditions in if Statements

Bash scripts often need to check multiple conditions before executing commands. The bash if statement allows checking multiple conditions using Boolean operators AND and OR.

The AND operator (&&) evaluates as true if both the conditions on either side of it are true. The OR operator (||) evaluates as true if either of the conditions on either side is true.


if [ "$x" -gt 10 ] && [ "$y" -lt 20 ] 
then
  echo "Both conditions are true"
fi

In this example, the echo command will execute only if $x is greater than 10 AND $y is less than 20. The square brackets [] around the conditions represent the test command, which evaluates conditional expressions in Bash.

Table of Contents

Similarly, the OR operator || combines two conditions where either one being true causes the overall condition to be true:

  
if [ "$x" -lt 5 ] || [ "$y" -gt 30 ]
then
  echo "At least one condition is true" 
fi

Here if $x is less than 5 OR $y is greater than 30, the echo command will execute. The || operator implements logical OR, while the && implements logical AND.

Nesting if Statements

In addition to Boolean operators, bash also allows nesting of multiple if statements to implement multi-way conditional logic:


if [ condition1 ] 
then
  statements1
elif [ condition2 ]  
then 
  statements2
else
  statements3  
fi

The elif clause lets you chain multiple conditional checks, equivalent to else if in other languages. The final else clause handles the default case when none of the conditions match.

Nesting if statements allows checking many possible condition permutations in a readable way. However, using too many nested blocks can hamper readability. Moderation is key.

Combining Test Commands with Boolean Operators

Bash evaluates compound test commands by first parsing them into discrete test blocks joined by conditional operators. Each test block returns true or false based on the condition.


if [ condition1 ] && [ condition2 ] 
# Evaluated as:
# if (test condition1) && (test condition2)

The test blocks sets exit codes of 0 for true or 1 for false. Bash ANDs and ORs these exit codes for the overall result.

Operator Precedence Rules

Bash evaluates AND operators && before OR operators || because AND has higher precedence.
Parentheses can override operator precedence.


if [[ condition1 && condition2 ]] || [[ condition3 ]]
# Evaluates condition1 && condition2 first

Knowing Bash operator precedence allows properly structuring compound conditionals without ambiguity.

Short-Circuit Evaluation

Bash compounds use short-circuit evaluation – conditions are tested from left to right, and evaluation stops as soon as an overall result can be determined.

  
if [ condition1 ] && [ condition2 ] 
# condition2 will NOT be tested if condition1 is false

Short-circuit evaluation avoids unnecessary tests and makes Bash conditionals efficient. Understanding this order of evaluation is key to writing robust compound conditionals.

Using Conditional Expressions with [[ ]]

The [[ ]] construct allows creating conditional expressions with Boolean operators like [[ $x -lt 100 && $y -gt 10 ]].


if [[ "$x" -lt 100 && "$y" -gt 10 ]]  
then
  echo "x is less than 100 AND y is greater than 10"
fi

The [[ ]] syntax is more convenient than having separate test commands. Multiple conditions can be specified in one [[ ]] block using Bash logical operators like -a for AND and -o for OR.

String Comparisons and Regular Expressions

The [[ ]] construct has built-in support for string comparisons and regular expression matching using the =~ operator.


string="Hello world"
if [[ "$string" =~ "lo w" ]]
then
  echo "String matches regex" 
fi

Being able to match strings against patterns and wildcards provides powerful text processing capabilities.

Simpler Code with [[ ]]

Overall the [[ ]] conditional expression syntax results in simpler code vs individual [ ] test commands:

  
# With [ ] 
if [ "$x" -gt 100 ] && [ "$y" -lt 50 ]  

# With [[ ]]
if [[ "$x" -gt 100 && "$y" -lt 50 ]]

This simplification improves readability for complex Bash conditional logic.

Tips for Structuring Multi-Condition Tests

Properly structuring multi-condition Bash tests improves script readability, reusability and maintainability. Here are some tips:

Check Necessary Conditions First

Start with the simplest, most general conditions required for program logic. Check for necessary inputs or prerequisites first:


if [ -z "$1" ]  
  # Fail if no command line args
then
  echo "No input provided" >&2
  exit 1
fi

This avoids unnecessary further tests if basic requirements are not met.

Consistent Indentation

Indent nested if statements and code blocks consistently:


if [ condition1 ]
  then
    if [ condition2 ] 
      then
       action1
     fi
fi

Proper indentation greatly improves readability of multi-condition tests.

Functions for Code Reuse

Encapsulate complex multi-condition checks into reusable functions:


validateInput() {
  if [ -z "$1" ]
    return 1
  # Additional checks
  return 0  
}

if validateInput "$input"  
  # Main logic
fi

This makes condition checking modular and code reuse easier.

Use Comments Liberally

Use comments to document the meaning and purpose of non-trivial conditionals:


# Check user permissions
if [[ "$userid" != "admin" && ! -f ~/"$userid"/.accessToken ]]
  # Permission denial logic
fi

Comments help maintain complex conditional logic and edge cases.

Conclusion

Bash provides flexible tools like if statements, Boolean operators, nested blocks and [[ ]] to check multi-condition logic. By understanding Bash evaluation rules and best practices in structuring conditionals, robust and readable multi-condition tests can be implemented in scripts. Consistent indentation, modularity and comments also improve maintainability of complex conditional flows.