Linux命令行入门：从终端操作到C程序编译的完整实践

简介：本资源是一份面向高校计算机专业本科生的操作系统课程实验报告，聚焦Linux用户接口与编程环境的实践入门，帮助初学者系统掌握命令行操作、系统管理基础及C/Shell程序开发全流程。内容覆盖Linux常用命令（ls/uname/man/pwd等参数详解）、U盘挂载与卸载、vi/vim编辑器使用、GCC编译C程序、Shell脚本三种执行方式，以及root与sudo权限机制的原理与安全实践。资源为1个609KB的Word文档（.docx），结构完整，含实验目的、分步操作命令示例、关键输出说明及深度总结，适合作为实验预习材料、报告撰写参考或期末复习提纲。目前已有109人学习下载，内容详实、术语准确、步骤可复现，特别适合零基础接触Linux系统的学生快速建立实操能力与系统认知框架。

1. 这不是“黑屏命令行”，而是你第一次真正摸到操作系统脉搏的地方

你有没有试过点开一个终端，敲下ls，然后屏幕上突然跳出一堆文件名——那一刻，你其实已经站在操作系统最底层的“对话窗口”前了。它不炫酷，没有按钮和动画，但它比图形界面更真实、更直接：你发一个指令，系统立刻回应，中间不绕路、不翻译、不美化。这就是 Linux 的用户接口——不是冷冰冰的“命令集合”，而是一套人和操作系统之间最原始、最高效的对话协议。它让你能看清文件怎么存、时间怎么记、权限怎么管、程序怎么活；它也是所有服务器、云平台、嵌入式设备背后默认的“工作语言”。学它，不是为了当黑客或修电脑，而是为了不再被“双击运行”“自动安装”“请稍候”这些黑匣子遮住眼睛。哪怕你以后只写网页、做数据分析、甚至画UI，只要代码要跑在机器上，就绕不开这一层。这份实验材料，就是专为零基础新手设计的“第一副操作手套”：不讲内核调度、不碰内存管理，只带你用最常用的 12 个命令、3 种执行方式、1 个 C 程序，亲手完成一次从敲命令→写代码→编译→运行→查错的完整闭环。它不假设你会编程，不预设你装过虚拟机，甚至不强求你记住所有参数——它只保证：你照着做，5 分钟内就能看到自己写的程序在终端里打印出“Hello, Linux!”。

2. 先搞懂一个事实：Linux 的“命令”不是魔法咒语，而是有逻辑的动宾短语

很多人第一次打开终端，看到ls -la /home就懵了：这串字符到底谁是主语、谁是动作、谁是目标？别急，我们把它拆成一句大白话：“请（系统）列出（ls）当前目录下所有文件（-a），并带上详细信息（-l），特别关注这个路径（/home）”。你看，它根本不是乱码，而是一个结构清晰的“动宾+修饰+定位”短句。理解这一点，比死记硬背 50 条命令有用十倍。

2.1 命令 = 动词，选项 = 形容词，路径 = 名词：三要素缺一不可

Linux 所有命令都遵循这个骨架：
[命令] [选项] [目标]
比如cp -r /src /dst：

• cp是动词（copy），表示“复制”；
• -r是形容词（recursive），说明“要连文件夹里面所有东西一起搬”；
• /src /dst是两个名词，分别是“从哪搬”和“搬到哪”。

再看man ls：

• man是动词（manual），意思是“调出说明书”；
• ls是名词，指“你要查哪个命令的说明书”。
  它不是man命令自带ls功能，而是man这个工具专门负责“查任何命令的说明书”，你填什么，它就查什么。这种“工具通用、目标可换”的设计，正是 Linux 高效的核心——你不用学 100 个专用工具，只要掌握 20 个通用动词，再配上不同名词，就能组合出上千种操作。

提示：所有命令的选项前面都带-（单字母）或--（单词全称），比如-a和--all效果一样。初学建议先用-版本，短、快、终端里敲得少。

2.2 为什么ls -a能看见隐藏文件？因为 Linux 把“隐藏”定义成“文件名开头是点”

Windows 用属性位标记“隐藏”，Linux 不玩虚的：只要文件名以英文句点.开头，它就是隐藏的。所以.bashrc、.vimrc这些配置文件，本质就是名字带点的普通文件。ls -a的作用，就是告诉系统：“别过滤掉那些名字带点的，全给我列出来”。你可以马上验证：

touch .secret_file # 创建一个名字带点的文件 ls # 看不到它 ls -a # 立刻出现

这行代码里，touch是“创建空文件”的动词，.secret_file是名词（文件名），没加-选项，因为它默认行为就是“建一个空的”。你不需要知道touch内部怎么写，只要记住：它是个“造文件”的锤子，你给它名字，它就打钉子。

2.3uname -a不是“查系统”，而是“问系统：请报上你的全部家底”

uname这个命令，字面意思是 “Unix name”，但它在 Linux 上早已升级成“系统自报家门”的万能应答器。-a是 all 的缩写，相当于说：“别挑重点，把你能说的全说出来”。它返回的每一项，都是系统启动时就固化在内核里的真实信息：

• Linux：内核名称（不是操作系统名，是内核项目名）；
• hostname：这台机器在网络里的“小名”；
• 5.15.0-xx-generic：内核版本号，决定你能用哪些新功能；
• x86_64：CPU 架构，说明这是 64 位电脑；
• GNU/Linux：说明它用的是 GNU 工具链 + Linux 内核的组合。

你可能会问：查这个有啥用？举个真实场景：某天你下载了一个软件包，提示“仅支持 x86_64 架构”，你敲uname -m（m 是 machine 的缩写），回显x86_64，心里就踏实了；如果回显aarch64（常见于树莓派或苹果 M 系列），你就知道得找另一个版本。它不是知识炫耀，而是你判断“我的机器能不能跑这个”的第一道安检门。

2.4man不是“帮助文档”，而是你随身携带的“命令字典+函数词典+语法手册”三合一

很多新手以为man只能查命令，比如man ls。其实它还能查 C 语言函数：man printf、man memcpy，甚至查配置文件格式：man fstab。它的本质，是 Linux 系统内置的一套分级说明书体系：

• 第 1 章：用户命令（如ls,cp,grep）；
• 第 2 章：系统调用（如open,read,write，C 程序直接调用内核的接口）；
• 第 3 章：库函数（如printf,malloc，标准 C 库提供的功能）；
• 第 5 章：配置文件格式（如/etc/passwd的字段含义）；
• 第 8 章：系统管理命令（如mount,ifconfig，通常需 root 权限）。

当你敲man memcpy，系统默认查第 3 章（库函数），因为memcpy是 C 程序员用的。如果你真想查内核级的内存拷贝（极少用），得写man 2 memcpy强制指定第 2 章。这种分章设计，让同一词条在不同语境下有不同解释——就像“银行”这个词，在金融新闻里指机构，在物理课上可能指“河岸倾斜面”。man的价值，不在于你背下所有内容，而在于你遇到陌生东西时，条件反射敲man xxx，而不是去百度搜“xxx 是什么”，浪费 3 分钟还可能看到过时答案。

2.5pwd和cd看似简单，却是你和系统“空间感”的锚点

pwd（print working directory）输出的不是“当前文件夹名”，而是从根目录/出发，走到你现在位置的完整路径。比如/home/student/lab1，它告诉你：你不在桌面上，不在文档里，而是在student用户家目录下的lab1文件夹里。这个路径，是所有后续操作的“起点坐标”。

cd（change directory）则是移动这个坐标的指令。注意两个高频用法：

• cd ..：回到上一级（..是 Linux 规定的“上级目录”代号）；
• cd ~：瞬间闪现到你的家目录（~是当前用户的家目录快捷符号）。

为什么强调这个？因为新手常犯的错是：在/tmp目录下写了程序，却跑到/home下去gcc hello.c，结果报错“No such file or directory”。他忘了gcc默认只在当前目录找文件。pwd就是你每次敲命令前该看一眼的“GPS 定位”，cd就是你手动校准位置的“方向键”。这不是多余步骤，而是避免 90% 文件找不到错误的后悔药。

3. 别急着写代码：先用 3 个命令搭好你的第一个“开发小房间”

很多新手一上来就想编译 C 程序，结果卡在“文件在哪”“权限不够”“找不到编译器”上，挫败感爆棚。其实 Linux 开发的第一步，根本不是写代码，而是亲手搭一个干净、可控、属于你自己的“工作间”。这个房间要有三样东西：一个专属文件夹、一个文本编辑器、一个能执行命令的环境。我们用 3 个命令，5 分钟搞定。

3.1mkdir：不是“建文件夹”，而是给你划一块“私人领地”

mkdir lab1这条命令，表面是“建一个叫 lab1 的文件夹”，实质是在文件系统里为你申请一块隔离的存储空间。它像在学校里领一把教室钥匙：从此lab1这个文件夹里的所有文件，都归你管，别人（非 root）不能删，系统也不会自动清理。更重要的是，它帮你建立“项目边界”——以后所有实验文件都放这里，不会和桌面、下载、文档混在一起。你可以随时rm -rf lab1彻底清空重来，毫无心理负担。

注意：rm -rf是“强制递归删除”，威力巨大。新手务必养成习惯：删之前先ls lab1确认里面只有你要删的东西。我第一次用rm -rf *清理桌面，手抖多按了个空格，变成rm -rf * .，差点把整个家目录删了……从那以后，我每次删东西前，都强制echo rm -rf lab1先看一遍命令长啥样，确认无误再删。

3.2vi或nano：选一个编辑器，把它当成“写字的纸和笔”，别纠结高级功能

实验报告里提到vi/vim，但对零基础来说，vi的模式切换（命令模式/插入模式/底线模式）简直是玄学入口。新手第一周，请无条件选择nano——它没有模式，打开就写，Ctrl+O保存，Ctrl+X退出，所有操作都在屏幕底部有中文提示。它不酷，但绝不翻车。

安装和使用一步到位（Ubuntu/Debian 系统）：

sudo apt update && sudo apt install nano -y nano hello.c

这时屏幕会弹出一个空白编辑器，你输入：

#include <stdio.h> int main() { printf("Hello, Linux!\n"); return 0; }

Ctrl+O→ 回车（确认保存）→Ctrl+X（退出）。就这么简单。nano的价值，是让你把注意力 100% 放在“写什么”上，而不是“怎么按才能存”上。等你写过 10 个程序，再回头学vi的i进入插入、Esc退出、:wq保存退出，会发现它快得飞起。但第一课，别给自己加戏。

3.3gcc：不是“编译器”，而是把 C 代码“翻译”成机器能懂的“普通话”

gcc hello.c -o hello这条命令，常被误解为“运行编译器”。其实gcc是 GNU Compiler Collection 的缩写，它本身是个“翻译工厂”。你给它 C 代码（人类能读的），它产出可执行文件（机器能跑的二进制）。-o hello指定输出文件名叫hello，否则默认叫a.out（ancient out，古早的输出文件名）。

验证是否成功：

ls -l hello # 查看 hello 文件权限，应该有 x（可执行）标志 ./hello # ./ 表示“在当前目录下运行 hello”，必须加 ./，不能只写 hello

如果屏幕打印Hello, Linux!，恭喜，你完成了从写代码到运行的首次闭环。这一步的意义，远超“打印一句话”——它证明你已打通“编辑→翻译→执行”这条最核心的开发链路。后面所有复杂程序，不过是这条链路上加了更多环节（加库、调试、打包），但骨架从未变过。

3.4chmod：不是“改权限”，而是给文件贴一张“使用说明书”

你可能遇到bash: ./hello: Permission denied。这不是程序错了，而是 Linux 在说：“这文件没贴‘可执行’标签，我拒绝运行”。解决方法：

chmod +x hello

chmod是 change mode 的缩写，+x意思是“加上可执行（execute）权限”。Linux 给每个文件贴三张标签：

• u（user，所有者）、g（group，所属组）、o（others，其他人）；
• 每张标签有三个开关：r（read）、w（write）、x（execute）。

chmod +x是简写，等价于chmod u+x hello，只给所有者加执行权。你也可以chmod 755 hello（数字权限），但新手建议用+x，直观、安全、不易错。权限不是安全恐吓，而是 Linux 的“交通规则”——红灯停、绿灯行，文件有x才能跑，没x就是纯文本。

3.5 常见问题排查：新手最容易卡在这 4 个地方，每条都附解决方案

现象 1：gcc: command not found

原因：系统没装 GCC 编译器，就像想做饭却发现厨房没锅。Ubuntu/Debian 默认不预装开发工具。
解决：

sudo apt update sudo apt install build-essential -y

build-essential是一个“元包”，自动安装gcc,g++,make,libc-dev等全套开发必需品。装完后gcc --version应显示版本号。

现象 2：./hello: No such file or directory（但ls确实能看到 hello）

原因：hello是 64 位可执行文件，但你的系统是 32 位（或反之）；或更常见——你用gcc编译时加了-static选项，导致链接了静态库，而系统缺对应库。
解决：先确认架构：

uname -m # 输出 x86_64 表示 64 位 file hello # 查看 hello 的实际格式，应显示 "ELF 64-bit LSB pie executable"

如果file hello显示ELF 32-bit，而uname -m是x86_64，说明你编译时被误导了。删掉重来：rm hello && gcc hello.c -o hello。

现象 3：nano: command not found

原因：nano未预装（某些最小化安装的 Linux 发行版会省略）。
解决：

# Ubuntu/Debian sudo apt install nano -y # CentOS/RHEL sudo yum install nano -y # 或用 vi 临时顶替（vi hello.c → 按 i 进入输入 → 写完按 Esc → 输入 :wq 回车）

现象 4：sudo: command not found或sudo: unable to resolve host xxx

原因：你当前不是标准用户，而是直接用 root 登录的；或/etc/hosts文件里没配主机名映射。
解决：

• 如果是 root 登录，立刻退出：exit，然后用你安装系统时创建的标准用户名登录（如student）。sudo是为标准用户设计的，root 用它反而多余。
• 如果是 hosts 问题，临时修复：

echo "127.0.0.1 $(hostname)" | sudo tee -a /etc/hosts

（$(hostname)会自动替换为你的机器名）

4. Shell 脚本不是“编程”，而是把你每天重复敲的 5 行命令，打包成一个“一键按钮”

你有没有算过，每天打开终端后，平均要敲多少行命令？cd ~/lab1、ls、gcc hello.c -o hello、./hello、ls -l……如果这些操作每周重复 20 次，一年就是 1000 行。Shell 脚本，就是把这些命令抄进一个文件，然后“一键执行”。它不涉及算法、数据结构，纯粹是命令的流水线装配。

4.1 三种执行方法，本质是“谁来当老板”：你自己、bash 解释器、还是当前 shell

实验报告提到三种方法，但新手常混淆它们的区别。我们用一个真实脚本run.sh演示：

#!/bin/bash echo "开始编译..." gcc hello.c -o hello echo "开始运行..." ./hello echo "运行结束！"

• 方法一：./run.sh（推荐新手用）
  前提：chmod +x run.sh。执行时，系统会读第一行#!/bin/bash，然后启动一个新的 bash 进程来运行脚本。好处：干净隔离，脚本里cd不会影响你当前终端的位置；坏处：新开进程稍慢一点点。

• 方法二：bash run.sh
  你手动指定“请 bash 来执行 run.sh”。效果和./run.sh几乎一样，但不依赖第一行#!。即使你删了#!/bin/bash，bash run.sh依然能跑。适合调试脚本时快速验证。

• 方法三：source run.sh或. run.sh
  这是最容易被误解的。它不是“运行脚本”，而是把脚本里的每一行命令，原样抄到你当前的终端里执行。所以如果脚本里有cd /tmp，执行完后你的终端当前目录真的变成了/tmp！它常用于加载环境变量（如. ~/.bashrc），但绝不适合用来运行含cd、export的常规脚本，否则你会迷失在目录海洋里。

提示：新手统一用./run.sh。它最符合直觉——“我点了一个文件，它就该自己干完所有事”，且不会污染你的当前环境。

4.2#!/bin/bash不是注释，而是“她叫什么名字”的户口本

第一行#!/bin/bash，常被当成注释忽略。其实#在这里是“shebang”符号，!后面是解释器路径。它的作用，是告诉系统：“当用户用./xxx方式运行这个文件时，请用/bin/bash这个程序来解析它”。

• 如果你写#!/bin/sh，系统会用更轻量的sh（POSIX 标准 shell）；
• 如果你写#!/usr/bin/env python3，系统会先查python3在哪（env命令负责找），再调用它。

为什么重要？因为不同 Linux 发行版，bash路径可能不同（/bin/bash或/usr/bin/bash）。用#!/usr/bin/env bash更兼容，但新手先用#!/bin/bash，简单直接。

4.3 一个实用脚本：自动编译+运行+C 代码，附带错误检查

我们写一个真正能用的脚本compile_run.sh，它会：

1. 检查hello.c是否存在；
2. 编译，若失败则报错退出；
3. 运行，若失败则提示。

#!/bin/bash # 检查源文件是否存在 if [ ! -f hello.c ]; then echo "错误：找不到 hello.c 文件！请先用 nano hello.c 创建它。" exit 1 fi # 编译，-Wall 开启所有警告（好习惯！） echo "正在编译 hello.c..." gcc -Wall hello.c -o hello if [ $? -ne 0 ]; then echo "编译失败！请检查 hello.c 的语法。" exit 1 fi # 运行 echo "正在运行..." ./hello

保存后chmod +x compile_run.sh，然后./compile_run.sh。它比手动敲命令多不了几行，但把“检查→编译→运行→反馈”全包圆了，且失败时明确告诉你哪里错了。这才是脚本的价值：不是偷懒，而是把经验固化成可复用的流程。

4.4 Shell 脚本的“变量”不是内存地址，而是“便利贴上的值”

Shell 里定义变量：name="Linux"，使用：echo $name。注意：

• =两边绝对不能有空格，name = "Linux"是错的（它会被解释为命令name，参数=,"Linux"）；
• $name的$是取值符号，就像便利贴上写name，你得加$才能拿到上面的字；
• 变量名区分大小写，NAME和name是两个变量。

你可以用变量让脚本更灵活：

#!/bin/bash SRC_FILE="hello.c" EXE_FILE="hello" if [ ! -f "$SRC_FILE" ]; then echo "错误：找不到 $SRC_FILE" exit 1 fi gcc -Wall "$SRC_FILE" -o "$EXE_FILE" # ...后续同上

引号"$SRC_FILE"是防文件名含空格（如my program.c），虽然新手暂时遇不到，但养成加引号的习惯，能避开未来 80% 的路径错误。

4.5 常见问题排查：Shell 脚本的 3 个隐形杀手，新手必踩

现象 1：./run.sh: Permission denied

原因：脚本文件没加可执行权限，和hello一样。
解决：chmod +x run.sh。永远记住：Linux 不关心文件内容，只认权限位。一个.sh后缀的文件，如果没有x权限，它就是纯文本，不是程序。

现象 2：./run.sh: line 3: syntax error near unexpected token 'then'

原因：if语句格式错误。常见错误：

• if [ condition ] then（错！then必须换行或用;隔开）；
• [ condition ]中[和]两侧必须有空格，[1 -eq 1]是错的，[ 1 -eq 1 ]才对。
  解决：用shellcheck工具检查（sudo apt install shellcheck，然后shellcheck run.sh），它会像老师一样标出每一处语法雷区。

现象 3：脚本里cd /tmp后，ls却显示当前目录没变

原因：你用了source run.sh，脚本在当前 shell 执行，cd确实生效了，但你没注意终端提示符的路径变了！或者你用了./run.sh，它在新进程中cd，不影响你当前终端。
解决：永远用pwd确认当前路径。如果脚本需要改变你的工作目录，用source；如果只是内部流程，用./。别猜，用pwd验证。

5. 从 root 到 sudo：理解 Linux 的“权限分层”，不是为了当管理员，而是为了不删库跑路

实验报告反复强调“不要用 root 登录”，但新手常不解：既然 root 权限最大，为啥还要躲着走？这就像问“为什么银行金库要分多道门，而不是一把万能钥匙？”——权限分层不是限制，而是保险丝。它确保你写错一个命令，最多删掉自己的文件，而不是让整个系统瘫痪。

5.1 root 不是“超级账号”，而是“系统管理员的工牌”

root用户的 UID（用户 ID）是 0，这是 Linux 内核硬编码的“最高权限标识”。它能：

• 删除/etc/passwd（用户数据库），让所有账号失效；
• 格式化/dev/sda（硬盘），让系统彻底消失；
• 修改/boot/vmlinuz（内核镜像），导致开机黑屏。

这些操作，日常开发中 99.9% 用不到。你写 C 程序、查文档、挂 U 盘，都不需要 root。root 的存在意义，是应对极端故障（如系统无法启动、磁盘损坏），而非日常办公。把它想象成消防栓——平时封着，只在火灾时砸开。

5.2sudo不是“提权”，而是“借一张临时工牌”，且有严格时效

sudo的全称是 “substitute user do”，即“以另一用户身份执行命令”。默认是root，但你可以sudo -u student ls以student身份执行。它的精妙设计在于：

• 首次使用需密码：防止他人物理接触你的电脑时乱操作；
• 5 分钟缓存期：这 5 分钟内，你连续执行sudo apt update、sudo reboot，都不用输密码，提升效率；
• 日志全记录：所有sudo命令会写入/var/log/auth.log，谁、何时、执行了什么，一查便知。

所以sudo不是“绕过安全”，而是“在安全框架内，精准授权”。它把“管理员”这个角色，拆解成一个个具体动作（apt install、systemctl restart），你只借其中一项，用完即还。

5.3 为什么sudo rm -rf /是“自杀指令”，而rm -rf /是“权限拒绝”

rm -rf /意思是“递归强制删除根目录下所有东西”。如果你是普通用户：

rm -rf / # 报错：rm: cannot remove '/etc': Permission denied

因为/etc目录权限是drwxr-xr-x，其他用户（others）只有读和执行（进入）权，没有写（删除）权。rm尝试删/etc/passwd时，内核直接拒绝。

但如果你sudo rm -rf /：

• sudo启动一个 root 进程；
• root 对/etc有完全控制权；
• rm顺利删除/etc/passwd，接着删/bin/bash，最后删/sbin/init……系统在 3 秒内崩溃。

关键区别：普通命令受当前用户权限约束；sudo命令受 root 权限约束。这就是分层保护的价值——它不阻止你执行危险命令，但强迫你主动输入密码、明确声明“我要用 root 权限”，给你 3 秒反悔时间。

5.4 实战：挂载 U 盘，一次搞懂mount、umount和权限协作

实验报告提到挂载 U 盘到/mnt。这看似简单，实则完美体现权限协作：

1. 插入 U 盘，系统识别为/dev/sdb1（需dmesg | tail查看）；
2. 创建挂载点：sudo mkdir /mnt/usb（普通用户不能在/mnt下建目录）；
3. 挂载：sudo mount /dev/sdb1 /mnt/usb（mount是特权命令，必须sudo）；
4. 访问：ls /mnt/usb（此时你是普通用户，但/mnt/usb目录权限是drwxr-xr-x，你有读权，可以看文件）；
5. 卸载：sudo umount /mnt/usb（卸载也需sudo，防止未完成写入就拔盘）。

整个过程，sudo只在 2、3、5 步介入，其余全是普通用户操作。Linux 不要求你全程 root，只要求你在“动系统根基”时，亮明身份、接受审查。

5.5 常见问题排查：权限相关的 3 个经典迷思，破除玄学

现象 1：sudo apt update报错Could not get lock /var/lib/dpkg/lock-frontend

原因：另一个进程（如系统更新 GUI）正在用包管理器，锁住了数据库。
解决：

# 查看谁占着锁 sudo lsof /var/lib/dpkg/lock-frontend # 强制杀死（谨慎！） sudo kill -9 $(sudo lsof -t /var/lib/dpkg/lock-frontend) # 或更安全：等待几分钟，通常自动释放

现象 2：sudo提示user is not in the sudoers file

原因：你的账号没被加入sudo用户组。安装系统时，通常只给首建用户加sudo权限。
解决：必须用 root 登录（或重启进 recovery mode），执行：

# root 下执行 usermod -aG sudo your_username

然后重启。切记：此操作只能由 root 或已有 sudo 权限的用户完成，无法自助。

现象 3：sudo密码输对了，还是提示sorry, try again

原因：sudo密码是当前用户的密码，不是 root 密码！很多人误以为要输root的密码。
解决：输你登录系统时用的密码。如果忘了，只能用 recovery mode 重置。

6. 下一步学什么：从“能跑通”到“敢重构”，一条不绕路的 Linux 实践路径

你已经完成了实验一的所有目标：能用ls、pwd、mkdir管理文件，能用nano写 C 程序，能用gcc编译运行，能用sudo安全执行特权命令，甚至能写一个带错误检查的 Shell 脚本。但这不是终点，而是你和 Linux 关系的“破冰仪式”。接下来三个月，我建议你按这个节奏推进，每一步都紧扣“今天就能用上”的原则，绝不堆砌概念：

6.1 第一周：把“重复劳动”自动化，用 Shell 脚本接管你的开发流

目标：让nano→gcc→./a.out→valgrind（内存检查）变成一键操作。

• 学习read命令：让脚本交互式提问，“请输入源文件名？”；
• 学习$1：./compile.sh hello.c中的hello.c会自动成为$1；
• 学习case语句：根据文件后缀（.c、.cpp）自动调用gcc或g++。

我第一次写这个脚本时，把gcc $1 -o ${1%.c}写成了gcc $1 -o $1.out，结果编译main.c生成main.c.out，运行时敲./main.c.out总觉得别扭。后来发现${1%.c}是“去掉结尾 .c”，main.c就变成main。从那以后我每次写变量替换，都先echo ${1%.c}测试一遍，再用在正式命令里。

6.2 第二周：深入man，建立你的“命令决策树”

目标：遇到新命令，30 秒内判断它属于哪一类、常用哪几个选项、是否需要sudo。

• 用man -k keyword（如man -k copy）搜索关键词，找到cp、scp、rsync；
• 重点精读man 1 cp的-r、-i、-v选项，对比cp -r dir1 dir2和cp -r dir1/ dir2/的区别（后者是“把 dir1 里面的东西拷进 dir2”，前者是“把 dir1 整个文件夹拷进 dir2”）；
• 建立个人速查表（用 Markdown 写）：
  | 命令 | 常用场景 | 必备选项 | 是否需 sudo |
  |------|----------|----------|-------------|
  |cp| 复制文件 |-r（目录）,-i（覆盖前询问） | 否 |
  |mount| 挂载设备 | `-

本文还有配套的精品资源，点击获取