Bash Syntax Cheat Sheet

Have you ever found yourself scripting, only to hit a snag remembering the exact syntax for a Bash command? Enter the Bash Cheat Sheet: your concise companion in the vast world of Bash programming. This guide is crafted to demystify the language, its usage, and its intricate syntax. With a dedicated reference section for commands and key programming concepts, followed by practical example code snippets, this cheat sheet is poised to illuminate the path for both beginners and seasoned professionals alike.

In a realm as expansive as programming, this Bash cheat sheet can be your guiding light. From troubleshooting pesky errors to navigating through directories, or automating tasks, embrace this cheat sheet and remember, proficiency in any programming language is a marathon, not a sprint, paved with continuous learning and practice. So, let’s set sail on this exciting journey to unlock the full potential of Bash. Ready your terminals, and let’s dive into Bash!

Command Reference Section

Before diving into practical examples, let’s explore the various commands and concepts of Bash. This reference section will also provide explanations and example usage cases when applicable. These topics will serve as key tools while scripting in Bash and will also deepen your understanding of the following Sample Code.

Command Chaining

Common Commands

Command Modifiers

Modifier Flags for ls

Modifier Flags for grep

Modifier Flags for mkdir

Modifier Flags for rm

Modifier Flags for echo

Modifier Flags for cat

Modifier Flags for touch

Modifier Flags for cp

Modifier Flags for mv

Modifier Flags for find

Modifier Flags for chmod

Modifier Flags for chown

Flags

Command Line Parameters

Sorting Methods

Data Types

Boolean Operations

Function Structure

Variables

Environment Variables

Operators

Arithmetic Operators

Assignment Operators

Logical Operators

Relational Operators

Data Structures

Statements and Loops

Internal Field Separator (IFS)

String Manipulation

Regex & Pattern Matching

Date and Time

Text Color and Formatting

Common Errors

Script Comments

Script Output

Networking Commands

Debugging and Error Handling

Bash Sample Script & Syntax

In this section, we’ll walk through a straightforward Bash script that demonstrates how different Bash scripting concepts come together. The following script will provide practical syntax examples, followed by echo statements to showcase what the codeblocks would output. Before the Script, we will instruct you on how to prepare an environment, so that you may run the code yourself!

Setting Up Your Environment

To prepare your environment for running Bash scripts, follow these streamlined steps:

1. Choose an IDE or Editor:
   Pick your preferred editor like Visual Studio Code, Atom, Sublime Text, or a terminal-based editor like Vim or Emacs for writing Bash scripts.

2. Ensure Bash is Available:
   Linux/macOS: Bash is typically pre-installed.
   Windows: Install Windows Subsystem for Linux (WSL), Git Bash, or Cygwin.

3. Create and Open Your Bash Script:
   Open your editor, create a new file, paste the Bash script, and save it with a .sh extension, e.g., myscript.sh.

4. Set Execute Permissions:
   Open a terminal, navigate to your script’s directory, and run: chmod +x myscript.sh.

5. Run Your Script:
   In the terminal, execute the script by typing: ./myscript.sh [arg1].
   Note: This script expects an integer as a command-line argument, provide it as such:

./myscript.sh [integer]

That’s it! You’re ready to execute Bash scripts.

Bash Sample Script

Below, we present a sample Bash script designed to showcase a range of Bash scripting techniques. This example should also provide insight into scripting best practices and how various commands can be used together. Refer to this segment to understand more about how the commands and concepts previously discussed are applied in actual coding scenarios.

#!/bin/bash
# The above line is called a shebang. It tells the system this script should
# be executed using Bash, the Bourne Again SHell, regardless of which shell 
# the user might be using. It specifies the path to the Bash interpreter.

# Variable assignment
name="World"
echo "Hello, $name"
# Output: Hello, World

# Command-line Parameters
number=$1

if [ $number -eq 10 ]; then # Compare the parameter to 10
    echo "Your number is equal to 10."
elif [ $number -lt 10 ]; then
    echo "Your number is less than 10."
else
    echo "Your number is greater than 10."
fi
# Output will depend on number used when calling the script
# If the number "5" was passed, output would be:
# Your number is less than 10.

# printf for formatted output
name="Alice"
age=30
printf "Name: %s, Age: %d\n" "$name" "$age"
# Output: Name: Alice, Age: 30

# Environment Variables
echo "Your home directory is: $HOME"
# Outputs the path to the user's home directory

# Setting a new environment variable
export MY_VAR="Hello World"
echo $MY_VAR
# Outputs: Hello World

# Using an environment variable in a command
mkdir "$MY_VAR"
# Creates a new directory named "Hello World"

# String Concatenation
str1="Hello"
str2="World"
concatenatedStr="$str1, $str2!"
echo "Concatenated string: $concatenatedStr"
# Output: Concatenated string: Hello, World!

# String Length
str="Hello World"
length=${#str}
echo "Length of '$str': $length"
# Output: Length of 'Hello World': 11

# Substring Extraction
# Extracting 'World' from 'Hello World'
extractedStr=${str:6:5}
echo "Extracted substring: $extractedStr"
# Output: Extracted substring: World

# Case Conversion
# Converting to uppercase
upperStr=${str^^}
echo "Uppercase conversion: $upperStr"
# Output: Uppercase conversion: HELLO WORLD

# Replace in String
# Replacing 'World' with 'Bash'
replacedStr=${str/World/Bash}
echo "Replaced String: $replacedStr"
# Output: Replaced String: Hello Bash

# Split string based on delimiter (space in this example)
string="one two three"
IFS=' ' read -r -a str_array <<< "$string"
echo "First element after split: ${str_array[0]}" # Outputs "First element after split: one"

# Array usage
fruits=("apple" "banana" "cherry")
echo "First fruit: ${fruits[0]}" # Output: First fruit: apple

# Associative array
declare -A capitals
capitals["France"]="Paris"
capitals["Germany"]="Berlin"
echo "The capital of France is: ${capitals[France]}" # Output: The capital of France is: Paris

# Reading a file line by line
while IFS= read -r line; do
  echo "Line: $line"
done < myfile.txt # Output: Lines from myfile.txt

# Check if a file exists
file="myfile.txt"
if [ -f "$file" ]; then
  echo "$file exists."
else
  echo "$file does not exist."
fi # Output depends on if myfile.txt exists

# Sorting lines of text in a file alphabetically
echo -e "banana\napple\nfig" > fruits.txt
sort fruits.txt
# This will output:
# apple
# banana
# fig

# Numerical sort with -n flag
echo -e "10\n2\n1" > numbers.txt
sort -n numbers.txt
# This will output:
# 1
# 2
# 10

# Using Here Document to create a configuration file
cat << EOF > myconfig.conf
# My Application Configuration File
HOST=localhost
PORT=8080
EOF

echo "Configuration file created with the following content:"
cat myconfig.conf

# Text color and formatting w/ ANSI escape codes
echo -e "\e[31mThis text is red\e[0m" # Red text
echo -e "\e[1;34mThis text is bold and blue\e[0m" # Bold and blue text

current_date=$(date)
echo "Current date and time: $current_date"

# Show date and time one week later
date_one_week_later=$(date -d "$current_date + 1 week") # '-d' flag used for date manipulation, allowing for manipulation like "1 week" to be performed"
echo "Date and time one week later: $date_one_week_later"

# Conditional statement
if [ "$name" = "World" ]; then
  echo "The condition is true."
else
  echo "The condition is false."
fi 
# Output: The condition is true.

# Case statement
color="red"
case $color in
  red)
    echo "Red color selected."
    ;;
  blue)
    echo "Blue color selected."
    ;;
  *)
    echo "Unknown color."
    ;;
esac # Output: Red color selected.

# For Loop
for i in {1..3}; do
  echo "Loop iteration: $i"
done 
# Output: Loop iteration: 1 (then 2, then 3)

# While loop
count=3
while [ $count -gt 0 ]; do
  echo "Countdown: $count"
  ((count--))
done 
# Output: Countdown: 3 (then 2, then 1)

# Using Break and Continue in Loops
for i in {1..5}; do # Loop through numbers 1 to 5
  if [ "$i" -eq 3 ]; then
    echo "Skipping number $i"
    continue # Skip the rest of the loop at 3 and continue with the next iteration
  fi
  if [ "$i" -eq 4 ]; then
    echo "Stopping at number $i"
    break # Exit the loop at number 4
  fi
  echo "Number $i" # Will output "Number 1" then "Number 2"
done

# Use of parameters ($@)
echo "Script parameters: $@"
# When running: ./script.sh param1 param2
# Output: Script parameters: param1 param2

# Assignment Operators and Arithmetic
a=10
b=0
echo "Initial value of a: $a" # 10

# Assignment
a=$b
echo "Assigned value of b to a: $a" # Value of b

# Addition assignment
((a+=5))
echo "After addition assignment: $a" # 5

# Subtraction assignment
((a-=3))
echo "After subtraction assignment: $a" # 2

# Multiplication assignment
((a*=2))
echo "After multiplication assignment: $a" # 4

# Logical Operators
a=true
b=false

# Logical AND
if [[ $a && $b ]]; then
    echo "Both are true."
else
    echo "a AND b is false."
fi # a AND b is false.

# Logical OR
if [[ $a || $b ]]; then
    echo "At least one is true."
else
    echo "Both are false."
fi # At least one is true.

# Logical NOT
if [[ ! $b ]]; then
    echo "b is not true."
else
    echo "b is true."
fi # b is not true.

# Relational Operators
a=10
b=20

if [ $a -eq $b ]; then
    echo "a is equal to b."
elif [ $a -ne $b ]; then
    echo "a is not equal to b." # This will be executed
fi

if [ $a -lt $b ]; then
    echo "a is less than b." # This will be executed
elif [ $a -gt $b ]; then
    echo "a is greater than b."
fi

if [ $a -le $b ]; then
    echo "a is less than or equal to b." # This will be executed
elif [ $a -ge $b ]; then
    echo "a is greater than or equal to b."
fi

# Simple Regex Matching in Conditional
if [[ "Hello World!" =~ ^Hello ]]; then # Checks if the string starts with "Hello"
  echo "Pattern found in string" # This will be the output
else
  echo "Pattern not found in string"
fi

# Extracting Parts of String Using Regex
versionString="Version: 5.0.17"
if [[ $versionString =~ Version:\ ([0-9]+)\.([0-9]+)\.([0-9]+) ]]; then
  majorVersion=${BASH_REMATCH[1]}
  minorVersion=${BASH_REMATCH[2]}
  patchVersion=${BASH_REMATCH[3]}
  echo "Major: $majorVersion, Minor: $minorVersion, Patch: $patchVersion" # Major: 5, Minor: 0, Patch: 17
fi

# Pattern Matching with Globbing
files=(*.sh)
echo "Shell script files: ${files[@]}" # Lists .sh files in the current directory

# Using Extended Globbing
shopt -s extglob # Enable extended globbing
files=(!(*.sh))
echo "Non-shell script files: ${files[@]}" # Lists files not ending with .sh
shopt -u extglob # Disable extended globbing

# Flags and Modifier Flags
# Use 'set -e' to exit the script when any command fails
set -e
echo "Set -e: Exit on first error. Next command will fail, exiting the script early."
cat nonexistentfile.txt
# Use 'set +e' to disable exit on first error
set +e

# Use 'set -u' to treat unset variables as an error
set -u
echo "Set -u: Treating unset variables as an error."
echo $UNSET_VARIABLE
# Use 'set +u' to disable treating unset variables as an error
set +u

# Redirecting stderr to stdout and filtering through grep
ls valid_file.txt non_existent_file.txt 2>&1 | grep "No such file" || echo "One or more files do not exist."

# Using the -f flag with grep to read patterns from a file
echo "Error" > patterns.txt
grep -f patterns.txt log.txt || echo "Pattern not found in log.txt."

# Command chaining with logical AND (&&) and OR (||)
mkdir temp_directory && echo "Directory created successfully." || echo "Failed to create directory."

# Redirecting command output to a file while checking for command success
cp source.txt destination.txt && echo "Copy successful." > operation_status.txt || echo "Copy failed." > operation_status.txt

# Using the exec command with redirection to globally redirect script output
exec 3>&1 4>&2 # Saving file descriptors
exec 1>log_all_output.txt 2>&1 # Redirecting all output to log file
echo "This output will be logged in the file."
exec 1>&3 2>&4 # Restoring file descriptors

# Function definition and call
greet() {
  local person="$1" # Local variable
  echo "Hello, $person"
}
greet "Alice" # Output: Hello, Alice

# A function to display basic system information and store it into a log file
system_info() {
  echo "System Information Report:"

  # Display current date and time
  echo "Current Date and Time: $(date)"

  # Show system uptime
  echo "System Uptime: $(uptime -p)"

  # Disk space usage
  echo "Disk Space Usage:"
  df -h | grep "^/dev" # Shows disk space usage for devices starting with /dev

  # Memory usage
  echo "Memory Usage:"
  free -h # Display human-readable memory usage
}

# Calling the system_info function and redirecting output to a file with a timestamp
system_info | tee "system_info_$(date "+%Y-%m-%d_%H-%M-%S").txt"

# File and Directory Manipulation
# Define directory and file names
dirName="exampleDir"
fileName="exampleFile.txt"

# Create a new directory
mkdir $dirName

# Navigate into the directory
cd $dirName

# Create a new file and write to it
echo "This is a sample text." > $fileName

# Display the content of the file
echo "Contents of $fileName:"
cat $fileName

# Navigate back to the original directory
cd ..

# Clean up: Remove the directory and its contents
rm -r $dirName

# Error Handling and Conditional Execution
# Attempt to read from a non-existent file and check exit status
cat non_existent_file.txt
if [ $? -ne 0 ]; then
  echo "Failed to read file." # This message is shown if the file doesn't exist.
fi

# Using conditional execution to echo "Error" if a command fails
ls non_existent_directory || echo "Error: Directory does not exist."

# Using && for success execution
echo "Checking for /tmp directory existence..." && ls /tmp || echo "Error: /tmp directory does not exist."

# Explicitly setting an exit status
false
if [ $? -eq 0 ]; then
  echo "Command succeeded."
else
  echo "Command failed."
fi

The example code provided above showcased a variety of Bash scripting techniques, from basic command execution to more complex structures like loops and conditionals. Remember, the reference section is there to support you; use it to revisit any concepts covered in the script or to clarify details as you experiment with Bash on your own!

Conclusion

In this article, we’ve equipped you with a handy Bash command reference and demonstrated these concepts through a practical code example. It’s our hope that these tools will bolster your Bash scripting journey, enhancing both your understanding and efficiency. As you move forward, we wish you the best of luck with your future Bash endeavors. Happy scripting!