Linux Logic Operations

Introduction

Welcome to the Linux Logic Operations lab. In this lab, you will learn about logical operations in Linux, which are essential tools for controlling command execution flow and making decisions in scripts.

Logical operations allow you to combine commands and conditions, enabling you to create more sophisticated scripts that can respond to different situations. By the end of this lab, you will understand how to use logical operators to control command execution and check file attributes in Linux.

Skills Graph

Understanding Basic Logical Operations in Linux

Linux shell provides several ways to combine commands and conditions using logical operators. In this step, you will learn about the most commonly used logical operators: && (AND) and || (OR).

First, let's navigate to our project directory:

cd ~/project

Let's start by creating some test files that we'll use throughout this lab:

touch treasure_map.txt shield.txt kings_gauntlet.txt

Now, let's create a script to demonstrate basic logical operations. We'll use the nano text editor to create a file called logic_basics.sh:

nano logic_basics.sh

In this script, we'll use logical operators to check if two files exist. Type or paste the following code into the editor:

#!/bin/bash

## This script demonstrates logical AND (&&) and OR (||) operators
## It checks if two specific files exist in the current directory

if [[ -f "treasure_map.txt" ]] && [[ -f "shield.txt" ]]; then
  echo "Both files exist. Proceed with the mission."
else
  echo "One or both files are missing. Abort the mission!"
fi

The && operator means "AND" - both conditions must be true for the overall condition to be true.
The -f test checks if a file exists and is a regular file (not a directory or other special file).

To save the file in nano, press Ctrl+X, then press Y to confirm saving, and press Enter to confirm the filename.

Now, let's make the script executable and run it:

chmod +x logic_basics.sh
./logic_basics.sh

You should see the output:

Both files exist. Proceed with the mission.

Let's try another example to better understand logical operators. Create a new script called logical_or.sh:

nano logical_or.sh

Add the following content:

#!/bin/bash

## This script demonstrates the logical OR (||) operator
## It checks if at least one of two files exists

if [[ -f "treasure_map.txt" ]] || [[ -f "nonexistent_file.txt" ]]; then
  echo "At least one file exists."
else
  echo "Neither file exists."
fi

The || operator means "OR" - if either condition is true, the overall condition is true.

Save the file (Ctrl+X, Y, Enter), make it executable, and run it:

chmod +x logical_or.sh
./logical_or.sh

Output:

At least one file exists.

This demonstrates that even though "nonexistent_file.txt" doesn't exist, the condition is still true because "treasure_map.txt" does exist.

Logical Operations with File Permissions

In Linux, file permissions control who can read, write, or execute files. In this step, you'll learn how to use logical operations to check file permissions.

First, let's create a script called permission_check.sh:

nano permission_check.sh

Add the following content to the script:

#!/bin/bash

## This script checks read and write permissions on a file
## using logical operators

filename="kings_gauntlet.txt"

if [[ -r "$filename" ]] && [[ -w "$filename" ]]; then
  echo "You have read and write permissions on $filename."
elif [[ -r "$filename" ]] || [[ -w "$filename" ]]; then
  echo "You have limited permissions on $filename."
else
  echo "You do not have permissions on $filename."
fi

In this script:

• -r tests if a file is readable by the current user
• -w tests if a file is writable by the current user
• The && operator requires both conditions to be true
• The || operator requires at least one condition to be true

Save the file (Ctrl+X, Y, Enter) and make it executable:

chmod +x permission_check.sh

Now, let's modify the permissions of our test file and see how it affects our script's output.

First, let's set the permissions to allow both reading and writing:

chmod 600 kings_gauntlet.txt
./permission_check.sh

Output:

You have read and write permissions on kings_gauntlet.txt.

Now, let's change the permissions to read-only:

chmod 400 kings_gauntlet.txt
./permission_check.sh

Output:

You have limited permissions on kings_gauntlet.txt.

Finally, let's remove all permissions:

chmod 000 kings_gauntlet.txt
./permission_check.sh

Output:

You do not have permissions on kings_gauntlet.txt.

Don't forget to restore reasonable permissions to the file:

chmod 600 kings_gauntlet.txt

Command Chaining with Logical Operators

Logical operators in Linux aren't just for conditional statements in scripts - they can also be used directly in the command line to chain commands together. In this step, you'll learn how to use logical operators for command chaining.

The && operator allows you to run a second command only if the first command succeeds (returns a zero exit status). This is useful for running a sequence of commands where each step depends on the previous step's success.

Let's try a simple example:

mkdir -p test_dir && echo "Directory created successfully"

The mkdir -p command creates a directory (and parent directories if needed), and the -p option prevents an error if the directory already exists. The echo command runs only if the mkdir command succeeds.

Output:

Directory created successfully

Now, let's try the || operator, which runs the second command only if the first command fails:

ls nonexistent_file.txt || echo "File not found"

Since "nonexistent_file.txt" doesn't exist, the ls command fails, and the echo command runs.

Output:

ls: cannot access 'nonexistent_file.txt': No such file or directory
File not found

You can also combine multiple commands using these operators. Create a script called command_chain.sh:

nano command_chain.sh

Add the following content:

#!/bin/bash

## This script demonstrates chaining commands with logical operators

echo "Starting command chain..."

## Create a directory and enter it only if creation succeeds
mkdir -p logic_test && cd logic_test && echo "Changed to new directory"

## Create a file and write to it only if creation succeeds
touch test_file.txt && echo "This is a test" > test_file.txt && echo "Created and wrote to file"

## Try to read a nonexistent file, or display an error message
cat nonexistent.txt || echo "Failed to read file"

## Return to the original directory
cd .. && echo "Returned to original directory"

echo "Command chain completed"

Save the file (Ctrl+X, Y, Enter), make it executable, and run it:

chmod +x command_chain.sh
./command_chain.sh

Output:

Starting command chain...
Changed to new directory
Created and wrote to file
cat: nonexistent.txt: No such file or directory
Failed to read file
Returned to original directory
Command chain completed

This script demonstrates how logical operators can control the flow of command execution based on the success or failure of previous commands.

Advanced File Testing Operators

Linux provides a variety of file testing operators that can be combined with logical operators. In this step, you'll learn about some of the most useful file testing operators.

Let's create a script that demonstrates these operators:

nano file_tests.sh

Add the following content:

#!/bin/bash

## This script demonstrates various file testing operators in Linux

## Check if a file exists (as a file, directory, or other type)
file_to_check="treasure_map.txt"
directory_to_check="test_dir"

echo "--- Basic File Tests ---"
## -e checks if the file exists (any type)
if [[ -e "$file_to_check" ]]; then
  echo "$file_to_check exists"
else
  echo "$file_to_check does not exist"
fi

## -f checks if it's a regular file (not a directory or device)
if [[ -f "$file_to_check" ]]; then
  echo "$file_to_check is a regular file"
fi

## -d checks if it's a directory
if [[ -d "$directory_to_check" ]]; then
  echo "$directory_to_check is a directory"
else
  echo "$directory_to_check is not a directory"
fi

echo "--- File Size Tests ---"
## -s checks if file is not empty (has a size greater than zero)
if [[ -s "$file_to_check" ]]; then
  echo "$file_to_check is not empty"
else
  echo "$file_to_check is empty"
fi

echo "--- Permission Tests ---"
## -r, -w, -x check read, write, and execute permissions
if [[ -r "$file_to_check" ]]; then
  echo "$file_to_check is readable"
fi

if [[ -w "$file_to_check" ]]; then
  echo "$file_to_check is writable"
fi

if [[ -x "$file_to_check" ]]; then
  echo "$file_to_check is executable"
else
  echo "$file_to_check is not executable"
fi

echo "--- Combining Tests with Logical Operators ---"
## Combining tests with AND (&&)
if [[ -f "$file_to_check" ]] && [[ -r "$file_to_check" ]]; then
  echo "$file_to_check is a readable file"
fi

## Combining tests with OR (||)
if [[ -f "$file_to_check" ]] || [[ -d "$file_to_check" ]]; then
  echo "$file_to_check is either a file or a directory"
fi

Save the file (Ctrl+X, Y, Enter), make it executable, and run it:

chmod +x file_tests.sh
./file_tests.sh

The output will show the results of various file tests on our existing files and directories.

To make the tests more interesting, let's add some content to our treasure_map.txt file and create the directory we're testing:

echo "This is a treasure map!" > treasure_map.txt
mkdir -p test_dir

Now run the script again:

./file_tests.sh

You should see a different output now that the file has content and the directory exists.

This script demonstrates how to use various file testing operators and combine them with logical operators to create sophisticated file checks.

Summary

In this lab, you have learned about logical operations in Linux and how they can be used to control the flow of command execution and script behavior. Here's a summary of what you've learned:

1. You learned about the basic logical operators && (AND) and || (OR) and how to use them in conditional statements.

2. You used file testing operators such as -f, -r, -w, and -x to check for file existence and permissions.

3. You practiced chaining commands together using logical operators to create sequences of operations that depend on the success or failure of previous commands.

4. You explored various file testing operators and learned how to combine them with logical operators to create more complex conditions.

These logical operations are fundamental tools in Linux scripting and command-line usage. They allow you to create more sophisticated scripts that can handle different situations based on conditions and previous command results.

By mastering logical operations, you have gained an essential skill for Linux system administration, automation, and scripting that will serve you well in your journey as a Linux user or administrator.