MIT Missing Semester 2026 第一课：Shell 入门#

Shell 的作用#

现代计算机通常通过图形界面接收操作，但图形界面只能提供预先设计好的按钮和流程。Shell 提供了一种文本接口，可以运行程序、传入参数、连接输入与输出，并将重复操作组织成可复用的自动化流程。

Shell、终端和命令行程序是三个不同的概念：

以以下命令为例：

1
echo hello

Shell 首先解析命令，确定需要执行 echo，再把 hello 作为参数传给它。程序产生的标准输出随后由终端显示。

Bash 是课程采用的共同基线。Zsh 和 Fish 具有许多人机交互改进，但不如 Bash 普遍。Windows 原生的 cmd.exe 和 PowerShell 不是 Unix Shell；在 Windows 上应使用 WSL 或 Linux 虚拟机。Shell 能力也常用于阅读开源项目安装说明、配置持续集成和诊断程序故障。

常见提示符可能写成：

1
missing:~$

其中 missing 是主机名，~ 表示当前位于 home 目录，$ 通常表示当前不是 root 用户。

命令与参数#

Shell 通常使用空白字符分隔命令和参数：

1
echo hello world

第一个单词是命令，后续单词是传入程序的参数。如果参数包含空格或特殊字符，需要使用引号或转义：

1
cd "My Photos"
2
cd My\ Photos

常见引号的行为不同：

• 单引号通常把内容按字面量处理；
• 双引号保留参数整体，同时允许变量与命令替换；
• $'...' 支持 \n 等 ANSI-C 转义。

1
echo '$HOME !'       # 字面输出 $HOME 和 !
2
echo "$HOME !"       # 展开 $HOME
3
printf '%s\n' $'first\nsecond'

引号不仅影响显示，还决定变量、通配符和特殊字符由 Shell 如何解释。处理文件名或用户输入时，正确引用变量能够避免参数被意外拆分。

1
ls *.txt
2
ls file?.txt
3
ls file[0-9].txt
4
ls {a,b,c}.txt

使用帮助系统#

命令行工具通常通过手册和帮助选项提供使用说明：

1
man date
2
date --help

man 适合查看完整手册，--help 通常提供较短的参数说明。面对陌生命令时，可以采用以下顺序：

1. 确认命令的参数结构；
2. 查找目标选项；
3. 在测试目录中使用小规模数据验证；
4. 确认行为后再处理真实文件。

这种方法比记忆固定命令更可靠，也能降低直接复制网络命令带来的风险。

工作目录与路径#

每个 Shell 进程都有当前工作目录。许多程序在没有收到明确路径时，会对当前目录执行操作。

1
pwd
2
cd /
3
cd ~
4
cd ..
5
ls

这些命令和路径分别表示：

绝对路径从 / 开始，描述从文件系统根到目标的完整位置：

1
/home/alice/project/data.txt

相对路径以当前工作目录为起点：

1
project/data.txt

相对路径是否正确取决于当前工作目录。遇到文件不存在的问题时，应先检查 pwd、目录内容和文件名，而不是立即使用更高权限。

按 Tab 可以触发路径或命令补全。pwd 与 echo "$PWD" 都能查看当前工作目录。

1
ls
2
ls /bin
3
ls -a
4
ls -l
5
ls -lh
6
ls -la

1
-rw-r--r-- 1 user group 45 Jul 26 19:20 hello.txt
2
drwxr-xr-x 2 user group 4.0K Jul 26 18:00 Documents

PATH 与命令查找#

输入不包含路径的命令时，Shell 会使用 PATH 环境变量查找可执行程序。

1
echo "$PATH"
2
which echo
3
type echo
4
type -a echo
5
command -V echo

PATH 包含一组以冒号分隔、按顺序排列的目录。Shell 从前到后搜索与外部命令同名的可执行文件，并运行首先找到的版本。列出这些目录的内容，可以了解当前环境能够直接调用哪些外部程序。

Shell 不一定一开始就查询 PATH。命令名还可能解析为别名、Shell 函数或内建命令。echo、cd、pwd、export 和 alias 都可能由 Shell 自己实现；系统中又可能同时存在 /bin/echo 等外部版本。

1
echo hello          # 通常调用 Shell 内建 echo
2
/bin/echo hello     # 明确调用外部程序

which 主要面向 PATH 中的外部程序，对别名、函数和内建命令的行为会随实现变化。检查一个名称实际会被解释为什么时，type 或 command -V 更可靠；type -a 可列出全部同名实现。

因此，即使程序已经安装，也可能因为以下原因出现 command not found：

• 安装目录不在 PATH 中；
• 环境变量修改尚未加载；
• 命令名称不正确；
• 当前 Shell 使用了不同的环境配置。

当系统中存在多个同名程序时，which 可以帮助确认实际运行的是哪个文件。也可以使用绝对路径绕过 PATH：

1
/bin/echo hello

绝对路径只绕过命令查找，不会绕过 Shell 的参数处理。例如 /bin/echo "$PATH" 中的变量仍由 Shell 先展开，再交给外部程序。

常用文本工具#

Unix 命令行环境强调使用功能相对单一的工具，并通过统一的文本接口组合它们。

1
cat file.txt
2
cat part1.txt part2.txt
3
sort file.txt
4
uniq file.txt
5
sort file.txt | uniq
6
sort -u file.txt
7
head -n 3 file.txt
8
tail -n 3 file.txt

1
sort names.txt | uniq -c

1
grep 'apple' hello.txt
2
grep -i 'apple' hello.txt
3
grep -n 'apple' hello.txt
4
grep -v 'apple' hello.txt
5
grep -l 'TODO' *.py
6
grep -q 'apple' hello.txt
7
grep -rn --include='*.py' 'TODO' .

1
sed 's/apple/orange/' hello.txt
2
sed 's/apple/orange/g' hello.txt
3
sed 's/old/new/g' file.txt

1
sed -i 's/old/new/g' file.txt

1
find 起点 条件 条件 动作

1
find ~/Downloads -type f -name "*.zip" -mtime +30
2
find ~ -type f -size +100M -exec ls -lh {} \;
3
find . -type f -name "*.py" -exec grep -l "TODO" {} \;

1
find ~ -type f -size +100M -exec ls -lh {} +

1
awk '{print $2}' data.txt
2
awk -F, '{print $2}' data.csv

1
pattern { action }

1
awk -F ',' '{print $1, $3}' people.csv
2
awk -F ',' 'NR > 1 && $2 > 18 {print $1, $3}' people.csv
3
awk -F ',' 'NR > 1 {sum += $2} END {print sum}' people.csv
4
awk 'END {print NR}' data.txt

1
ssh myserver 'journalctl -u sshd -b-1 | grep "Disconnected from"' \
2
  | sed -E 's/.*Disconnected from .* user (.*) [^ ]+ port.*/\1/' \
3
  | sort | uniq -c \
4
  | sort -nk1,1 | tail -n10 \
5
  | awk '{print $2}' | paste -sd,

1
producer
2
producer | filter
3
producer | filter | extract
4
producer | filter | extract | sort

标准输入、标准输出与标准错误#

命令行程序通常使用三条标准流：

默认情况下，stdin 来自键盘，stdout 和 stderr 显示在终端。Shell 可以把这些流连接到文件：

1
command < input.txt
2
command > output.txt
3
command >> output.txt
4
command 2> error.txt
5
command > all.txt 2>&1

其中：

• < 从文件读取标准输入；
• > 覆盖文件并写入标准输出；
• >> 追加标准输出；
• 2> 单独重定向标准错误；
• 2>&1 让标准错误指向当前标准输出的目标。

重定向会从左到右处理，因此调整顺序可能改变最终结果。对重要文件使用 > 前，应确认目标文件是否允许被覆盖。

如果命令没有收到文件参数，它通常会从 stdin 读取。例如：

1
grep apple

可以逐行键入文本，最后按 Ctrl+D 发送 EOF，表示输入流结束。EOF 不是实际输入的字符，而是“不会再有后续数据”的状态。

输入重定向与文件参数有时产生相同输出，但文件由不同主体打开：

1
sort < hello.txt   # Shell 打开文件，并把文件连接到 sort 的 stdin
2
sort hello.txt     # sort 收到文件名参数，并自行打开文件

> 会在命令运行前创建目标文件；如果文件已存在，则先把它截断为零长度。因此，单独执行以下语句也会清空文件：

1
> result.txt

重定向的顺序可以通过文件描述符模型理解：

1
command > all.log 2>&1
2
command 2>&1 > out.log

第一条命令先让 stdout 指向文件，再让 stderr 复制 stdout 的当前目标，因此两者都进入文件。第二条命令先让 stderr 复制仍指向终端的 stdout，随后才改变 stdout，因此 stderr 仍显示在终端。Bash 还提供 command &> all.log 作为同时重定向两者的专有简写。

管道与程序组合#

管道符 | 把左侧程序的 stdout 连接到右侧程序的 stdin：

1
producer | transformer | consumer

例如：

1
printf 'pear\napple\npear\n' | sort | uniq -c | sort -nr

这个管道依次执行：

1. 产生多行文本；
2. 对文本排序，使相同内容相邻；
3. 统计每种内容的数量；
4. 按数字降序排列。

管道传递的是字节流，而不是文件本身。stderr 默认不会进入管道，除非显式重定向。

调试复杂管道时，适合从左向右逐步扩展：

1
producer
2
producer | filter
3
producer | filter | sort
4
producer | filter | sort | uniq -c

每增加一个步骤，都应先观察当前数据的格式和含义。

tee 可以在保留管道输出的同时把内容写入文件：

1
command | tee full.log | grep CRITICAL

完整输出进入 full.log，而终端只显示经过筛选的行。

tee 默认覆盖目标文件，追加写入需要 -a：

1
command | tee -a full.log | grep CRITICAL

tee 只复制进入其 stdin 的数据。若上游程序的 stderr 也需要保存，必须先显式合并或单独重定向。

退出状态与条件执行#

Unix 程序通常使用退出状态报告执行结果：

• 0 表示成功；
• 非零值表示失败。

上一条命令的退出状态保存在 $?：

1
command
2
echo "$?"

Shell 的条件控制主要依据退出状态，而不是命令输出的文字：

1
command1 && command2
2
command1 || command2

• && 只在前一个命令成功时执行后一个命令；
• || 只在前一个命令失败时执行后一个命令。

Bash 条件与循环#

Bash 不只是交互式命令环境，也是一门脚本语言。

1
if [ -f "$file" ]; then
2
    echo "file exists"
3
else
4
    echo "file does not exist"
5
fi

1
if grep -q "apple" hello.txt; then
2
    echo "found"
3
else
4
    echo "not found"
5
fi

1
if grep -q "apple" hello.txt
2
then
3
    echo "found"
4
fi

1
[ -f "$file" ]      # 正确
2
[-f "$file"]        # 错误

1
[ "$name" = "Alice" ]

1
if [[ $filename == *.txt ]]; then
2
    echo "text file"
3
fi

1
for item in a b c; do
2
    echo "$item"
3
done

1
while command; do
2
    another_command
3
done

1
count=1
2
while [[ $count -le 5 ]]; do
3
    echo "$count"
4
    ((count++))
5
done

1
for i in {1..10}; do
2
    echo "$i"
3
done
4

5
for ((i = 1; i <= 10; i++)); do
6
    echo "$i"
7
done

1
backup="notes_$(date +%Y-%m-%d).txt"

1
for i in $(seq 1 10); do
2
    echo "$i"
3
done

后台任务与进程清理#

命令末尾的 & 会异步启动命令，使 Shell 不等待其完成就继续执行。特殊参数 $! 是最近放入后台的作业的进程 ID：

1
long_running_command &
2
worker_pid=$!
3

4
# 执行其他工作
5

6
kill "$worker_pid"

kill 默认发送 SIGTERM，请求进程有序终止。若脚本可能在中途退出，只在正常路径末尾调用 kill 无法保证清理，可以使用退出陷阱：

1
cleanup() {
2
    kill "$worker_pid" 2>/dev/null || true
3
}
4
trap cleanup EXIT

trap ... EXIT 会在 Shell 退出前执行清理函数。实际脚本仍需处理后台进程已经结束、变量尚未赋值等边界。

Shell 脚本执行#

Shell 命令可以保存为 .sh 文件。脚本开头通常包含 shebang：

1
#!/usr/bin/env bash

shebang 指定直接执行文件时使用的解释器。

脚本可以显式交给 Bash：

1
bash script.sh

也可以增加执行权限后直接运行：

1
chmod +x script.sh
2
./script.sh

直接执行依赖正确的 shebang 和执行权限。

三种运行方式的解释器选择不同：

• ./script.sh 直接执行文件，由 shebang 指定解释器；
• bash script.sh 明确让 Bash 读取文件，不依赖执行权限，也不依赖 shebang 选择 Bash；
• sh script.sh 明确使用 sh，不会因为脚本的 Bash shebang 自动切换。

因此，使用 [[ ... ]]、(( ... )) 等 Bash 语法的脚本不应通过 sh script.sh 运行。变量赋值的等号两侧也不能加空格：

1
LOGFILE="test.log"     # 正确
2
LOGFILE = "test.log"   # 错误：会被解析为执行 LOGFILE 命令

更严格的 Bash 模式#

常见脚本会启用：

1
set -euo pipefail

这些选项的基本含义是：

• -e：未处理的命令失败时尽早退出；
• -u：使用未定义变量时报错；
• pipefail：管道中的关键命令失败时让整个管道报告失败。

严格模式可以减少静默错误，但不能代替测试和错误处理。ShellCheck 等静态分析工具可以发现许多常见的引用、条件和可移植性问题。

这些选项有更精确的边界：

• set -e 有控制流例外。命令作为 if、while、until 的条件，或位于某些 &&、||、! 上下文时，非零状态不会直接使脚本退出；
• set -u 会把未定义变量视为错误。有意使用默认值时可以写 ${name:-unknown}；
• set -o pipefail 使管道返回最右侧非零命令的状态；如果所有命令成功，则返回 0；
• 算术命令 (( expression )) 在表达式结果为 0 时返回状态 1，因此与 set -e 组合时需要注意所处上下文。

综合示例：反复运行测试直到失败#

下面的脚本组合了严格模式、后台任务、特殊参数、命令替换、循环和重定向：

1
#!/bin/bash
2
set -euo pipefail
3

4
stress --cpu 8 &
5
STRESS_PID=$!
6

7
LOGFILE="test_runs_$(date +%s).log"
8
RUN=1
9

10
while cargo test my_test > "$LOGFILE" 2>&1; do
11
    echo "Run $RUN passed"
12
    ((RUN++))
13
done
14

15
kill "$STRESS_PID"
16
echo "Test failed on run $RUN"
17
echo "Last 20 lines of output:"
18
tail -n 20 "$LOGFILE"
19
echo "Full log: $LOGFILE"

执行流程如下：

1. stress --cpu 8 & 在后台启动八个 CPU 压力工作进程；
2. STRESS_PID=$! 保存后台作业的 PID；
3. $(date +%s) 产生 Unix 时间戳，用于生成不同的日志文件名；
4. while cargo test ...; do 直接用测试命令的退出状态控制循环；
5. > "$LOGFILE" 2>&1 先把 stdout 指向日志，再让 stderr 复制 stdout 的目标；
6. 测试成功时输出轮次并递增计数，失败时退出循环；
7. kill 停止后台负载，tail 显示失败日志的最后 20 行。

该示例适合解释语义，但仍有四个工程边界：

• stress 会显著占用 CPU，不应在不了解影响时直接运行；
• 循环中的 > 会在每轮覆盖日志，因此最终只保留最后一轮输出；若要保留全部轮次，应使用 >> 并加入轮次分隔；
• 如果脚本在执行 kill 前异常退出，后台任务可能继续运行，应使用 trap cleanup EXIT；
• 如果测试始终成功，循环不会结束，实际脚本应增加最大轮数或外部超时。

一个带清理和最大轮数的结构可以写成：

1
#!/usr/bin/env bash
2
set -euo pipefail
3

4
stress --cpu 8 &
5
STRESS_PID=$!
6

7
cleanup() {
8
    kill "$STRESS_PID" 2>/dev/null || true
9
}
10
trap cleanup EXIT
11

12
LOGFILE="test_runs_$(date +%s).log"
13
RUN=1
14
MAX_RUNS=100
15

16
while [[ $RUN -le $MAX_RUNS ]] &&
17
      cargo test my_test > "$LOGFILE" 2>&1; do
18
    echo "Run $RUN passed"
19
    ((RUN++))
20
done

这个版本保证 Shell 退出时尝试清理后台任务，并为循环设置上限。日志保留策略仍需根据目标选择覆盖或追加。

补充#

以下是若干正文没有展开、但属于 Shell 基础链条的知识。

1
echo "$SHELL"

1
ls /nonexistent /tmp >stdout.log 2>stderr.log
2
ls /nonexistent /tmp >all.log 2>&1

1
test -d /tmp/mydir || mkdir /tmp/mydir

1
#!/usr/bin/env bash
2

3
file=$1
4
if [[ -f $file ]]; then
5
    printf '%s\n' "file exists: $file"
6
else
7
    printf '%s\n' "file does not exist: $file"
8
fi

1
if (( $# == 0 )); then
2
    printf '%s\n' "usage: $0 command [arg ...]" >&2
3
    exit 2
4
fi
5

6
while "$@" >"$LOGFILE" 2>&1; do
7
    ((RUN++))
8
done

1
chmod +x check.sh
2
./check.sh somefile

1
set -x
2
command arg
3
set +x

1
cp -- notes.txt "notes_$(date +%Y-%m-%d).txt"

1
find "$HOME" -type f -name '*.*' -printf '%f\n' 2>/dev/null \
2
  | sed -n 's/.*\.//p' \
3
  | tr '[:upper:]' '[:lower:]' \
4
  | sort \
5
  | uniq -c \
6
  | sort -nr \
7
  | head -n 5

1
find . -type f -name '*.sh' -print0 | xargs -0 -r wc -l

1
curl -s "$COURSE_URL" | grep -c 'href="/2026/'

1
curl -fsSL "$JSON_URL" \
2
  | jq -r '.[] | select(.version > 6) | .name'

1
printf 'a 50 x\nb 150 y\nc 200 z\n' \
2
  | awk '$2 > 100 {print $3, $2, $1}'

1
y 150 b
2
z 200 c

1
awk '{print $1}' ~/.bash_history \
2
  | sort \
3
  | uniq -c \
4
  | sort -nr \
5
  | head -n 10

Shell 的适用边界#

Shell 适合：

• 组合现有命令；
• 批量处理文件；
• 编写构建、部署和环境初始化入口；
• 自动化短小、线性的系统任务。

当脚本需要复杂数据结构、大量错误处理、并发控制或系统化测试时，Python 等通用编程语言通常更容易维护。

Shell 的优势不在于替代所有编程语言，而在于用统一的输入输出模型，把已有工具高效组合成新的工作流。完成这些基础后，课程下一讲将继续讨论如何用 Shell 和更多命令行程序执行、组合并自动化更复杂的任务。

参考来源#

• MIT Missing Semester 2026：Course Overview + Introduction to the Shell
• MIT Missing Semester 2026 课程主页
• 简体中文社区翻译：课程概览 + Shell 入门
• YouTube：Lecture 1 — Course Overview + Introduction to the Shell
• GNU Bash Reference Manual
• GNU Awk User’s Guide
• GNU Coreutils Manual
• GNU Grep Manual
• GNU Findutils Manual
• GNU sed Manual
• curl Manual
• jq Manual
• 课程练习示例 JSON
• systemd：journalctl Manual
• OpenSSH：ssh(1) Manual