Linux之Ubuntu入门篇知识总结

学习资料：B站正点原子官方视频＋文档

说明：这里不再去讲工具安装使用了，我遇到的问题都在问题篇总结出来了，这里是对shell,Linux文件

这些以后真正必须熟练运用的知识的理解与总结

再次说明：我是初学者，手搓毕竟还有很多不足之处，请大家多多包容，有问题能指出再好不过啦

一，shell命令

1，什么是shell

我们把Linux想成一家餐厅：

• 你：使用电脑的人
• 终端：你点餐的窗口
• Shell：听懂要求并传达给厨房的服务员
• Linux系统：后面的厨房
• 命令：你说的话

2，举个例子

例如你在终端输入：

ls

过程是：

你输入"ls"
→ Shell看懂"查看文件"
→ Shell让Linux执行
→ Linux返回文件列表
→ Shell把结果显示给你

所以：

Shell是你和Linux之间的翻译员。

3，最常用命令（大白话版）

（快来熟悉专属魔法咒语，大过节的亲戚面前装逼也倍有面子）

可能是因为我笨笨的，官方语言实在是看的快睡着了，正规描述还是看官方文档，我这里只是自己看得懂的理解

|------------|------------|
| pwd | 我现在在哪？ |
| ls | 这里有什么？ |
| ls -a | 把隐藏的也显示出来 |
| cd 文件夹 | 进入文件夹 |
| cd .. | 返回上一层 |
| mkdir 文件夹 | 创建文件夹 |
| touch 文件 | 创建空文件 |
| cat 文件 | 查看文件内容 |
| echo "文字" | 显示一段文字 |
| cp 原文件 新文件 | 复制文件 |
| mv 旧名字 新名字 | 移动文件或改名 |
| file 文件 | 查看文件类型 |
| find | 寻找文件 |
| grep | 在文件中寻找文字 |
| clear | 清除终端屏幕 |
| rm 文件 | 删除文件 |
| rmdir 文件夹 | 删除空文件夹 |
| man 命令 | 查看命令说明书 |
| sudo 命令 | 临时使用管理员权限 |
| gedit | 打开某个文件 |
| ps | 查看正在运行的程序 |
| top | 实时查看系统运行状态 |
| df -h | 查看磁盘所剩空间 |
| du -sh 文件夹 | 查看文件夹大小 |

4，实战

1， 运行截图

2，命令解释

1. 查看外卖店准备开在哪里

pwd

我现在在哪里？

ls

这里有什么东西？

ls -a

把隐藏的东西也显示出来。

2. 创建外卖店

mkdir takeaway_shop

创建一家叫takeaway_shop的外卖店。

cd takeaway_shop

走进外卖店。

pwd

确认自己已经进入外卖店。

3. 创建订单室

mkdir orders

创建一个存放订单的房间。

cd orders

进入订单室。

4. 创建订单

touch order.txt

创建一张空订单。

touch .shop_secret

创建一份隐藏的店铺资料。

先输入：

ls

只能看到普通订单。

再输入：

ls -a

可以看到隐藏的.shop_secret。

5. 填写订单

gedit order.txt

在打开的记事本里输入：

顾客：小明
外卖：牛肉面
状态：制作中

保存并关闭窗口。

6. 查看订单

cat order.txt

终端会显示订单内容。

echo "外卖店收到新订单"

终端会显示这句话。

7. 复制订单

cp order.txt order_copy.txt

相当于复印一张订单。

ls

现在可以看到两份订单。

8. 给订单改名

mv order_copy.txt finished_order.txt

把复制的订单改名为"已完成订单"。

ls

9. 查看订单是什么文件

file order.txt

Linux会告诉你这是文本文件。

10. 寻找订单

find . -name "order.txt"

订单放在哪里？

grep "牛肉面" order.txt

在订单中寻找"牛肉面"。

11. 查看外卖店和电脑状态

du -sh .

查看订单室占用了多少空间。

df -h

查看电脑磁盘还剩多少空间。

ps

查看有哪些程序正在工作。

top

查看哪些程序最忙。按q退出。

12. 查看命令说明

man ls

查看ls的说明书。按q退出。

sudo ls

相当于临时拿到"店长钥匙"，用管理员身份查看文件。

13. 擦干净屏幕

clear

只清理终端画面，不会删除订单。

14. 外卖店关门，清理订单

rm order.txt

删除原订单。

rm finished_order.txt

删除已完成订单。

rm .shop_secret

删除隐藏资料。

返回外卖店：

cd ..

删除空订单室：

rmdir orders

离开外卖店：

cd ..

删除空外卖店：

rmdir takeaway_shop

最后查看：

ls

整个过程就是：

找到位置 → 开外卖店 → 建订单室 → 写订单 → 复制订单 → 改名 → 查找订单 → 删除订单 → 关闭外卖店

二，Ubuntu文件系统结构

把Linux文件系统想成一栋大楼。

根目录/

/就是整栋大楼的大门，所有房间都在它里面。

/
├── home
├── etc
├── dev
├── boot
└── tmp

常见文件夹（了解）

文件夹	生活类比	用途
/home	普通用户的房间	保存你的文件
/root	管理员的房间	root用户的文件
/bin	工具箱	保存ls、cp等命令
/sbin	管理员工具箱	保存系统管理命令
/etc	规章制度柜	保存系统配置
/boot	启动室	保存Linux启动文件
/dev	设备窗口	表示硬盘、串口等设备
/lib	公共零件库	保存程序使用的库
/tmp	临时桌子	保存临时文件
/var	记录室	保存日志等经常变化的文件
/proc	系统仪表盘	显示进程和系统运行信息
/sys	硬件仪表盘	显示内核和硬件信息
/media	自动停车位	U盘通常挂载在这里
/mnt	手动停车位	手动挂载设备
/usr	软件仓库	保存大量软件和相关文件
/opt	第三方软件区	安装额外软件
/srv	服务区	保存网络服务数据

（注意：/dev中主要是"设备文件"，不是驱动程序本身。）

绝对路径

从大楼入口/开始写完整地址：

/home/zyy/order.txt

类似：

中国／某省／某市／某街道／某房间

无论你当前在哪里，这个地址都不会变。

相对路径

从你当前所在的位置开始写：

order.txt

类似：

从我现在的位置往前走。

例如当前位于：

/home/zyy

那么：

order.txt

表示：

/home/zyy/order.txt

一句话记忆：

/是整栋大楼；绝对路径从大门开始，相对路径从当前位置开始。

三，文件权限管理

1，文件权限是什么

把文件想成一张外卖订单。

不同的人对订单能做的事情不同：

• r：read，能查看订单。
• w：write，能修改订单。
• x：execute，能把它当程序运行。

外卖店里有三类人：

1. u：店主，也就是文件拥有者。
2. g：店里的员工，也就是同组用户。
3. o：路人，也就是其他用户。

2，看懂权限

运行：

ls -l a.c

可能看到：

-rw-rw-r-- 1 zyy zyy 100 a.c

把权限拆开：

-   rw-   rw-   r--
│    │     │     │
│    │     │     └─ 其他人
│    │     └─────── 同组用户
│    └───────────── 文件拥有者
└────────────────── 文件类型

具体意思：

• 第一个-：这是普通文件。
• 第一个rw-：店主可以读、写，不能运行。
• 第二个rw-：员工可以读、写，不能运行。
• 最后r--：其他人只能查看。

常见文件类型：

• -：普通文件。
• d：文件夹。
• l：软链接。

3，数字权限（二进制表示）

Linux也可以用数字表示权限：

r = 4
w = 2
x = 1

把需要的权限加起来：

• 7 = 4+2+1：rwx，可读、可写、可运行。
• 6 = 4+2：rw-，可读、可写。
• 5 = 4+1：r-x，可读、可运行。
• 4：r--，只能读。
• 0：---，什么都不能做。

因此：

-rw-rw-r--

对应：

664

4，chmod：修改权限

chmod相当于修改外卖店的规定。

把a.c修改为rw-rw-r--：

chmod 664 a.c

给文件拥有者增加执行权限：

chmod u+x a.c

• u：拥有者。
• +：增加权限。
• x：执行权限。

删除执行权限：

chmod u-x a.c

注意：C源文件a.c通常不需要执行权限。编译出来的程序才需要执行权限。

5，chown：修改主人

chown相当于把外卖店转让给别人。

例如把a.c交给用户zyy：

sudo chown zyy a.c

同时修改拥有者和用户组：

sudo chown zyy:zyy a.c

• 第一个zyy：新拥有者。
• 第二个zyy：新用户组。

最简单记忆

r：能看
w：能改
x：能运行

chmod：修改权限
chown：更换主人

三，Linux连接文件

先理解普通文件

把一个文件想成一个房间：

order.txt → 房间里放着"牛肉面订单"

• order.txt是房间的门
• 文件内容是房间里的东西

复制文件

复制文件相当于重新建一个房间：

order.txt       → 房间1：牛肉面订单
order_copy.txt  → 房间2：牛肉面订单

这是两个独立房间

修改房间1，不会影响房间2

硬链接

硬链接相当于：

给同一个房间再开一扇门。

order.txt ──→ 同一个房间
hard.txt  ──→ 同一个房间

两个名字进入的是同一个房间。

所以：

• 修改order.txt，hard.txt也会看到变化。
• 删除order.txt这扇门，还能从hard.txt进去。
• 两扇门都删除后，房间才真正消失。

创建硬链接：

ln order.txt hard.txt

软链接

软链接相当于：

放一块路牌，写着"order.txt在那边"。

soft.txt路牌 → order.txt门 → 房间

创建软链接：

ln -s order.txt soft.txt

如果删除order.txt这扇门：

soft.txt路牌 → 找不到order.txt → 无法打开

所以软链接类似Windows快捷方式。

inode是什么

inode就是Linux给"房间"设置的内部编号。

你现在只需要知道：

• 硬链接：两个门通向同一个房间，所以inode相同。
• 软链接：它只是一块路牌，所以有自己的inode。

最重要的区别

复制：建造两个房间
硬链接：同一个房间开两扇门
软链接：放一块指路牌

实战

运行截图

命令解释

echo "牛肉面订单" > order.txt

创建order.txt，并把"牛肉面订单"写进去。

• echo：输出文字
• >：把文字写进文件
• order.txt：文件名

（注意：如果文件已经存在，>会覆盖原来的内容）

ln order.txt hard.txt

给order.txt创建一个硬链接，名字叫hard.txt。

可以理解为：

给同一个房间增加一扇叫hard.txt的门。

ln -s order.txt soft.txt

给order.txt创建一个软链接，名字叫soft.txt。

• ln：创建链接。
• -s：表示软链接。
• order.txt：被指向的文件。
• soft.txt：快捷方式的名字。

可以理解为：

创建一块叫soft.txt的路牌，指向order.txt。

rm order.txt

删除order.txt这个名字。

此时：

• hard.txt仍然可以进入原来的房间。

• soft.txt指向的order.txt已经不存在。

  cat hard.txt

查看hard.txt的内容。

结果仍然是：

牛肉面订单

因为硬链接是同一个文件的另一个入口。

cat soft.txt

通过软链接查看内容。

这时会报错，因为它指向的order.txt已经删除了。

最后清理

rm hard.txt

删除硬链接。删除后，真正的文件内容也会消失。

rm soft.txt

删除已经失效的软链接。

完整过程：

创建文件
→ 创建硬链接
→ 创建软链接
→ 删除原文件
→ 硬链接仍然可用
→ 软链接失效
→ 清理文件

四，vim编译器

Vim是什么

Vim是一个在终端里编辑文字的工具，类似"终端版记事本"。

打开订单：

vim order.txt

Vim为什么有三种模式

把Vim想成一个管理订单的员工，他有三种工作状态。

1. 普通模式：查看订单

刚打开Vim时，默认就是普通模式

这个状态下不能直接输入文字，主要用来：

• 移动光标。
• 删除。
• 复制。
• 粘贴。
• 撤销。

生活类比：

员工正在检查订单，还没有拿笔写字。

2. 编辑模式：填写订单

在普通模式下按：

a

就可以开始输入文字。

生活类比：

员工拿起笔，开始填写订单。

编辑完成后按：

Esc

返回普通模式。

3. 命令模式：保存或退出

先按Esc回到普通模式，然后输入：

:

屏幕底部会出现一个冒号，这时可以输入保存、退出等命令。

最重要的保存和退出

保存并退出：

:wq

然后按回车。

只保存：

:w

不保存，直接退出：

:q!

正常退出：

:q

（如果文件修改后没有保存，:q不会让你退出）

实例

运行截图

步骤

1，在终端输入：

vim order.txt

2，然后：

1. 按a
2. 输入（随便输）
3. 保存

按Esc

输入:wq

按回车

3，查看文件：

cat order.txt

4，清除

五，Linux C编程

截图样例

第一步：打开文件

终端输入：

vim hello.c

意思：用Vim打开一个叫hello.c的文件。

第二步：写程序

按i，然后输入：

#include <stdio.h>

int main()
{
    printf("Hello\n");
    return 0;
}

程序的意思：

• main：程序从这里开始。
• printf：在屏幕显示文字。
• return 0：程序正常结束。

按Esc，输入:wq，回车保存。

第三步：编译

gcc hello.c -o hello

意思：

GCC把hello.c翻译成一个叫hello的程序。

第四步：运行

./hello

结果：

Hello

五，make和makefile

先分清三个东西：

GCC：真正负责编译
Makefile：写着"怎么编译"的文本文件
make：读取Makefile并执行编译命令的软件

为什么需要它们

假设程序只有一个文件：

hello.c

可以手动编译：

gcc hello.c -o hello

但如果程序有很多文件：

main.c
add.c
sub.c
menu.c

每次都要输入：

gcc main.c add.c sub.c menu.c -o app

文件越多，命令越长，也容易写错。

所以我们把这条命令保存在一个叫Makefile的文件中

Makefile是什么

Makefile就是一张"编译说明书"

内容例如：

app: main.c add.c
	gcc main.c add.c -o app

第一行：

app: main.c add.c

意思是：

要生成app，需要main.c和add.c

第二行：

	gcc main.c add.c -o app

意思是：

使用这条GCC命令生成app

注意：第二行前面必须按一次Tab键

make是什么

终端输入：

make

make会做三件事：

1. 在当前文件夹寻找Makefile。
2. 阅读里面的编译规则。
3. 执行里面的GCC命令。

最终生成：

app

然后运行：

./app

为什么不直接使用GCC

直接使用GCC：

gcc main.c add.c -o app

每次都要自己输入完整命令。

使用make：

make

只需要输入一个单词，make会自动完成。

最简单的类比

假设要制作一份外卖套餐：

• main.c、add.c：做菜需要的材料。
• gcc：真正做菜的厨师。
• Makefile：写着做菜步骤的纸。
• make：拿着步骤安排厨师的店长。
• app：最后做好的外卖。

最重要的一句话：

Makefile保存编译方法，make读取Makefile，GCC真正完成编译。

Makefile最基本的格式

目标: 依赖
	命令

(注意：第三行"命令"前必须按一次Tab键,不过现在已经自动了）

目标：最后想得到什么
依赖：需要哪些原材料
命令：具体怎样制作

外卖类比：

牛肉面: 面条 牛肉
	厨师制作牛肉面

C程序的格式

程序名: 需要的C文件
	gcc 需要的C文件 -o 程序名

例如：

app: main.c add.c
	gcc main.c add.c -o app

解释：

• app：最终生成的程序。
• main.c add.c：生成程序需要的源文件。
• gcc...：真正执行的编译命令。

执行：

make

可以重复使用的模板

以后项目可以按照这个格式写：

TARGET = app
SRC = main.c add.c

$(TARGET): $(SRC)
	gcc $(SRC) -o $(TARGET)

clean:
	rm -f $(TARGET)

注意：gcc和rm前面都要按一次Tab。

解释：

TARGET：程序名称
SRC：所有C源文件
$(TARGET)：使用TARGET里面的内容
$(SRC)：使用SRC里面的内容

所以：

gcc $(SRC) -o $(TARGET)

实际相当于：

gcc main.c add.c -o app

编译：

make

删除编译出来的程序：

make clean

你只需要记住这个核心格式：

目标: 依赖
	命令

也就是：

我要生成什么：我需要什么；下一行写具体怎么生成。

六,makefile基本语法

1. 编译规则

固定格式：

目标: 依赖文件
	执行命令

例如：

app: main.c add.c
	gcc main.c add.c -o app

解释：

• app：想生成的程序。
• main.c add.c：生成程序需要的文件。
• gcc...：具体编译方法。

注意：gcc前面必须按一次Tab，不能用普通空格。

2. 定义变量

TARGET = app
SRC = main.c add.c
CC = gcc

使用变量：

$(TARGET)
$(SRC)
$(CC)

例如：

$(TARGET): $(SRC)
	$(CC) $(SRC) -o $(TARGET)

实际相当于：

gcc main.c add.c -o app

3. 注释

#后面是说明文字，不会执行：

# 编译程序

4. 清理规则

clean:
	rm -f app

执行：

make clean

作用：删除编译生成的程序。

完整基础模板

# 编译器
CC = gcc

# 最终程序名称
TARGET = app

# C源文件
SRC = main.c add.c

# 编译规则
$(TARGET): $(SRC)
	$(CC) $(SRC) -o $(TARGET)

# 清理规则
clean:
	rm -f $(TARGET)

使用：

make
./app
make clean

目标: 依赖
	命令

实例

1. 创建文件夹

mkdir make_demo
cd make_demo

2. 创建main.c

vim main.c

按i输入：

#include <stdio.h>

int add(int a, int b);

int main()
{
    printf("2+3=%d\n", add(2, 3));
    return 0;
}

按Esc，输入:wq保存退出。

3. 创建add.c

vim add.c

按i输入：

int add(int a, int b)
{
    return a + b;
}

保存退出。

4. 创建Makefile

vim Makefile

按i输入：

CC = gcc
TARGET = app
SRC = main.c add.c

$(TARGET): $(SRC)
	$(CC) $(SRC) -o $(TARGET)

clean:
	rm -f $(TARGET)

注意：$(CC)和rm前面必须按一次Tab键。

保存退出。

5. 自动编译

make

6. 运行程序

./app

结果：

2+3=5

7. 删除编译结果

make clean

这个实例中：

main.c + add.c：源文件
Makefile：记录编译规则
make：执行规则
app：生成的程序

运行截图

这里要注意修改文件后要重新make

七，shell脚本入门

1. Shell脚本是什么

把多条终端命令放进一个文件，以后一次执行。

Shell脚本 = 自动执行的命令清单

2. 基本格式

#!/bin/bash

命令1
命令2
命令3

• #!/bin/bash：告诉系统使用Bash执行。
• 脚本通常以.sh结尾。
• 命令从上到下执行。

3. read接收输入

read -p "请输入姓名：" name
echo "$name"

• read：等待用户输入。
• name：保存输入内容。
• $name：取出内容。

4. 整数计算

result=$((10 + 20))

Shell整数计算使用：

$((表达式))

5. test和[ ]判断

判断文件是否存在：

test -f order.txt

也可以写成：

[ -f order.txt ]

注意：中括号里面必须留空格。

常用判断：

-f：普通文件是否存在
-d：文件夹是否存在
-e：文件或文件夹是否存在
= ：字符串相同
!=：字符串不同

6. &&和||

命令1 && 命令2

命令1成功，才执行命令2。

命令1 || 命令2

命令1失败，才执行命令2。

记忆：

&&：成功后继续
||：失败后处理

7. 脚本参数

运行：

bash shop.sh 牛肉面 加辣

脚本中：

$0：脚本名shop.sh
$1：牛肉面
$2：加辣
$#：参数数量，这里是2
$@：全部参数

标准模板

#!/bin/bash

# 接收用户输入
read -p "请输入内容：" value

# 整数计算
result=$((10 + 20))

# 判断文件
test -f "$1" && echo "文件存在" || echo "文件不存在"

# 显示输入和结果
echo "输入内容：$value"
echo "计算结果：$result"

# 显示脚本参数
echo "脚本名称：$0"
echo "第一个参数：$1"
echo "参数数量：$#"
echo "全部参数：$@"

这节课最核心的是：

Shell脚本把多条命令放进一个文件；read接收输入，$(( ))计算，test判断，&&和||根据成功或失败选择是否继续。

Shell脚本知识点总结

1. Shell脚本

   把多条终端命令写进一个文件，一次运行。

2. 基本格式

   #!/bin/bash

   命令从上到下执行，文件通常以.sh结尾。

3. read

   接收用户输入，并保存到变量。

4. 变量

   name="小明"
   echo "$name"

   保存变量时不用$，使用变量时加$。

5. 整数计算

   result=$((10 + 20))

6. test或[ ]

   用于判断文件、数字和字符串。

   test -f order.txt
   [ -f order.txt ]

7. &&和||

   • &&：前面成功，执行后面。
   • ||：前面失败，执行后面。

8. 脚本参数

   • $0：脚本名称。
   • $1、$2：第一个、第二个参数。
   • $#：参数数量。
   • $@：全部参数。

核心一句话：

Shell脚本就是自动执行多条命令，并且可以接收输入、计算、判断和使用参数。

实例

下面做一个"外卖订单"Shell脚本。

1. 创建脚本

vim shop.sh

按i，输入：

#!/bin/bash

food="$1"
price="$2"

read -p "请输入购买数量：" count

total=$((price * count))

echo "商品：$food"
echo "数量：$count"
echo "总价：$total 元"

echo "商品：$food，数量：$count，总价：$total 元" > order.txt

test -f order.txt && echo "订单创建成功" || echo "订单创建失败"

echo "脚本名称：$0"
echo "参数数量：$#"
echo "全部参数：$@"

逐行解释

#!/bin/bash

告诉Linux：使用Bash执行这个脚本。

food="$1"

把运行脚本时的第一个参数保存到food。

例如：

bash shop.sh 牛肉面 15

这里$1就是"牛肉面"。

price="$2"

把第二个参数保存到price。这里$2就是15。

不可有空格

read -p "请输入购买数量：" count

显示提示，等待用户输入数量，并保存到count。

total=$((price * count))

计算：

单价 × 数量

结果保存到total。

echo "商品：$food"

显示商品名称。

echo "数量：$count"

显示购买数量。

echo "总价：$total 元"

显示计算后的总价。

echo "商品：$food，数量：$count，总价：$total 元" > order.txt

把订单内容写入order.txt。

>表示覆盖写入文件。

test -f order.txt && echo "订单创建成功" || echo "订单创建失败"

检查order.txt是否存在：

• 存在：显示"订单创建成功"。

• 不存在：显示"订单创建失败"。

  echo "脚本名称：$0"

显示脚本名称，例如shop.sh。

echo "参数数量：$#"

显示参数数量。这里是2个参数。

echo "全部参数：$@"

显示全部参数：

牛肉面 15

完整过程：

接收商品和单价
→ 询问数量
→ 计算总价
→ 保存订单
→ 检查订单
→ 显示参数信息

13:18

按Esc，输入:wq，回车保存。

2. 运行脚本

bash shop.sh 牛肉面 15

根据提示输入：

2

结果：

商品：牛肉面
数量：2
总价：30 元
订单创建成功
脚本名称：shop.sh
参数数量：2
全部参数：牛肉面 15

运行截图

zyy@zyy-VMware-Virtual-Platform:~$ vim shop.sh

zyy@zyy-VMware-Virtual-Platform:~$ bash shop.sh 牛肉面 15

请输入购买数量2

商品：牛肉面

数量: 2

总价: 30元

订单创建成功

脚本名称：shop.sh

参数数量：2

全部参数：牛肉面 15

八，shell脚本条件判断，函数和循环

1. if判断

C语言：

if (age >= 18) {
    printf("成年");
} else {
    printf("未成年");
}

Shell：

if [ "$age" -ge 18 ]; then
    echo "成年"
else
    echo "未成年"
fi

对应关系：

C的{ }       → Shell的then、else、fi
C的printf    → Shell的echo
C的>=        → Shell的-ge

易错点：

• [ "$age" -ge 18 ]里面必须有空格。
• Shell的if最后写fi。
• 数字不能直接使用>判断。

2. case多选

C语言的switch：

switch (num) {
case 1:
    break;
}

Shell对应case：

case "$num" in
    1)
        echo "牛肉面"
        ;;
    *)
        echo "没有这个选项"
        ;;
esac

易错点：

• C使用break，Shell使用;;。
• Shell的case最后写esac。
• *相当于C语言的default。

3. 函数

C语言：

void show()
{
    printf("完成");
}

Shell：

show()
{
    echo "完成"
}

调用：

show

易错点：

• Shell调用函数时不写()。
• Shell命令结尾通常不需要分号。

4. while循环

C语言：

while (i < 3) {
    i++;
}

Shell：

while [ "$i" -lt 3 ]; do
    i=$((i + 1))
done

易错点：

• while最后写done。
• 必须修改i，否则会死循环。

5. for循环

Shell也支持类似C语言的写法：

for ((i=0; i<3; i++)); do
    echo "$i"
done

易错点：

• Shell使用do开始循环内容。
• 使用done结束，不使用}。

最重要的对照

C语言的{ }        → Shell的then/fi或do/done
switch            → case
break             → ;;
printf             → echo
>=                 → -ge
<=                 → -le
==                 → -eq

一句话记忆：

逻辑和C语言一样，只是Shell用fi结束if，用done结束循环。

实例

命令解释

#!/bin/bash

使用Bash执行这个脚本。

show_menu()

定义一个叫show_menu的函数。

{

函数内容开始，类似C语言的{。

echo "1. 牛肉面：15元"

显示第一种商品。

echo "2. 炒饭：12元"

显示第二种商品。

}

函数定义结束。

show_menu

调用函数，显示菜单。Shell调用函数时不写()。

read -p "请选择商品：" choice

等待用户输入，并把内容保存到choice。

case "$choice" in

根据用户输入的choice进行选择，类似C语言的switch。

1)

如果用户输入1。

food="牛肉面"

把商品名称保存到food。

price=15

把价格15保存到price。

;;

这个选项结束，类似C语言的break。

2)

如果用户输入2。

food="炒饭"
price=12

保存商品名称和价格。

*)

*表示除1和2之外的其他输入，类似C语言的default。

echo "没有这个商品"

显示错误提示。

exit 1

结束脚本。1表示脚本因为错误而结束。

;;

当前选项结束。

esac

整个case结束。

read -p "请输入数量：" count

让用户输入购买数量，保存到count。

while [ "$count" -le 0 ]; do

只要数量小于或等于0，就一直循环。

• -le：小于或等于。

• do：循环内容开始。

  read -p "数量必须大于0，请重新输入：" count

让用户重新输入数量。

done

while循环结束。

total=$((price * count))

计算：

价格 × 数量

把结果保存到total。

read -p "请输入你的余额：" money

让用户输入余额，保存到money。

if [ "$money" -ge "$total" ]; then

判断余额是否大于或等于总价。

• -ge：大于或等于。

• then：条件成立后执行。

  echo "付款成功，总价：$total 元"

余额足够，显示付款成功。

for ((i=1; i<=count; i++)); do

从1开始循环，每次增加1，一共循环count次。

echo "正在打包第$i份$food"

显示当前正在打包第几份外卖。

done

for循环结束。

else

余额不足时执行下面的内容。

echo "余额不足"

显示余额不足。

fi

整个if判断结束。

整体过程：

显示菜单
→ 选择商品
→ 输入数量
→ 计算总价
→ 输入余额
→ 判断能否付款
→ 重复打包外卖

运行截图

zyy@zyy-VMware-Virtual-Platform:~$ vim shop.sh

zyy@zyy-VMware-Virtual-Platform:~$ bash shop.sh

1. 牛肉面：15元

2. 炒饭：12元

请选择商品：