Bash cheat sheet

Bash is the command language that runs in most Linux and macOS terminals, and the usual way to automate a job you would otherwise type by hand. The reference below is grouped by what you are trying to do, and the filter box searches all of it at once. Type array to see everything about arrays, or macos to see what the Mac's built-in Bash cannot do.

Every snippet is checked against Bash 5.3, the current release, and was run on 5.3.9. Anything that needs more than Bash 3.2, the version still at /bin/bash on every Mac, says so in the notes column. This page is the language itself. Tools such as grep, find and sed appear only as things to pipe into; the Linux commands cheat sheet covers them.

A script template worth copying

Most scripts want the same bones: strict mode, a usage message, flags, a check on the arguments and a temporary folder that is always cleaned up. This one archives a folder into a dated .tar.gz.

#!/usr/bin/env bash
# backup.sh: archive a folder into a dated .tar.gz
set -euo pipefail
 
usage() {
  echo "Usage: ${0##*/} [-v] [-o OUT_DIR] SOURCE_DIR" >&2
  exit 2
}
 
verbose=0
out_dir="."
while getopts "vo:h" opt; do
  case $opt in
    v) verbose=1 ;;
    o) out_dir=$OPTARG ;;
    *) usage ;;
  esac
done
shift $((OPTIND - 1))
(( $# == 1 )) || usage
 
source_dir=${1%/}
[[ -d $source_dir ]] || { echo "error: $source_dir is not a folder" >&2; exit 1; }
 
log() {
  if (( verbose )); then echo "$*" >&2; fi
}
 
tmp=$(mktemp -d)
trap 'rm -rf "$tmp"' EXIT
 
name=${source_dir##*/}
archive="$name-$(date +%Y-%m-%d).tar.gz"
log "Archiving $source_dir"
 
tar -czf "$tmp/$archive" -C "$(dirname "$source_dir")" "$name"
mv "$tmp/$archive" "$out_dir/"
echo "$out_dir/$archive"

$ ./backup.sh -v -o /tmp photos
Archiving photos
/tmp/photos-2026-09-26.tar.gz
 
$ ./backup.sh
Usage: backup.sh [-v] [-o OUT_DIR] SOURCE_DIR

getopts handles -v -o /tmp, -vo /tmp and -o/tmp alike, and shift $((OPTIND - 1)) drops the flags so $1 is the first real argument. Messages go to stderr with >&2, so the only thing on stdout is the path of the archive, which lets another script capture it with $(./backup.sh photos). The trap removes the temporary folder whether the script finishes, fails partway or is stopped with Ctrl+C. Nothing in it needs more than Bash 3.2, so it runs unchanged on a Mac.

Quoting in one table

Most Bash bugs are quoting bugs. With name="Ada Lovelace":

The rule that covers it: put double quotes around every $variable and every $(command), unless you have a reason not to. "${files[@]}" is the one form that keeps every array item whole.

Single vs double brackets

Here documents in full

The heredoc rows above show only the first line. Here is each form whole:

name="Ada"
 
# Variables and $( ) expand
cat <<EOF
Hello, $name. It is $(date +%A).
EOF
 
# Quoted word: nothing expands, useful for writing out code
cat > greet.sh <<'EOF'
#!/usr/bin/env bash
echo "Hello, $1"
EOF
 
# <<- strips leading tabs, so the body can follow the indentation
if true; then
	cat <<-EOF
	indented with tabs in the file, printed with none
	EOF
fi
 
# Into a variable
config=$(cat <<EOF
user=$name
debug=false
EOF
)

The end word has to be alone on its line with nothing after it, not even a space. <<- strips tab characters only; an editor that turns tabs into spaces breaks it, which is why many people avoid it and keep heredoc bodies unindented.

Renaming and processing files safely

Two loops that come up constantly, written so a file name with spaces, or starting with a dash, cannot break them.

# Rename every .jpeg to .jpg
for f in *.jpeg; do
  [[ -e $f ]] || continue          # no .jpeg files: skip the literal *.jpeg
  mv -n -- "$f" "${f%.jpeg}.jpg"   # -n: never overwrite, --: end of options
done
 
# Read a CSV, skipping the header, and handle a last line with no newline
while IFS=, read -r name email plan || [[ -n $name ]]; do
  [[ $name == name ]] && continue
  printf '%-10s %s\n' "$name" "$plan"
done < users.csv

A plain comma split like this does not handle quoted fields that contain commas. For real CSV, use a tool that parses it properly, such as Python's csv module from the Python cheat sheet, or load it into SQLite and query it with the SQL cheat sheet.

Pipes are where Bash does most of its real work, one small tool feeding the next. This counts the ten most common lines in a log:

sort access.log | uniq -c | sort -rn | head -n 10

GNU sort, the one on Linux, uses a merge sort, and spills sorted runs to temporary files and merges them when the input does not fit in memory. That is how it sorts files far larger than RAM.

The Linux commands cheat sheet has more pipelines like this one, and the options for each tool in them.

Where set -euo pipefail falls short

Strict mode is worth having, but it has holes that catch everyone once. Each row here was run under set -euo pipefail on Bash 5.3.

Bash on macOS

macOS has used zsh as the default login shell since Catalina (10.15). /bin/bash is still there, frozen at 3.2.57, a patch release of the Bash 3.2 that came out in 2006, because newer Bash is licensed under GPLv3. Everything on this page without a version note works on it. These do not:

Two ways to live with it. Install a current Bash with brew install bash and start scripts with #!/usr/bin/env bash, which finds it on your PATH. Or, for a script other people will run on their Macs, stick to what 3.2 supports. zsh runs most simple Bash one-liners unchanged but differs in the details, such as arrays starting at 1, so run Bash scripts with Bash rather than pasting them into zsh.

Gotchas

The mistakes almost everyone makes in their first month of Bash.

For containers, the Docker cheat sheet explains why CMD in shell form makes the shell PID 1. The usual Bash entrypoint script ends in exec "$@", which replaces the shell with the real command so it receives signals directly. For the Git side of a script, such as a hook that runs before every commit, the Git cheat sheet has the commands to call.

Common questions