Bash Essentials on fffelipe's world wide web

Variables

Mon, 01 Jan 0001 00:00:00 +0000

name="Felipe"
count=42
echo "$name has $count items"

# readonly
readonly API_URL="https://api.example.com"

# default if unset
port="${PORT:-8080}"

Always quote "$var" to handle spaces and special chars. The ${VAR:-default} pattern is essential for env-driven scripts.

Prompt

Mon, 01 Jan 0001 00:00:00 +0000

Prompts often show helpful context like username, machine name, current directory, or Git branch.

Real-world example: a prompt ending in $ usually means a normal user shell, while # often means a root/admin shell where mistakes can be more dangerous.

Quoting

Mon, 01 Jan 0001 00:00:00 +0000

name="Felipe"
echo '$name' # → $name
echo "$name" # → Felipe
echo "Hi, $name!" # → Hi, Felipe!

# command substitution needs double quotes
today="$(date +%Y-%m-%d)"
echo "Today is $today"

Default to double quotes around variables. Use single quotes when you literally want $ in the output (regex patterns, awk scripts).

echo & printf

Mon, 01 Jan 0001 00:00:00 +0000

echo "Hello, world"
echo -n "no newline"

printf "%s is %d years old\n" "$name" "$age"
printf "%.2f\n" 3.14159 # → 3.14
printf "[%-10s]\n" "left" # → [left ]

Prefer printf in scripts; echo’s behavior with flags varies between systems. printf is portable and POSIX-standard.

pwd

Mon, 01 Jan 0001 00:00:00 +0000

The current working directory is where relative paths start from.

Real-world example: before running a destructive command, use pwd to confirm you are in the folder you think you are in.

cd

Mon, 01 Jan 0001 00:00:00 +0000

Examples:

cd projects
cd ..
cd ~
cd -

.. means parent directory, ~ means your home directory, and cd - jumps back to the previous directory.

Command Substitution

Mon, 01 Jan 0001 00:00:00 +0000

today="$(date +%Y-%m-%d)"
branch="$(git rev-parse --abbrev-ref HEAD)"
count="$(ls *.txt | wc -l)"

echo "Backup-${today}-${branch}.tar.gz"

Always use $(...) not backticks; it nests cleanly and is easier to read in any non-trivial expression.

Exit Codes

Mon, 01 Jan 0001 00:00:00 +0000

ls /tmp
echo "Exit code: $?" # 0

ls /no/such/path
echo "Exit code: $?" # 2

# use directly in conditions
if grep -q "ERROR" log.txt; then
 echo "found errors"
fi

Don’t check $? after the command; use the command directly in if. && chains success, || chains failure: cmd1 && cmd2 || echo "failed".

ls

Mon, 01 Jan 0001 00:00:00 +0000

Useful options:

ls -la
ls -lh

-a includes hidden files, -l shows details, and -h makes file sizes human-readable.

Real-world example: ls -la helps you see config files like .gitignore, .env, or .bashrc.

Shebang & Permissions

Mon, 01 Jan 0001 00:00:00 +0000

#!/usr/bin/env bash
# script.sh
echo "Hello from $(basename "$0")"

# make it runnable
chmod +x script.sh
./script.sh

Use #!/usr/bin/env bash (not /bin/bash): it finds bash via PATH, which works across Linux distros and macOS. chmod +x once, then run with ./.

if / else

Mon, 01 Jan 0001 00:00:00 +0000

if [[ -f "$file" ]]; then
 echo "exists"
elif [[ -d "$file" ]]; then
 echo "is a directory"
else
 echo "not found"
fi

# string compare
if [[ "$env" == "prod" ]]; then ...; fi

# number compare
if (( count > 10 )); then ...; fi

Use [[ ]] for strings/files (modern bash) and (( )) for arithmetic. Avoid the older single-bracket [ ]; it has subtle quoting issues.

cat and less

Mon, 01 Jan 0001 00:00:00 +0000

Use cat for short files and less for longer files.

Examples:

cat README.md
less server.log

Real-world example: use less to inspect logs without flooding your terminal. Press / to search and q to quit.

for loops

Mon, 01 Jan 0001 00:00:00 +0000

# over a list
for env in dev staging prod; do
 echo "Deploying to $env"
done

# over files
for file in *.log; do
 gzip "$file"
done

# numeric range
for i in {1..5}; do
 echo "Attempt $i"
done

Always quote "$file" in case filenames have spaces. For C-style loops use for ((i=0; i<10; i++)).

touch and mkdir

Mon, 01 Jan 0001 00:00:00 +0000

Examples:

touch notes.txt
mkdir drafts
mkdir -p posts/new-post

mkdir -p creates parent directories as needed and does not error if they already exist.

while loops

Mon, 01 Jan 0001 00:00:00 +0000

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

# poll until something happens
while ! curl -sf http://localhost:8080/health; do
 echo "Waiting for service..."
 sleep 2
done

IFS= read -r is the canonical safe way to read lines; it preserves whitespace and treats backslashes literally.

case

Mon, 01 Jan 0001 00:00:00 +0000

case "$1" in
 start) echo "Starting..." ;;
 stop) echo "Stopping..." ;;
 restart) echo "Restarting..." ;;
 *.log) echo "It's a log file" ;;
 *) echo "Unknown: $1" ;;
esac

Patterns support globs, so *.log matches any .log file. *) is the default catchall; always include it for safety.

cp, mv, and rm

Mon, 01 Jan 0001 00:00:00 +0000

Examples:

cp draft.md backup.md
mv draft.md post.md
rm old.txt

Be careful with rm: it does not send files to the trash; they are gone immediately. Double-check paths before using recursive removal like rm -r.

Redirection

Mon, 01 Jan 0001 00:00:00 +0000

command > out.txt # overwrite
command >> out.txt # append
command < input.txt # read from file

# combined
./build.sh > build.log 2>&1 # stdout + stderr to log
./build.sh &> build.log # shorthand (bash only)

> overwrites with no warning, so be careful. Use >> to append. 2>&1 redirects stderr to wherever stdout is currently going.

Pipes

Mon, 01 Jan 0001 00:00:00 +0000

ps aux | grep python | grep -v grep

cat access.log \
 | awk '{print $7}' \
 | sort | uniq -c \
 | sort -rn | head

git log --oneline | wc -l # commit count

Pipes are how Unix tools compose. Each tool does one thing; chain them to build pipelines that would be pages of code in other languages.

File Tests

Mon, 01 Jan 0001 00:00:00 +0000

[[ -f file ]] # is a regular file
[[ -d dir ]] # is a directory
[[ -e path ]] # exists (any kind)
[[ -r file ]] # readable
[[ -w file ]] # writable
[[ -x file ]] # executable
[[ -s file ]] # not empty
[[ -z "$var" ]] # variable is empty
[[ -n "$var" ]] # variable is non-empty

Always quote variables in tests: [[ -f "$path" ]]. Combine with && / || for compact logic: [[ -f .env ]] && source .env.

stdin / stdout / stderr

Mon, 01 Jan 0001 00:00:00 +0000

# send errors to a file
./build.sh 2> errors.log

# discard noise
find / -name "*.log" 2> /dev/null

# only errors, throw away stdout
./build.sh > /dev/null 2> errors.log

# write to stderr from your script
echo "Warning: file missing" >&2

/dev/null is the bit bucket; anything sent there disappears. Print errors to stderr (>&2) so they show up even when stdout is piped or redirected.

Globs & Wildcards

Mon, 01 Jan 0001 00:00:00 +0000

ls *.py # all .py in cwd
ls **/*.py # recursive (needs shopt -s globstar)
ls report_?.txt # exactly one char
ls log[0-9].txt # one digit

shopt -s nullglob # no match → empty list (safer)

Without nullglob, for f in *.log will iterate once with the literal string *.log if no files match. Set it at the top of any script that loops over globs.

grep

Mon, 01 Jan 0001 00:00:00 +0000

grep "ERROR" app.log
grep -i "warning" *.log # case-insensitive
grep -r "TODO" . # recursive
grep -v "DEBUG" app.log # invert (NOT matching)
grep -c "ERROR" app.log # count
grep -n "ERROR" app.log # show line numbers
grep -E "^(error|warn)" log # extended regex

grep -rn pattern . to search a project with line numbers, your daily driver. If rg (ripgrep) is installed, use it instead: it is much faster and respects .gitignore.

find

Mon, 01 Jan 0001 00:00:00 +0000

find . -name "*.py"
find . -type f -name "*.log"
find . -type d -name "node_modules" -prune
find . -mtime -7 # modified in last 7 days
find . -size +10M # larger than 10MB
find . -name "*.tmp" -delete # find + delete

Test with -print first before adding -delete or -exec rm. The -prune trick excludes whole directories from the search.

Environment variables

Mon, 01 Jan 0001 00:00:00 +0000

Use export to make a variable available to commands you run from the shell.

Example:

export NODE_ENV=production

Real-world example: tools often read configuration from environment variables, such as PATH, HOME, EDITOR, or API keys.

sed

Mon, 01 Jan 0001 00:00:00 +0000

sed 's/foo/bar/' file.txt # first per line
sed 's/foo/bar/g' file.txt # all
sed -i '' 's/foo/bar/g' file # in-place (macOS)
sed -i 's/foo/bar/g' file # in-place (Linux)

sed -n '10,20p' file.txt # print lines 10-20

macOS sed differs from GNU sed; -i needs an empty argument on macOS (-i ''). For anything complex, reach for awk or a real language.

awk

Mon, 01 Jan 0001 00:00:00 +0000

awk '{print $1}' file.txt # first column
awk -F, '{print $2}' file.csv # CSV (comma sep)

# sum column 3
awk '{sum += $3} END {print sum}' data.txt

# filter then print
ps aux | awk '$3 > 1 {print $2, $11}' # PIDs > 1% CPU

When you need to extract or aggregate columns, awk beats grep+sed combinations. $0 is the whole line, $1..$N are fields.

xargs

Mon, 01 Jan 0001 00:00:00 +0000

find . -name "*.tmp" | xargs rm

# safer: handles spaces in filenames
find . -name "*.tmp" -print0 | xargs -0 rm

# one item per call with placeholder
ls *.jpg | xargs -I {} mv {} processed/

# parallel
cat urls.txt | xargs -P 4 -I {} curl -sO {}

Always use -print0 + -0 when filenames might have spaces. -P N runs N commands in parallel, handy for I/O-bound tasks like batch downloads.

jq

Mon, 01 Jan 0001 00:00:00 +0000

curl -s api.example.com/users | jq '.'
curl -s api.example.com/users | jq '.[0].name'
curl -s api.example.com/users | jq '.[] | .email'
curl -s api.example.com/users | jq 'map(select(.active))'

# raw (unquoted) string output
jq -r '.token' response.json

-r removes JSON quoting from string output, which is needed when piping into other commands. jq '.' alone pretty-prints any JSON. Not always pre-installed; brew install jq or apt install jq.

Robust Script Template

Mon, 01 Jan 0001 00:00:00 +0000

#!/usr/bin/env bash
set -euo pipefail

# -e exit on any error
# -u error on undefined variables
# -o pipefail fail if any pipe segment fails

readonly LOG_DIR="${LOG_DIR:-/var/log/myapp}"

main() {
 local input="$1"
 echo "Processing $input"
 # ...
}

main "$@"

set -euo pipefail should be on every script you write. Without -e, a failing command keeps going. Without -u, typos in variable names silently expand to empty strings, a classic source of bugs.

Process Files in a Loop

Mon, 01 Jan 0001 00:00:00 +0000

#!/usr/bin/env bash
set -euo pipefail
shopt -s nullglob

# simple version (one directory)
for file in logs/*.log; do
 gzip "$file"
done

# with find (handles deep trees + weird names)
find logs -type f -name "*.log" -print0 \
 | while IFS= read -r -d '' file; do
 gzip "$file"
 done

Use the simple for loop for files in one directory. Switch to find -print0 when you have nested paths or filenames that might contain spaces, newlines, or quotes.

Args & User Input

Mon, 01 Jan 0001 00:00:00 +0000

#!/usr/bin/env bash
set -euo pipefail

usage() { echo "Usage: $0 [-v] <input>"; exit 1; }

verbose=false
while getopts "v" opt; do
 case "$opt" in
 v) verbose=true ;;
 *) usage ;;
 esac
done
shift $((OPTIND - 1))

[[ $# -lt 1 ]] && usage
input="$1"

$verbose && echo "Processing $input"

getopts handles short flags well. For complex CLIs (long flags, subcommands) consider rewriting in Python with argparse; bash gets unwieldy fast past a few options.

Background Jobs

Mon, 01 Jan 0001 00:00:00 +0000

# run in background
long-task &

# capture PID, wait for it
long-task &
pid=$!
wait "$pid"

# multiple in parallel, wait for all
task1 & task2 & task3 &
wait

# survive logout
nohup long-task > out.log 2>&1 &

# see all background jobs
jobs

& backgrounds; wait blocks until done; nohup detaches from the terminal so the process survives the shell exiting. For anything long-running and important, use a proper supervisor (systemd, launchd, supervisord).

Cron / Scheduled Tasks

Mon, 01 Jan 0001 00:00:00 +0000

# edit your crontab
crontab -e

# format: m h dom mon dow command
0 2 * * * /usr/local/bin/backup.sh
*/15 * * * * /usr/local/bin/healthcheck.sh
0 9 * * 1-5 /usr/local/bin/daily-report.sh

# show your jobs
crontab -l

# always log output for debugging
0 2 * * * /path/to/script.sh >> /var/log/script.log 2>&1

Cron runs with a minimal environment, so always use absolute paths and explicitly redirect output. Test scripts with bash -l -c "command" to mimic cron’s environment. On modern Linux, systemd timers are an alternative with better logging.

Functions

Mon, 01 Jan 0001 00:00:00 +0000

Example:

greet() {
 echo "hello, $1"
}

greet "felipe"

Real-world example: put repeated deployment or cleanup steps into functions so scripts are easier to read and change.