Day 5 - Week 3 Comprehensive Review: The Big Picture of the Shell and Scripts

📌 Key Takeaways

• This week converges on a single question — "how do we hand work we used to do by hand over to the shell in a repeatable way".
• Shell families are Bourne (sh·ksh·bash·zsh) and C (csh·tcsh). The standard is bash, and csh introduced alias and history.
• Variables are divided by whether they are exported, and configuration files differ between login shells (~/.bash_profile) and interactive shells (~/.bashrc).
• FD 0·1·2 and the order of 2>&1, the difference between glob * and regex *, and the three kinds of quotes are the heart of Day 2.
• Scripts build up in this order: shebang → positional parameters → [ ] conditions (string =, number -eq, spaces required) → if/case/for/while → functions.

Day 1 Review: The Shell, Variables, and Initialization Files

• The shell is the command interpreter between the kernel and the user.
• Types split into the Bourne family (sh → ksh → bash → zsh) and the C family (csh → tcsh), and bash is the standard Linux login shell.
• It was csh that first introduced alias and history.
• A shell variable is valid only in the current shell and is not inherited by children, while an environment variable marked with export is inherited by child processes. Inheritance goes in one direction only, parent→child.

The read order of initialization files differs by shell type.

• Login shell: /etc/profile → (the first one of ~/.bash_profile → ~/.bash_login → ~/.profile) → ~/.bash_logout at logout
• Non-login interactive shell: /etc/bashrc → ~/.bashrc
• To apply a change immediately, use source or . (dot). bash file applies only in a new child shell, so it has no effect.

💡 Concept: A one-line summary of the key point — .bash_profile once at login, .bashrc every time a shell is launched. So the convention is to put aliases and functions in .bashrc and environment variables in .bash_profile.

Day 2 Review: Redirection, Pipes, Metacharacters

Every process has three standard channels — stdin (0), stdout (1), stderr (2). Redirection changes where these FDs are connected.

• The order of 2>&1 decides the result. It must be > file 2>&1 (redirect 1 to the file first, then merge 2) for both to go to the file.
• A pipe (|) connects the stdout of the preceding command to the stdin of the following command (stderr is not passed by default).
• Combine filters (grep, sort, uniq, wc, cut, tee, etc.) to turn a compound job into one line.
• Wildcards (globbing) are expanded by the shell into file names before the command runs: * (zero or more), ? (exactly one), [ ] (one of the characters in brackets). The meaning differs from * in regular expressions (repetition of the preceding character).

The behavioral differences among quotes are an item the exam asks about.

⚠️ Trap: With sort file > file, > empties the file before the command runs, so the contents vanish. To write to the same file, use the tool's -o option or go through a temporary file.

Day 3 Review: Aliases, History, Job Control

• alias gives a nickname to a long command, and to make it permanent you put it in ~/.bashrc. Temporary bypasses are \command, command cmd, and the absolute path.
• history is reused with !! (the whole previous command), !n (number n), and !$ (the last argument of the previous command). Behavior is tuned with HISTSIZE (number kept in memory) and HISTCONTROL (duplicate and space control).
• Job control is the most practical part of this week.

When the terminal closes, SIGHUP is delivered to the jobs inside and kills them. nohup makes them ignore this signal, but background execution is strictly &'s job, so you must use both together.

Day 4 Review: Shell Scripting Basics

• The shebang (#!/bin/bash) on the first line of a script specifies the interpreter. ./script.sh runs in a child shell and source script.sh runs in the current shell.
• Positional parameters: $0 (name), $1~$9 (arguments), $# (count), $@ (all, separated), $? (exit status, 0=success), $$ (PID).
• Condition evaluation (test/[ ]): strings use =, !=, -z, -n; numbers use -eq, -ne, -gt, -lt; files use -f, -d, -e. Spaces are required inside the brackets and around operators.
• Control structures: if-elif-else-fi, case-esac (patterns end with ;;, *) is the default), for-do-done, while-do-done, until. Control loops with break and continue.
• Functions: return gives only an exit status of 0~255, and data is passed with echo+$(function). Localize variables inside functions with local.

if accepts not only [ ] but any command as a condition and branches on its exit status, as in if grep -q root /etc/passwd; then .... [ ] can be an if condition because it is itself a command called test.

Integrated Scenario: Where What You Learned Meets in One Script

Here we summarize how this week's concepts are used together in a real script.

#!/bin/bash
# Compress today's .log files in the log directory and record the result
 
LOG_DIR="/var/log/myapp"
DATE=$(date +%Y%m%d)              # command substitution (Day3)
REPORT="/tmp/compress_$DATE.txt"
 
if [ ! -d "$LOG_DIR" ]; then      # file test + conditional (Day4)
    echo "Directory not found: $LOG_DIR" >&2   # stderr redirection (Day2)
    exit 1
fi
 
count=0
for file in "$LOG_DIR"/*.log; do  # wildcard + for (Day2,4)
    [ -f "$file" ] || continue    # skip when nothing matches
    gzip "$file" 2>> "$REPORT"    # append errors only (Day2)
    count=$((count + 1))          # arithmetic expansion (Day3)
done
 
echo "Compression complete: $count files" | tee -a "$REPORT"   # pipe + tee (Day2)

• This short script contains command substitution, conditionals, file tests, redirection, wildcards, loops, arithmetic expansion, pipes, and tee, all together.
• It shows that what you learned this week is not isolated knowledge but parts that mesh to automate a single task.

A "log compression and cleanup" script like this is actually handled for you by a standard tool called logrotate. But logrotate's inner workings and custom cleanup logic ultimately stand on the principles of shell scripts like this one. Knowing the fundamentals also helps you understand what the standard tools are doing.

Final Checklist Right Before the Exam

• Shell family classification: ksh is the Bourne family (don't be fooled by the name), and csh introduced alias and history
• $SHELL is the default login shell; the current shell is echo $0
• The difference between shell and environment variables is whether it is exported, and inheritance is one-way parent→child
• Login shell: /etc/profile → ~/.bash_profile; interactive: ~/.bashrc
• FD: stdin 0, stdout 1, stderr 2 / the order of 2>&1 matters
• Glob * ≠ regex *
• Single quotes = block everything, double quotes = expand variables only
• Ctrl-Z = suspend, Ctrl-C = terminate / use nohup and & together
• test: string =, number -eq, spaces required
• $? = exit status (0=success), a function's return is an exit status only

📖 Glossary

• Bourne family / C family : The group of bash, ksh, and zsh descended from sh, and the tcsh group that branched from csh.
• Shell variable vs environment variable : A variable not passed to children because it is not exported, versus one that is passed.
• ~/.bash_profile vs ~/.bashrc : A file read once at login, versus a file read every time a new shell is launched.
• source (.) : A command that reads a file inside the current shell to apply settings immediately.
• FD 0/1/2 : The numbers of standard input, standard output, and standard error. Redirection changes what these numbers are connected to.
• 2>&1 : Notation that merges errors into the output. It must be written after > file for both to go to the file.
• Globbing : The expansion in which the shell replaces *, ?, and [] with actual file names in advance. The meaning differs from regex.
• SIGHUP : The signal delivered to jobs inside a terminal when it closes. It is ignored with nohup.
• Job number (%n) : A job identification number that is meaningful only within the current shell. Used like fg %1.
• shebang : The first line that specifies which interpreter should run the script.
• $? : The exit status of the previous command. 0 is success, and conditionals branch on this value.
• test/[ ] : A command that evaluates a condition and answers with an exit status. Strings use =, numbers use -eq, spaces required.
• local : The keyword that declares a local variable that lives only inside a function.