Bash Commands Cheat Sheet: Essential Reference

Bash is the default shell on most Linux distributions and macOS, and the runtime behind CI pipelines, deployment scripts, and developer automation. This bash commands cheat sheet groups the most-used commands by category — navigation, file operations, text processing, I/O redirection, process management, and scripting syntax — so you can jump straight to the section you need without filtering through man pages.

Essential Bash Commands by Category

A quick-lookup overview of the command groups covered in this reference:

Navigation and Directory Commands

The bash commands you run dozens of times a day:

For a wider reference covering the Linux filesystem hierarchy and system administration utilities, the Linux Commands Cheat Sheet covers broader territory including package management, disk usage, and service control.

File Operations

Copying, Moving, and Removing

Viewing File Contents

Bash Variables and Parameter Expansion

Bash variables are set without spaces around = and read with $. Single quotes prevent expansion; double quotes allow it:

name="Alice"
count=0
readonly CONFIG_DIR="/etc/myapp"

echo "$name"                    # Alice
echo "Hello, ${name}!"         # Hello, Alice!
echo "${name:-default}"        # use "default" if $name is unset or empty
echo "${name:0:3}"             # substring: first 3 chars → Ali
echo "${name^^}"               # uppercase → ALICE
echo "${#name}"                # string length → 5
echo "${name/Alice/Bob}"       # replace first match → Bob

 # Command substitution
today=$(date +%Y-%m-%d)
file_count=$(ls | wc -l)

 # Arithmetic
((count++))
result=$((count * 10 + 5))
echo "$result"

 # Arrays
servers=("web01" "web02" "db01")
echo "${servers[0]}"           # web01
echo "${servers[@]}"           # all elements
echo "${#servers[@]}"          # array length

Special variables Bash always provides:

Text Search and Processing

grep — Search Files and Streams

Use the regex tester to validate patterns interactively before embedding them in scripts or grep commands.

sed — Stream Editor

sed edits text streams line by line. The most common use is substitution:

awk — Column and Record Processing

awk processes structured text (CSV, log fields, whitespace-delimited output) by splitting each line into fields:

I/O Redirection and Pipelines

Bash connects commands using stdin (0), stdout (1), and stderr (2):

Practical pipeline patterns:

 # Discard errors entirely
ls /nonexistent 2>/dev/null

 # Capture stdout and stderr together
output=$(command 2>&1)

 # Analyze the 20 most-requested 404 URLs in an nginx access log
cat access.log \
  | grep " 404 " \
  | awk '{print $7}' \
  | sort \
  | uniq -c \
  | sort -rn \
  | head -20

 # Write to a file and see it at the same time
make 2>&1 | tee build.log

 # Process substitution: use command output as a file argument
diff <(sort file1.txt) <(sort file2.txt)

 # Here-string: pass a string as stdin
base64 <<< "hello world"

Process and Job Management

When running long-lived processes over SSH, pair these commands with a terminal multiplexer. The tmux Cheat Sheet covers session, window, and pane management so processes survive disconnections.

Bash Scripting Quick Reference

Conditionals

#!/usr/bin/env bash

log_file="/var/log/app.log"

 # File tests
if [[ -f "$log_file" ]]; then
    echo "Log file exists"
elif [[ -d "/var/log" ]]; then
    echo "Directory exists but no log file yet"
else
    echo "Neither exists"
fi

 # Common file test flags
 # -f  regular file exists
 # -d  directory exists
 # -e  path exists (file or directory)
 # -r  readable    -w  writable    -x  executable
 # -s  non-empty file
 # -L  symbolic link

 # String comparison
env="${DEPLOY_ENV:-development}"
if [[ "$env" == "production" ]]; then
    echo "Production mode — extra caution"
fi

 # Numeric comparison (use (()) for arithmetic)
file_count=$(ls | wc -l)
if (( file_count > 100 )); then
    echo "More than 100 files in current directory"
fi

 # Case statement
case "$1" in
    start)   systemctl start myapp ;;
    stop)    systemctl stop myapp ;;
    restart) systemctl restart myapp ;;
    *)       echo "Usage: $0 {start|stop|restart}" ;;
esac

Loops

 # For loop over a list
for service in nginx postgresql redis; do
    if systemctl is-active --quiet "$service"; then
        echo "$service is running"
    else
        echo "$service is STOPPED"
    fi
done

 # Glob expansion — iterate over files
for log in /var/log/*.log; do
    size=$(wc -l < "$log")
    echo "$log: $size lines"
done

 # C-style for loop
for (( i=1; i<=5; i++ )); do
    echo "Step $i of 5"
done

 # While loop reading a file line by line
while IFS= read -r line; do
    echo "Processing: $line"
done < input.txt

 # Until loop (opposite of while — loops until condition is TRUE)
count=0
until [[ $count -ge 5 ]]; do
    echo "count=$count"
    ((count++))
done

Functions

 # Define with the function keyword or bare name()
check_service() {
    local service_name="$1"          # always use local for function vars
    if systemctl is-active --quiet "$service_name"; then
        echo "$service_name is running"
        return 0
    else
        echo "$service_name is NOT running" >&2
        return 1
    fi
}

 # Call with arguments
check_service nginx
check_service postgresql || echo "postgresql down — alerting on-call"

 # Return values via stdout (command substitution)
get_version() {
    local app="$1"
    "$app" --version 2>&1 | head -1
}
version=$(get_version node)
echo "Node version: $version"

Error Handling

set -euo pipefail
 # -e   exit immediately on any error
 # -u   treat unset variables as errors
 # -o pipefail   pipe fails if any command in it fails

 # Trap errors and cleanup
trap 'echo "Error on line $LINENO — exiting" >&2' ERR
trap 'rm -f "/tmp/scratch_$$"' EXIT

 # Conditional execution
command1 && command2   # run command2 only if command1 succeeds
command1 || command2   # run command2 only if command1 fails

Bash History and Keyboard Shortcuts

History Commands

Essential Keyboard Shortcuts

Networking Commands

For a thorough walkthrough of curl — including request headers, authentication schemes, and JSON payloads — see the curl Command Guide. When deploying from scripts, the Git Commands Cheat Sheet covers the repository operations you’ll need alongside push and pull automation. The Docker Commands Cheat Sheet pairs well for containerized deployment workflows.

The GNU Bash Manual is the authoritative reference for every built-in and shell option. The Linux man page for bash documents every flag, expansion rule, and built-in command in full detail.

Frequently Asked Questions

What is the difference between bash and sh?

sh is the POSIX shell standard — a minimal specification for shell behavior including basic conditionals, loops, and parameter expansion. bash (Bourne Again SHell) is a strict superset of sh that adds arrays, arithmetic expansion with $((...)), [[ ... ]] extended conditionals, process substitution with <(...), readline editing, and a richer history system.

On most modern Linux systems, /bin/sh is a symlink to dash or another minimal POSIX shell — not bash. Scripts with #!/bin/sh run in POSIX mode and will fail if they use bash-specific syntax like [[ ]] or arrays. Use #!/usr/bin/env bash when your script needs bash features, and #!/bin/sh only when strict POSIX portability matters (e.g., inside BusyBox or Alpine Linux containers where bash is not installed).

How do I find a file by name in bash?

Use the find command with the -name flag:

find /home -name "*.log" -type f            # all .log files under /home
find . -name "config.json" -maxdepth 3      # search up to 3 levels deep
find /tmp -mmin -30 -type f                 # files modified in the last 30 minutes
find . -name "*.pyc" -delete                # find and delete all .pyc files
find /var/log -size +100M -type f           # files larger than 100 MB

For searching text content within files, use grep -r "pattern" . instead. Combine both to locate files by name and then filter by content:

find . -name "*.conf" -exec grep -l "timeout" {} \;

How do I check which process is using a specific port?

Run one of these commands — they need sudo for processes owned by other users:

lsof -i :8080           # process name, PID, user — most readable
ss -tlnp | grep :8080   # faster; built into modern Linux kernels
netstat -tlnp | grep :8080  # classic; requires the net-tools package
fuser 8080/tcp          # returns just the PID

lsof -i :8080 is the most readable on a single server. On high-traffic servers or in scripts, ss is faster because it queries the kernel directly without the overhead of scanning /proc.

Conclusion

These bash commands cover the full daily workflow: navigating filesystems, reading and transforming text with grep, sed, and awk, managing background jobs, and writing scripts that handle errors cleanly with set -euo pipefail and traps. The scripting section is worth revisiting any time a sequence of bash commands grows beyond a one-liner — the discipline of local variables, explicit error handling, and meaningful exit codes pays back quickly in debugging time.

For terminal session management across long-running tasks, the tmux Cheat Sheet is the natural companion reference. For a broader coverage of Linux system administration commands including disk management, user control, and service configuration, the Linux Commands Cheat Sheet goes deeper on system-level utilities.