Bash Cheat Sheet

Navigation

File Commands

Networking

Not bash itself, but the commands every bash cheat sheet gets used for on a server.

Jobs and Processes

If exit answers "There are stopped jobs", run jobs to see them, then fg to finish each one or kill %1 to drop it. A second exit leaves anyway and kills them.

Variables

No spaces around the equals sign, and quote expansions unless you want word splitting.

If and Test Operators

Use [[ ]] in bash: it is safer with unquoted variables than [ ] and adds glob and regex matching.

if [[ -f "$conf" ]]; then
  echo "found"
elif [[ -d /etc/nginx ]]; then
  echo "directory only"
else
  echo "missing"
fi

Combine with && and || inside [[ ]], negate with !.

Case Statements

Cleaner than a stack of elif when one value has several possible shapes.

case "$1" in
  start)          systemctl start app ;;
  stop)           systemctl stop app ;;
  restart|reload) systemctl restart app ;;   # | separates alternatives
  *.log)          echo "that is a log file" ;;
  "")             echo "no argument given" ;;
  *)              echo "usage: $0 {start|stop|restart}" >&2; exit 2 ;;
esac

• The patterns are globs, not regex, and the first match wins, so *) goes last as the catch-all.
• ;; ends a branch. ;& falls straight into the next branch, ;;& carries on testing the remaining patterns (bash 4+).
• shopt -s nocasematch makes the matching case-insensitive.

Loops

for f in *.log; do            # every .log file here
  echo "$f"
done

for i in {1..5}; do           # brace range: 1 2 3 4 5
  echo "$i"
done

for ((i = 0; i < 3; i++)); do  # C-style counter
  echo "$i"
done

while read -r line; do        # a file, one line at a time
  echo "$line"
done < servers.txt

until ssh -q web1 true; do    # retry until it succeeds
  sleep 5
done

break leaves the loop, continue skips to the next round.

Arrays

Indexed from 0, and "${arr[@]}" must be quoted or elements with spaces split apart.

arr=(one two three)
arr+=(four)              # append
echo "${arr[0]}"         # first element
echo "${arr[-1]}"        # last element
echo "${arr[@]}"         # all elements
echo "${#arr[@]}"        # how many
unset 'arr[1]'           # remove one (indexes keep their gaps)

for item in "${arr[@]}"; do
  echo "$item"
done

declare -A port=([http]=80 [ssh]=22)   # associative array, bash 4+
echo "${port[ssh]}"
for key in "${!port[@]}"; do
  echo "$key -> ${port[$key]}"
done

Parameter Expansion

String surgery without spawning sed. The keyboard is the mnemonic for the confusing pair: # sits left of $ and cuts from the front, % sits right of it and cuts from the back. One symbol takes the shortest match, doubled takes the longest. The patterns are globs, not regex.

Arithmetic

Integers only. Bash cannot do decimals on its own.

$(( )) is arithmetic, $( ) runs a command. A stray space between the parentheses changes which one you get.

Globbing

Bash expands these before the command ever runs, so rm *.log is the shell handing rm a list of names.

Quote the pattern when the command should do its own matching: find . -name "*.log" and rsync --exclude '*.tmp' both want the pattern intact, not a list of files the shell already expanded.

Redirection and Pipes

Multi-line input goes through a heredoc; quote the delimiter (<<'EOF') to stop expansion inside it.

cat > /etc/motd <<EOF
Welcome to $(hostname)
EOF

Command Substitution

$( ) nests cleanly, as in $(basename "$(pwd)"). Backticks do the same job but are the legacy form.

Reading Input

Always pass -r, or read eats backslashes in the input.

A yes/no prompt, defaulting to no:

read -rp "Deploy to production? [y/N] " ans
[[ "$ans" == [yY]* ]] || exit 0

Prompting inside a while read ... done < file loop does not work: the loop already owns stdin, so the prompt reads the next line of the file. Add < /dev/tty to the inner read.

Keyboard Shortcuts

Bash line editing is readline; these work in any readline program, psql and python included.

Vi Mode

The table above is emacs mode, the bash default. set -o vi swaps it for vi keys; put it in ~/.bashrc, or set editing-mode vi in ~/.inputrc to change every readline program at once. You start in insert mode, so press Esc first.

Ctrl+R and Ctrl+C still work from insert mode, so history search does not go away.

History

Worth setting in ~/.bashrc:

export HISTSIZE=10000
export HISTFILESIZE=20000
export HISTTIMEFORMAT='%F %T '
export HISTCONTROL=ignoredups:ignorespace  # skip duplicates; a leading space hides a command

Startup Files

• A login shell does not read ~/.bashrc. That is why most ~/.bash_profile files contain [[ -f ~/.bashrc ]] && . ~/.bashrc, and why a PATH you set in one file is missing in the other.
• These files are sourced, not executed, so they need no chmod +x and no shebang.
• ssh host 'command' starts a non-interactive shell. Bash does read ~/.bashrc there, but most distro copies open with a line that returns early when the shell is not interactive, so anything below it never applies to remote commands.
• A prompt that redraws over itself usually means unescaped colour codes in PS1. Wrap every escape sequence in \[ and \] so bash does not count it towards the line width.

Exit Codes

Codes worth recognising: 126 found but not executable, 127 command not found, 130 killed with Ctrl+C, and 128+N killed by signal N.

Regex

[[ =~ ]] matches POSIX extended regex; capture groups land in BASH_REMATCH.

re='^([0-9]+)\.([0-9]+)'
if [[ $version =~ $re ]]; then
  major="${BASH_REMATCH[1]}"
  minor="${BASH_REMATCH[2]}"
fi

• Keep the pattern in a variable and unquoted after =~; quoting it makes bash match the text literally.
• POSIX extended regex has no \d, \w or \s. Write [0-9], [[:alnum:]] and [[:space:]] instead.
• BASH_REMATCH is overwritten by the next =~, so copy what you need straight away.
• case statements and [[ == ]] use globs (*, ?, [a-z]), not regex.
• To match inside files use grep; to edit with a pattern use sed.

Functions

deploy() {
  local target="$1"
  if [[ -z "$target" ]]; then
    echo "usage: deploy <host>" >&2
    return 2
  fi
  rsync -az ./site/ "$target:/var/www/"
}

deploy web1

• local keeps a variable inside the function; without it, everything leaks into the script.
• return only sets an exit code (0 to 255). To hand back data, echo it and capture with out=$(deploy web1).
• Define a function before its first call; bash reads top to bottom.

Running Scripts

"command not found" for a script sitting right in front of you is the missing ./. The current directory is not on PATH, so bash never looks there.

Script Arguments

Flag parsing with the getopts builtin:

while getopts "f:v" opt; do
  case "$opt" in
    f) file="$OPTARG" ;;
    v) verbose=1 ;;
    *) echo "usage: $0 [-v] [-f file]" >&2; exit 2 ;;
  esac
done
shift $((OPTIND - 1))   # what remains is in "$@"

Windows Equivalents

For moving between a Linux box and a Windows one. Windows PowerShell 5.1 aliases the short names (ls, cp, cat); PowerShell 7 on Linux and macOS drops those aliases so the real commands still work.

Bash itself runs on Windows through WSL or Git Bash, which is usually easier than translating a script.

Gotchas

• name = value is not an assignment; it runs a command called name. No spaces around =.
• An unquoted $var splits on spaces and expands globs. Quote every expansion: "$var", "${arr[@]}", "$@".
• sh script.sh is not bash on Debian and Ubuntu; /bin/sh is dash there, and [[, arrays, and {1..5} all fail. Use a #!/usr/bin/env bash shebang and run with bash.
• macOS ships bash 3.2 from 2007, so declare -A, ${var^^}, and mapfile fail on a Mac. The macOS default shell is zsh now; a current bash comes from Homebrew.
• cat file | while read runs the loop in a subshell, so variables set inside it vanish afterwards. Feed the loop with done < file instead.
• rm -rf "$dir/"* with an unset $dir expands to /*. set -u at the top turns that typo into an error instead of a disaster.