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元
请选择商品：