Using Logical Operators in Shell

Summary:
Combine conditions using &&, ||, -a, and -o.

Shell scripting is a powerful tool for automating tasks and combining commands in creative ways. One key aspect is how you combine and control the flow of commands with logical operators. Understanding operators like &&, ||, -a, and -o is essential for crafting efficient and readable scripts. In this article, we’ll explore these logical operators, see their differences, and learn how to use them effectively.

Table of Contents

What Are Logical Operators?

Logical operators allow you to control the sequence and dependency of command execution or check multiple conditions in shell scripts.

  • Command-level logic: Combine separate shell commands using && (AND) and || (OR).
  • Test-level logic: Combine test conditions inside [ ... ], test, or [[ ... ]] using -a (AND) and -o (OR).

Knowing when and how to use each makes your scripts robust and flexible.

Using && (AND Operator)

&& is a short-circuit AND operator between commands:

  • Runs the second command only if the first succeeds.
  • Uses the exit status: 0 is success, anything else is failure.

Syntax:

command1 && command2
  • command2 runs only if command1 succeeds.

Example:

ls some_dir && echo "Directory exists."

If ls some_dir succeeds (exit code 0), it prints the message.

Using || (OR Operator)

|| is a short-circuit OR operator between commands:

  • Runs the second command only if the first fails.
  • Based on exit status.

Syntax:

command1 || command2
  • command2 runs only if command1 fails.

Example:

ls some_dir || echo "Directory does not exist."

If the directory is missing (exit code not 0), it prints the message.

Logical Operators in Conditionals (-a and -o)

Inside [ ... ], you can combine multiple test conditions:

  • -a (AND) returns true if both conditions are true.
  • -o (OR) returns true if either condition is true.

Syntax:

[ condition1 -a condition2 ]
[ condition1 -o condition2 ]

Examples:

# Both files must exist
if [ -f file1.txt -a -f file2.txt ]; then
    echo "Both files exist."
fi

# Either file must exist
if [ -f file1.txt -o -f file2.txt ]; then
    echo "At least one file exists."
fi

TIP:

  • In scripts using [[ ... ]], you can use && and || inside test expressions: 
    if [[ -f file1.txt && -f file2.txt ]]; then ... fi
  • [[ ... ]] is generally more versatile and less error-prone than [ ... ].

Best Practices and Warnings

  • Use parentheses with multiple conditions:
    Group conditions for clarity and correct precedence. 
    [ \( cond1 -a cond2 \) -o cond3 ]
  • Prefer [[ ... ]] for advanced scripting:
    It handles logical operators better and avoids some parsing issues.
  • Avoid confusing command-level vs. test-level operators:
    Remember: && and || join actual commands, -a and -o join test expressions.

Examples

1. Combine Command Execution

#!/bin/sh
mkdir backup && echo "Backup directory created."

Only echoes if the mkdir command succeeded.

2. Fallback Action on Failure

#!/bin/sh
cp important.txt /backup/ || echo "Backup failed!"

If the copy fails, the script warns the user.

3. Multiple Conditions in [ ... ]

#!/bin/sh
if [ -f "$1" -a -r "$1" ]; then
    echo "File exists and is readable."
else
    echo "File not found or not readable."
fi

Tests if the file ($1) both exists and is readable.

4. Using [[ ... ]] in Bash

#!/bin/bash
if [[ -d dir1 || -d dir2 ]]; then
    echo "At least one directory exists."
fi

This syntax is supported in Bash but not POSIX sh.

Conclusion

Logical operators are indispensable tools in shell scripting, letting you craft scripts that act intelligently based on conditions and command outcomes. Remember:

  • Use && and || to chain commands based on their success or failure.
  • Use -a and -o to combine test conditions inside [ ... ], and prefer [[ ... ]] for advanced logic in Bash.
  • Always double-check your logic for correctness and readability.

Mastering these operators will help you create efficient, reliable, and maintainable shell scripts!

Back to All Articles