Bash Essentials

basics beginner

Variables

Assign without spaces around =; reference with $.

details / example

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.

basics beginner

Prompt

The prompt is the text Bash shows when it is ready for your next command.

basics beginner

Quoting

Single quotes preserve everything literally; double quotes allow variable expansion.

details / example

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).

basics beginner

echo & printf

echo for simple output, printf when you need formatting or precise control.

details / example

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.

navigation beginner

pwd

pwd prints the current working directory.

navigation beginner

cd

cd changes the current directory.

basics beginner

Command Substitution

Capture the output of a command into a variable.

details / example

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.

basics beginner

Exit Codes

Every command returns 0 (success) or non-zero (failure). Available as $?.

details / example

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".

navigation beginner

ls

ls lists files and directories.

details / example

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.

basics beginner

Shebang & Permissions

The shebang line tells the OS which interpreter to use; the file must be executable.

details / example

#!/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 ./.

control-flow beginner

if / else

Conditional execution. Test expressions go in [[ ... ]].

details / example

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.

commands beginner

cat and less

cat concatenates and prints file contents to the terminal; less opens a paged, scrollable view of a file.

details / example

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.

control-flow beginner

for loops

Iterate over a list, range, or files matching a glob.

details / example

# 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++)).

files beginner

touch and mkdir

touch updates a file’s timestamp, or creates it empty if it does not exist; mkdir creates a directory.

control-flow beginner

while loops

Repeat while a condition holds. Most useful for reading input line-by-line and polling.

details / example

# 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.

control-flow beginner

case

Match a value against multiple patterns. Cleaner than long if/elif chains.

details / example

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.

files beginner

cp, mv, and rm

cp copies, mv moves or renames, and rm removes files.

details / example

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.

files-streams beginner

Redirection

Send command output to a file or read input from a file.

details / example

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.

files-streams beginner

Pipes

Connect the stdout of one command to the stdin of the next.

details / example

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.

files-streams beginner

File Tests

Common tests inside [[ ]] for checking file properties.

details / example

[[ -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.

files-streams beginner

stdin / stdout / stderr

File descriptors 0, 1, 2: input, normal output, error output.

details / example

# 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.

files-streams beginner

Globs & Wildcards

Pattern matching for filenames.

details / example

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.

utilities beginner

grep

Search for patterns in files or stdin.

details / example

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.

utilities beginner

find

Locate files by name, type, modification time, or other attributes.

details / example

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.

scripting intermediate

Environment variables

Environment variables are shell variables marked with export, so child processes inherit them.

details / example

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.

utilities beginner

sed

Stream editor for find/replace and basic transforms on text.

details / example

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.

utilities beginner

awk

Column-oriented text processing, powerful for tabular data.

details / example

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.

utilities beginner

xargs

Build commands from stdin, useful for chaining find to other commands.

details / example

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.

utilities beginner

jq

Like sed/awk for JSON. Essential for working with APIs and structured logs.

details / example

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.

workflows intermediate

Robust Script Template

A safe starting point for any new script. The set options catch errors that would otherwise pass silently.

details / example

#!/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.

workflows intermediate

Process Files in a Loop

A common pattern: iterate over matching files and run something on each, with proper handling of edge cases like spaces and nested directories.

details / example

#!/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.

workflows intermediate

Args & User Input

Standard pattern for parsing positional args and flags in a script.

details / example

#!/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.

workflows intermediate

Background Jobs

Run commands asynchronously and manage long-running processes.

details / example

# 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).

workflows intermediate

Cron / Scheduled Tasks

Run scripts on a schedule. Cron is the standard Unix scheduler and is everywhere.

details / example

# 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.

scripting intermediate

Functions

A Bash function names a reusable group of commands.

details / example

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.