# Linux 常用命令详解

## 目录
1. [文件和目录操作](#文件和目录操作)
2. [文本处理命令](#文本处理命令)
3. [系统信息和进程管理](#系统信息和进程管理)
4. [网络命令](#网络命令)
5. [权限和用户管理](#权限和用户管理)
6. [压缩和归档](#压缩和归档)
7. [查找和搜索](#查找和搜索)
8. [系统监控](#系统监控)

---

## 文件和目录操作

### ls - 列出目录内容

**基本语法：** `ls [选项] [目录]`

**常用选项：**
- `-l` 详细信息（长格式）
- `-a` 显示隐藏文件
- `-h` 人类可读的文件大小
- `-t` 按修改时间排序
- `-r` 反向排序
- `-R` 递归显示子目录

**实例：**
```bash
# 基本用法
ls
# 输出：Documents Downloads Music Pictures Videos

# 详细信息显示
ls -l
# 输出：
# drwxr-xr-x 2 user user 4096 Dec 24 10:30 Documents
# drwxr-xr-x 2 user user 4096 Dec 24 09:15 Downloads
# -rw-r--r-- 1 user user 1024 Dec 24 08:45 readme.txt

# 显示所有文件（包括隐藏文件）
ls -la
# 输出：
# total 24
# drwxr-xr-x 3 user user 4096 Dec 24 10:30 .
# drwxr-xr-x 3 root root 4096 Dec 23 15:20 ..
# -rw------- 1 user user  220 Dec 23 15:20 .bash_logout
# -rw------- 1 user user 3771 Dec 23 15:20 .bashrc

# 按大小排序，人类可读格式
ls -lhS
# 输出：
# -rw-r--r-- 1 user user 2.1M Dec 24 10:30 large_file.zip
# -rw-r--r-- 1 user user 512K Dec 24 09:15 medium_file.pdf
# -rw-r--r-- 1 user user 1.0K Dec 24 08:45 small_file.txt
```

### cd - 切换目录

**基本语法：** `cd [目录路径]`

**特殊符号：**
- `~` 用户主目录
- `-` 上一个目录
- `..` 父目录
- `.` 当前目录

**实例：**
```bash
# 切换到用户主目录
cd ~
pwd
# 输出：/home/username

# 切换到根目录
cd /
pwd
# 输出：/

# 切换到上级目录
cd ..
pwd
# 输出：/

# 切换到上一个目录
cd /home/username/Documents
cd /tmp
cd -
pwd
# 输出：/home/username/Documents

# 使用相对路径
cd ./subfolder/another_folder
```

### mkdir - 创建目录

**基本语法：** `mkdir [选项] 目录名`

**常用选项：**
- `-p` 创建多级目录
- `-m` 设置权限模式

**实例：**
```bash
# 创建单个目录
mkdir new_folder

# 创建多级目录
mkdir -p project/src/components/ui
# 创建了：project/src/components/ui 整个路径

# 创建多个目录
mkdir folder1 folder2 folder3

# 创建目录并设置权限
mkdir -m 755 public_folder
mkdir -m 700 private_folder

# 验证创建结果
ls -la
# 输出：
# drwxr-xr-x 2 user user 4096 Dec 24 11:00 public_folder
# drwx------ 2 user user 4096 Dec 24 11:00 private_folder
```

### cp - 复制文件和目录

**基本语法：** `cp [选项] 源文件 目标文件`

**常用选项：**
- `-r` 递归复制目录
- `-i` 交互式复制（覆盖前询问）
- `-v` 显示详细过程
- `-a` 保持所有属性

**实例：**
```bash
# 复制文件
cp file1.txt file2.txt

# 复制文件到目录
cp file1.txt /home/user/backup/

# 递归复制目录
cp -r source_folder/ destination_folder/

# 交互式复制（防止意外覆盖）
cp -i important.txt backup_important.txt
# 输出：cp: overwrite 'backup_important.txt'? y

# 保持所有属性复制
cp -a original_folder/ backup_folder/

# 复制多个文件到目录
cp file1.txt file2.txt file3.txt /backup/
```

### mv - 移动/重命名文件和目录

**基本语法：** `mv [选项] 源文件 目标文件`

**常用选项：**
- `-i` 交互式移动
- `-v` 显示详细过程
- `-u` 只在源文件更新时移动

**实例：**
```bash
# 重命名文件
mv oldname.txt newname.txt

# 移动文件到目录
mv file.txt /home/user/documents/

# 移动并重命名
mv old_file.txt /new/location/new_name.txt

# 移动目录
mv old_folder/ /new/location/

# 批量移动文件
mv *.txt /text_files/

# 交互式移动
mv -i file.txt existing_file.txt
# 输出：mv: overwrite 'existing_file.txt'? n
```

### rm - 删除文件和目录

**基本语法：** `rm [选项] 文件名`

**常用选项：**
- `-r` 递归删除目录
- `-f` 强制删除，不询问
- `-i` 交互式删除
- `-v` 显示详细过程

**实例：**
```bash
# 删除文件
rm file.txt

# 交互式删除
rm -i important.txt
# 输出：rm: remove regular file 'important.txt'? y

# 删除目录及其内容
rm -r folder/

# 强制删除（危险操作）
rm -rf unwanted_folder/

# 删除特定类型文件
rm *.tmp
rm -f *.log

# 显示删除过程
rm -v file1.txt file2.txt
# 输出：
# removed 'file1.txt'
# removed 'file2.txt'
```

---

## 文本处理命令

### cat - 显示文件内容

**基本语法：** `cat [选项] 文件名`

**常用选项：**
- `-n` 显示行号
- `-b` 显示非空行行号
- `-s` 压缩空行
- `-A` 显示所有字符

**实例：**
```bash
# 创建示例文件
echo -e "第一行\n\n第三行\n第四行" > sample.txt

# 基本显示
cat sample.txt
# 输出：
# 第一行
# 
# 第三行
# 第四行

# 显示行号
cat -n sample.txt
# 输出：
#      1	第一行
#      2	
#      3	第三行
#      4	第四行

# 只显示非空行号
cat -b sample.txt
# 输出：
#      1	第一行
# 
#      2	第三行
#      3	第四行

# 连接多个文件
cat file1.txt file2.txt > combined.txt

# 创建文件（Ctrl+D结束输入）
cat > newfile.txt
# 输入内容后按Ctrl+D保存
```

### grep - 文本搜索

**基本语法：** `grep [选项] 模式 文件名`

**常用选项：**
- `-i` 忽略大小写
- `-v` 反向匹配（不包含）
- `-n` 显示行号
- `-r` 递归搜索
- `-c` 只显示匹配行数

**实例：**
```bash
# 创建示例文件
cat > employees.txt << EOF
John Smith, Manager, 50000
Jane Doe, Developer, 45000
Bob Johnson, Manager, 55000
Alice Brown, Designer, 40000
Mike Wilson, Developer, 48000
EOF

# 基本搜索
grep "Manager" employees.txt
# 输出：
# John Smith, Manager, 50000
# Bob Johnson, Manager, 55000

# 忽略大小写搜索
grep -i "manager" employees.txt
# 同上输出

# 显示行号
grep -n "Developer" employees.txt
# 输出：
# 2:Jane Doe, Developer, 45000
# 5:Mike Wilson, Developer, 48000

# 反向匹配
grep -v "Manager" employees.txt
# 输出：
# Jane Doe, Developer, 45000
# Alice Brown, Designer, 40000
# Mike Wilson, Developer, 48000

# 计算匹配行数
grep -c "Developer" employees.txt
# 输出：2

# 使用正则表达式
grep "^[JM]" employees.txt  # 以J或M开头的行
# 输出：
# John Smith, Manager, 50000
# Mike Wilson, Developer, 48000

# 递归搜索目录
grep -r "function" /path/to/code/
```

### sed - 流编辑器

**基本语法：** `sed [选项] '命令' 文件名`

**常用命令：**
- `s/old/new/` 替换
- `d` 删除行
- `p` 打印行
- `a` 追加行

**实例：**
```bash
# 创建示例文件
cat > data.txt << EOF
Hello World
This is line 2
Hello Universe
This is line 4
EOF

# 基本替换（只替换每行第一个）
sed 's/Hello/Hi/' data.txt
# 输出：
# Hi World
# This is line 2
# Hi Universe
# This is line 4

# 全局替换
sed 's/is/was/g' data.txt
# 输出：
# Hello World
# Thwas was line 2
# Hello Universe
# Thwas was line 4

# 删除包含特定文本的行
sed '/line 2/d' data.txt
# 输出：
# Hello World
# Hello Universe
# This is line 4

# 打印特定行
sed -n '2,3p' data.txt
# 输出：
# This is line 2
# Hello Universe

# 在特定行后添加内容
sed '2a\This is an added line' data.txt
# 输出：
# Hello World
# This is line 2
# This is an added line
# Hello Universe
# This is line 4

# 直接修改文件
sed -i 's/Hello/Hi/g' data.txt
```

### awk - 文本处理工具

**基本语法：** `awk 'pattern { action }' 文件名`

**内置变量：**
- `NR` 当前行号
- `NF` 当前行字段数
- `$0` 整行内容
- `$1,$2,...` 各字段内容

**实例：**
```bash
# 创建示例数据
cat > sales.txt << EOF
Product Price Quantity
Apple 1.20 100
Banana 0.80 150
Orange 1.50 80
Grape 2.00 60
EOF

# 打印所有行
awk '{print}' sales.txt
# 或
awk '{print $0}' sales.txt

# 打印特定字段
awk '{print $1, $2}' sales.txt
# 输出：
# Product Price
# Apple 1.20
# Banana 0.80
# Orange 1.50
# Grape 2.00

# 计算总价
awk 'NR>1 {total += $2 * $3} END {print "Total:", total}' sales.txt
# 输出：Total: 440

# 添加条件
awk 'NR>1 && $2 > 1.00 {print $1, "is expensive"}' sales.txt
# 输出：
# Apple is expensive
# Orange is expensive
# Grape is expensive

# 格式化输出
awk 'NR>1 {printf "%-10s $%.2f\n", $1, $2}' sales.txt
# 输出：
# Apple      $1.20
# Banana     $0.80
# Orange     $1.50
# Grape      $2.00

# 统计行数和字段数
awk 'END {print "Lines:", NR, "Max fields:", NF}' sales.txt
# 输出：Lines: 5 Max fields: 3
```

### sort - 排序文本

**基本语法：** `sort [选项] 文件名`

**常用选项：**
- `-n` 数字排序
- `-r` 反向排序
- `-k` 指定字段排序
- `-u` 去重排序
- `-t` 指定分隔符

**实例：**
```bash
# 创建示例数据
cat > students.txt << EOF
Alice,85,Math
Bob,92,Physics
Charlie,78,Math
David,95,Physics
Eve,88,Chemistry
EOF

# 基本排序（按字母顺序）
sort students.txt
# 输出：
# Alice,85,Math
# Bob,92,Physics
# Charlie,78,Math
# David,95,Physics
# Eve,88,Chemistry

# 按第二字段（分数）数字排序
sort -t',' -k2 -n students.txt
# 输出：
# Charlie,78,Math
# Alice,85,Math
# Eve,88,Chemistry
# Bob,92,Physics
# David,95,Physics

# 反向排序（分数从高到低）
sort -t',' -k2 -nr students.txt
# 输出：
# David,95,Physics
# Bob,92,Physics
# Eve,88,Chemistry
# Alice,85,Math
# Charlie,78,Math

# 按学科排序，再按分数排序
sort -t',' -k3,3 -k2,2n students.txt
# 输出：
# Eve,88,Chemistry
# Alice,85,Math
# Charlie,78,Math
# Bob,92,Physics
# David,95,Physics
```

---

## 系统信息和进程管理

### ps - 显示进程信息

**基本语法：** `ps [选项]`

**常用选项：**
- `aux` 显示所有进程详细信息
- `-ef` 显示所有进程完整信息
- `-u` 按用户显示
- `--forest` 树形显示

**实例：**
```bash
# 显示当前用户进程
ps
# 输出：
#   PID TTY          TIME CMD
#  1234 pts/0    00:00:01 bash
#  5678 pts/0    00:00:00 ps

# 显示所有进程详细信息
ps aux | head -10
# 输出：
# USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
# root         1  0.0  0.1  77616  8968 ?        Ss   Dec23   0:02 /sbin/init
# root         2  0.0  0.0      0     0 ?        S    Dec23   0:00 [kthreadd]
# root         3  0.0  0.0      0     0 ?        I<   Dec23   0:00 [rcu_gp]

# 查找特定进程
ps aux | grep firefox
# 输出：
# user     12345  2.1  5.4 2547696 437184 ?      Sl   10:30   1:23 /usr/bin/firefox

# 按CPU使用率排序
ps aux --sort=-%cpu | head -5
# 输出：显示CPU使用率最高的5个进程

# 按内存使用排序
ps aux --sort=-%mem | head -5
# 输出：显示内存使用最高的5个进程

# 显示进程树
ps --forest
# 输出：
#   PID TTY          TIME CMD
#  1234 pts/0    00:00:01 bash
#  5678 pts/0    00:00:00  \_ ps
```

### top - 动态显示进程

**基本语法：** `top [选项]`

**交互命令：**
- `q` 退出
- `k` 终止进程
- `M` 按内存排序
- `P` 按CPU排序
- `1` 显示所有CPU核心

**实例：**
```bash
# 基本使用
top

# 输出示例：
# top - 14:30:25 up 1 day,  3:45,  2 users,  load average: 0.15, 0.10, 0.05
# Tasks: 234 total,   1 running, 233 sleeping,   0 stopped,   0 zombie
# %Cpu(s):  2.3 us,  1.0 sy,  0.0 ni, 96.4 id,  0.3 wa,  0.0 hi,  0.0 si,  0.0 st
# MiB Mem :   7936.2 total,   2148.5 free,   3421.8 used,   2365.9 buff/cache
# MiB Swap:   2048.0 total,   2048.0 free,      0.0 used.   4102.5 avail Mem

#   PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
#  1234 user      20   0 2547696 437184 123456 S   5.3   5.4   1:23.45 firefox
#  5678 user      20   0  987654 234567  98765 S   2.1   2.9   0:45.12 chrome

# 只显示特定用户的进程
top -u username

# 设置刷新间隔（秒）
top -d 2

# 显示指定进程
top -p 1234,5678
```

### htop - 改进的top命令

**基本语法：** `htop [选项]`

**交互键：**
- `F1` 帮助
- `F2` 设置
- `F3` 搜索
- `F4` 过滤
- `F5` 树形视图
- `F6` 排序
- `F9` 终止进程
- `F10` 退出

**实例：**
```bash
# 基本使用（需要先安装：sudo apt install htop）
htop

# htop界面显示：
# - CPU使用率条形图
# - 内存和交换空间使用率
# - 进程列表，支持颜色和交互操作
# - 可以用鼠标操作

# 命令行选项
htop -u username  # 只显示指定用户进程
htop -d 10        # 设置刷新间隔
```

### kill - 终止进程

**基本语法：** `kill [选项] PID`

**常用信号：**
- `-9` SIGKILL（强制终止）
- `-15` SIGTERM（正常终止，默认）
- `-1` SIGHUP（重新加载配置）
- `-2` SIGINT（中断，Ctrl+C）

**实例：**
```bash
# 查找要终止的进程
ps aux | grep firefox
# 输出：user     12345  2.1  5.4 2547696 437184 ?      Sl   10:30   1:23 firefox

# 正常终止进程
kill 12345

# 强制终止进程
kill -9 12345

# 按进程名终止
killall firefox

# 终止多个进程
kill 12345 67890 13579

# 发送特定信号
kill -HUP 12345  # 重新加载配置

# 显示所有可用信号
kill -l
# 输出：
#  1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL
#  5) SIGTRAP      6) SIGABRT      7) SIGBUS       8) SIGFPE
#  9) SIGKILL     10) SIGUSR1     11) SIGSEGV     12) SIGUSR2
```

### jobs - 作业控制

**基本语法：** `jobs [选项]`

**相关命令：**
- `bg` 将作业放到后台
- `fg` 将作业调到前台
- `nohup` 不挂断运行

**实例：**
```bash
# 启动后台作业
sleep 300 &
# 输出：[1] 12345

# 查看作业状态
jobs
# 输出：[1]+  Running                 sleep 300 &

# 暂停当前作业（Ctrl+Z）
vim large_file.txt
# 按Ctrl+Z暂停
# 输出：[2]+  Stopped                 vim large_file.txt

# 查看所有作业
jobs
# 输出：
# [1]-  Running                 sleep 300 &
# [2]+  Stopped                 vim large_file.txt

# 将作业调到前台
fg %2
# vim回到前台

# 将停止的作业放到后台运行
bg %2

# 使用nohup运行不挂断命令
nohup long_running_script.sh &
# 输出：nohup: ignoring input and appending output to 'nohup.out'
```

---

## 网络命令

### ping - 测试网络连通性

**基本语法：** `ping [选项] 目标主机`

**常用选项：**
- `-c` 指定ping次数
- `-i` 指定间隔时间
- `-s` 指定数据包大小
- `-t` 设置TTL值

**实例：**
```bash
# 基本ping测试
ping google.com
# 输出：
# PING google.com (172.217.160.142) 56(84) bytes of data.
# 64 bytes from lga25s62-in-f14.1e100.net (172.217.160.142): icmp_seq=1 ttl=117 time=12.3 ms
# 64 bytes from lga25s62-in-f14.1e100.net (172.217.160.142): icmp_seq=2 ttl=117 time=11.8 ms

# 指定ping次数
ping -c 3 google.com
# 输出：发送3个包后停止

# 设置包大小
ping -s 1000 google.com
# 输出：发送1000字节的数据包

# 设置间隔时间
ping -i 2 google.com
# 输出：每2秒发送一个包

# ping本地回环
ping localhost
# 或
ping 127.0.0.1
# 输出：
# PING localhost (127.0.0.1) 56(84) bytes of data.
# 64 bytes from localhost (127.0.0.1): icmp_seq=1 ttl=64 time=0.045 ms

# 统计信息
ping -c 5 google.com
# 最终输出统计：
# --- google.com ping statistics ---
# 5 packets transmitted, 5 received, 0% packet loss, time 4006ms
# rtt min/avg/max/mdev = 11.234/12.567/13.890/0.892 ms
```

### wget - 下载文件

**基本语法：** `wget [选项] URL`

**常用选项：**
- `-O` 指定输出文件名
- `-c` 断点续传
- `-r` 递归下载
- `-P` 指定下载目录
- `--limit-rate` 限制下载速度

**实例：**
```bash
# 基本下载
wget https://example.com/file.zip
# 输出：
# --2023-12-24 14:30:25--  https://example.com/file.zip
# Resolving example.com (example.com)... 93.184.216.34
# Connecting to example.com (example.com)|93.184.216.34|:443... connected.
# HTTP request sent, awaiting response... 200 OK
# Length: 1048576 (1.0M) [application/zip]
# Saving to: 'file.zip'
# file.zip         100%[==============>]   1.00M  2.34MB/s    in 0.4s

# 指定输出文件名
wget -O myfile.zip https://example.com/file.zip

# 断点续传
wget -c https://example.com/largefile.iso

# 后台下载
wget -b https://example.com/largefile.iso
# 输出：Continuing in background, pid 12345.

# 限制下载速度
wget --limit-rate=200k https://example.com/file.zip

# 下载整个网站（谨慎使用）
wget -r -np -k https://example.com/

# 设置用户代理
wget --user-agent="Mozilla/5.0" https://example.com/file.zip

# 设置重试次数
wget --tries=3 https://example.com/file.zip
```

### curl - 数据传输工具

**基本语法：** `curl [选项] URL`

**常用选项：**
- `-o` 输出到文件
- `-O` 使用远程文件名
- `-L` 跟随重定向
- `-H` 添加请求头
- `-d` 发送POST数据

**实例：**
```bash
# 基本GET请求
curl https://api.github.com/users/octocat
# 输出：JSON格式的用户信息

# 保存到文件
curl -o user.json https://api.github.com/users/octocat

# 使用原文件名保存
curl -O https://example.com/file.zip

# 跟随重定向
curl -L https://github.com

# 显示详细信息
curl -v https://httpbin.org/get
# 输出：
# * Trying 54.175.219.8:443...
# * Connected to httpbin.org (54.175.219.8) port 443 (#0)
# * ALPN, offering h2
# * ALPN, offering http/1.1
# > GET /get HTTP/1.1
# > Host: httpbin.org
# > User-Agent: curl/7.68.0
# > Accept: */*

# POST请求发送JSON数据
curl -X POST -H "Content-Type: application/json" \
     -d '{"name":"John","age":30}' \
     https://httpbin.org/post

# 上传文件
curl -X POST -F "file=@/path/to/file.txt" https://httpbin.org/post

# 设置请求头
curl -H "Authorization: Bearer token123" \
     -H "Accept: application/json" \
     https://api.example.com/data

# 测试网站响应时间
curl -w "Total time: %{time_total}s\n" -o /dev/null -s https://google.com
# 输出：Total time: 0.123456s
```

### netstat - 显示网络连接

**基本语法：** `netstat [选项]`

**常用选项：**
- `-a` 显示所有连接
- `-t` 显示TCP连接
- `-u` 显示UDP连接
- `-l` 只显示监听端口
- `-n` 显示数字地址
- `-p` 显示进程信息

**实例：**
```bash
# 显示所有网络连接
netstat -a | head -10
# 输出：
# Active Internet connections (servers and established)
# Proto Recv-Q Send-Q Local Address           Foreign Address         State
# tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN
# tcp        0      0 127.0.0.1:631           0.0.0.0:*               LISTEN

# 显示监听端口
netstat -tlnp
# 输出：
# Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
# tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      1234/sshd
# tcp        0      0 127.0.0.1:3306          0.0.0.0:*               LISTEN      5678/mysqld

# 显示TCP连接状态统计
netstat -st
# 输出：
# Tcp:
#     12345 active connections openings
#     67890 passive connection openings
#     123 failed connection attempts

# 查看特定端口
netstat -tlnp | grep :80
# 输出：tcp    0    0 0.0.0.0:80    0.0.0.0:*    LISTEN    9876/apache2

# 显示路由表
netstat -rn
# 输出：
# Kernel IP routing table
# Destination     Gateway         Genmask         Flags   MSS Window  irtt Iface
# 0.0.0.0         192.168.1.1     0.0.0.0         UG        0 0          0 eth0
# 192.168.1.0     0.0.0.0         255.255.255.0   U         0 0          0 eth0
```

### ss - Socket Statistics

**基本语法：** `ss [选项]`

**常用选项：**
- `-a` 显示所有socket
- `-t` 显示TCP socket
- `-u` 显示UDP socket
- `-l` 显示监听状态
- `-n` 不解析服务名
- `-p` 显示进程信息

**实例：**
```bash
# 显示所有TCP连接
ss -t
# 输出：
# State    Recv-Q    Send-Q       Local Address:Port       Peer Address:Port
# ESTAB    0         0            192.168.1.100:22         192.168.1.10:12345

# 显示监听端口
ss -tlnp
# 输出：
# State    Recv-Q    Send-Q    Local Address:Port    Peer Address:Port    Process
# LISTEN   0         128       0.0.0.0:22           0.0.0.0:*            users:(("sshd",pid=1234,fd=3))
# LISTEN   0         80        127.0.0.1:3306       0.0.0.0:*            users:(("mysqld",pid=5678,fd=10))

# 显示特定端口的连接
ss -tlnp sport = :80
# 或
ss -tlnp | grep :80

# 显示连接统计
ss -s
# 输出：
# Total: 234 (kernel 456)
# TCP:   12 (estab 3, closed 5, orphaned 0, synrecv 0, timewait 4/0), ports 0
# Transport Total     IP        IPv6
# *         456       -         -
# RAW       0         0         0
# UDP       8         5         3
# TCP       7         4         3

# 按状态过滤
ss -t state established
ss -t state listening
```

---

## 权限和用户管理

### chmod - 修改文件权限

**基本语法：** `chmod [选项] 权限 文件名`

**权限表示方法：**
- 数字方式：读(4) + 写(2) + 执行(1)
- 字符方式：r(读) w(写) x(执行)
- 用户类别：u(所有者) g(组) o(其他) a(所有)

**实例：**
```bash
# 创建测试文件
echo "Hello World" > test.txt
ls -l test.txt
# 输出：-rw-r--r-- 1 user user 12 Dec 24 15:00 test.txt

# 数字方式设置权限
chmod 755 test.txt
ls -l test.txt
# 输出：-rwxr-xr-x 1 user user 12 Dec 24 15:00 test.txt

# 字符方式添加执行权限
chmod +x test.txt
ls -l test.txt
# 输出：-rwxr-xr-x 1 user user 12 Dec 24 15:00 test.txt

# 为所有者添加写权限
chmod u+w test.txt

# 为组和其他用户移除写权限
chmod go-w test.txt

# 设置精确权限
chmod u=rwx,g=rx,o=r test.txt
ls -l test.txt
# 输出：-rwxr-xr-- 1 user user 12 Dec 24 15:00 test.txt

# 递归修改目录权限
mkdir -p test_dir/subdir
chmod -R 755 test_dir/
ls -la test_dir/
# 输出：
# total 8
# drwxr-xr-x 3 user user 4096 Dec 24 15:01 .
# drwxr-xr-x 3 user user 4096 Dec 24 15:01 ..
# drwxr-xr-x 2 user user 4096 Dec 24 15:01 subdir

# 常用权限组合
chmod 644 document.txt    # 文件：所有者读写，其他只读
chmod 755 script.sh      # 脚本：所有者全权限，其他读执行
chmod 700 private_dir/   # 目录：只有所有者可访问
chmod 666 shared.txt     # 文件：所有人读写
```

### chown - 修改文件所有者

**基本语法：** `chown [选项] 所有者[:组] 文件名`

**常用选项：**
- `-R` 递归修改
- `-v` 显示详细过程
- `--reference` 参考其他文件

**实例：**
```bash
# 创建测试文件
echo "test" > ownership_test.txt
ls -l ownership_test.txt
# 输出：-rw-r--r-- 1 user user 5 Dec 24 15:05 ownership_test.txt

# 修改所有者（需要sudo权限）
sudo chown root ownership_test.txt
ls -l ownership_test.txt
# 输出：-rw-r--r-- 1 root user 5 Dec 24 15:05 ownership_test.txt

# 同时修改所有者和组
sudo chown root:root ownership_test.txt
ls -l ownership_test.txt
# 输出：-rw-r--r-- 1 root root 5 Dec 24 15:05 ownership_test.txt

# 只修改组
sudo chown :user ownership_test.txt
ls -l ownership_test.txt
# 输出：-rw-r--r-- 1 root user 5 Dec 24 15:05 ownership_test.txt

# 递归修改目录
sudo mkdir -p /tmp/test_ownership/subdir
sudo chown -R user:user /tmp/test_ownership/
ls -la /tmp/test_ownership/
# 输出：所有文件和子目录的所有者都变为user

# 参考其他文件的所有权
sudo chown --reference=/home/user/reference.txt target.txt

# 显示详细过程
sudo chown -v user:group file.txt
# 输出：changed ownership of 'file.txt' from root:root to user:group
```

### su - 切换用户

**基本语法：** `su [选项] [用户名]`

**常用选项：**
- `-` 或 `-l` 完全切换用户环境
- `-c` 执行单个命令
- `-s` 指定shell

**实例：**
```bash
# 切换到root用户
su -
# 输入root密码后：
# root@hostname:~#

# 切换到指定用户
su username
# 输入username的密码

# 完全切换用户环境
su - username
# 这会加载用户的环境变量和工作目录

# 以其他用户身份执行命令
su -c "ls -la /root/" root
# 输入root密码后执行ls命令

# 查看当前用户
whoami
# 输出：current_username

# 查看用户ID信息
id
# 输出：uid=1000(user) gid=1000(user) groups=1000(user),4(adm),24(cdrom),27(sudo)

# 查看登录用户
who
# 输出：
# user     pts/0        2023-12-24 14:30 (192.168.1.10)
# admin    pts/1        2023-12-24 15:00 (192.168.1.20)

# 查看系统登录历史
last | head -5
# 输出：
# user     pts/0        192.168.1.10     Sun Dec 24 14:30   still logged in
# user     pts/0        192.168.1.10     Sun Dec 24 10:15 - 14:25  (04:10)
```

### sudo - 以超级用户执行命令

**基本语法：** `sudo [选项] 命令`

**常用选项：**
- `-u` 指定用户
- `-i` 模拟登录
- `-s` 启动shell
- `-l` 列出权限

**实例：**
```bash
# 基本使用
sudo ls /root/
# 输入当前用户密码（不是root密码）

# 以指定用户执行命令
sudo -u www-data ls /var/www/

# 启动root shell
sudo -i
# 或
sudo -s

# 列出当前用户的sudo权限
sudo -l
# 输出：
# User user may run the following commands on hostname:
#     (ALL : ALL) ALL

# 编辑sudo配置（危险操作）
sudo visudo

# 不输入密码执行命令（需要配置NOPASSWD）
# 在/etc/sudoers中添加：user ALL=(ALL) NOPASSWD: /bin/ls
sudo ls /root/  # 不需要密码

# 以root身份编辑文件
sudo vim /etc/hosts

# 切换到root环境
sudo su -

# 查看sudo日志
sudo tail /var/log/auth.log | grep sudo
# 输出：sudo命令的执行记录
```

---

## 压缩和归档

### tar - 归档文件

**基本语法：** `tar [选项] 归档文件 文件列表`

**常用选项：**
- `-c` 创建归档
- `-x` 解压归档
- `-t` 列出内容
- `-v` 显示详细过程
- `-f` 指定归档文件名
- `-z` gzip压缩
- `-j` bzip2压缩

**实例：**
```bash
# 创建测试文件和目录
mkdir -p test_archive/dir1/dir2
echo "File 1 content" > test_archive/file1.txt
echo "File 2 content" > test_archive/dir1/file2.txt
echo "File 3 content" > test_archive/dir1/dir2/file3.txt

# 创建tar归档
tar -cvf archive.tar test_archive/
# 输出：
# test_archive/
# test_archive/file1.txt
# test_archive/dir1/
# test_archive/dir1/file2.txt
# test_archive/dir1/dir2/
# test_archive/dir1/dir2/file3.txt

# 查看归档内容
tar -tvf archive.tar
# 输出：
# drwxr-xr-x user/user         0 2023-12-24 15:10 test_archive/
# -rw-r--r-- user/user        15 2023-12-24 15:10 test_archive/file1.txt

# 解压归档
mkdir extract_test
cd extract_test
tar -xvf ../archive.tar

# 创建gzip压缩归档
tar -czvf archive.tar.gz test_archive/
# 输出：归档并压缩过程

# 解压gzip归档
tar -xzvf archive.tar.gz

# 创建bzip2压缩归档
tar -cjvf archive.tar.bz2 test_archive/

# 只提取特定文件
tar -xvf archive.tar test_archive/file1.txt

# 追加文件到已存在的归档
echo "New file" > newfile.txt
tar -rvf archive.tar newfile.txt

# 查看压缩比
ls -lh archive.tar*
# 输出：
# -rw-r--r-- 1 user user 10K Dec 24 15:15 archive.tar
# -rw-r--r-- 1 user user 2.1K Dec 24 15:16 archive.tar.gz
# -rw-r--r-- 1 user user 2.0K Dec 24 15:17 archive.tar.bz2
```

### gzip/gunzip - 压缩/解压文件

**基本语法：** `gzip [选项] 文件名`

**常用选项：**
- `-d` 解压（等同于gunzip）
- `-r` 递归压缩目录
- `-t` 测试压缩文件
- `-v` 显示详细信息
- `-1到-9` 压缩级别

**实例：**
```bash
# 创建测试文件
echo "This is a test file for compression demonstration. It contains some text that can be compressed to show the effectiveness of gzip compression." > test_compression.txt
ls -l test_compression.txt
# 输出：-rw-r--r-- 1 user user 138 Dec 24 15:20 test_compression.txt

# 基本压缩
gzip test_compression.txt
ls -l test_compression.txt.gz
# 输出：-rw-r--r-- 1 user user 95 Dec 24 15:20 test_compression.txt.gz
# 注意：原文件已被替换为压缩文件

# 保留原文件进行压缩
cp test_compression.txt.gz temp.gz
gunzip temp.gz
gzip -c test_compression.txt > test_compression_copy.txt.gz
ls -l test_compression*
# 输出：显示原文件和压缩文件都存在

# 解压文件
gunzip test_compression.txt.gz
# 或
gzip -d test_compression_copy.txt.gz

# 不同压缩级别对比
echo "Testing different compression levels" > compression_test.txt
cp compression_test.txt test1.txt
cp compression_test.txt test9.txt

gzip -1 test1.txt  # 最快压缩
gzip -9 test9.txt  # 最大压缩

ls -l test*.txt.gz
# 输出：比较不同压缩级别的文件大小

# 测试压缩文件完整性
gzip -t test1.txt.gz
echo $?
# 输出：0（成功）

# 显示压缩信息
gzip -l test1.txt.gz
# 输出：
#          compressed        uncompressed  ratio uncompressed_name
#                  45                  34  -8.8% test1.txt

# 递归压缩目录中的文件
mkdir -p compress_dir
echo "file1" > compress_dir/file1.txt
echo "file2" > compress_dir/file2.txt
gzip -r compress_dir/
ls -la compress_dir/
# 输出：目录中的所有文件都被压缩
```

### zip/unzip - 创建和解压ZIP文件

**基本语法：** `zip [选项] 压缩文件.zip 文件列表`

**常用选项：**
- `-r` 递归压缩目录
- `-v` 显示详细过程
- `-u` 更新压缩文件
- `-d` 从压缩文件中删除
- `-x` 排除特定文件

**实例：**
```bash
# 创建测试文件结构
mkdir -p zip_test/{docs,images,scripts}
echo "Document 1" > zip_test/docs/doc1.txt
echo "Document 2" > zip_test/docs/doc2.txt
echo "Image placeholder" > zip_test/images/image1.jpg
echo "#!/bin/bash\necho 'Hello World'" > zip_test/scripts/script1.sh

# 创建ZIP文件
zip -r project.zip zip_test/
# 输出：
#   adding: zip_test/ (stored 0%)
#   adding: zip_test/docs/ (stored 0%)
#   adding: zip_test/docs/doc1.txt (stored 0%)
#   adding: zip_test/docs/doc2.txt (stored 0%)

# 查看ZIP文件内容
unzip -l project.zip
# 输出：
# Archive:  project.zip
#   Length      Date    Time    Name
# ---------  ---------- -----   ----
#         0  12-24-2023 15:25   zip_test/
#         0  12-24-2023 15:25   zip_test/docs/
#        12  12-24-2023 15:25   zip_test/docs/doc1.txt

# 解压ZIP文件
mkdir extract_zip
cd extract_zip
unzip ../project.zip
# 输出：解压过程详情

# 只解压特定文件
unzip project.zip zip_test/docs/doc1.txt

# 解压时不覆盖已存在文件
unzip -n project.zip

# 静默解压（不显示输出）
unzip -q project.zip

# 测试ZIP文件完整性
unzip -t project.zip
# 输出：testing: zip_test/docs/doc1.txt    OK

# 排除特定文件类型
zip -r project_no_images.zip zip_test/ -x "*.jpg"

# 添加文件到现有ZIP
echo "New document" > newdoc.txt
zip project.zip newdoc.txt

# 从ZIP中删除文件
zip -d project.zip newdoc.txt

# 更新ZIP中的文件
echo "Updated document" > zip_test/docs/doc1.txt
zip -u project.zip zip_test/docs/doc1.txt

# 创建密码保护的ZIP文件
zip -r -P mypassword secure.zip zip_test/
# 解压时需要密码：
# unzip secure.zip
```

---

## 查找和搜索

### find - 查找文件和目录

**基本语法：** `find [路径] [条件] [动作]`

**常用条件：**
- `-name` 按名称查找
- `-type` 按类型查找
- `-size` 按大小查找
- `-mtime` 按修改时间查找
- `-perm` 按权限查找

**实例：**
```bash
# 创建测试文件结构
mkdir -p find_test/{level1/{level2,level3},old_files}
echo "content" > find_test/test.txt
echo "content" > find_test/level1/data.log
echo "content" > find_test/level1/level2/config.ini
echo "old content" > find_test/old_files/archive.bak
chmod 755 find_test/test.txt
chmod 644 find_test/level1/data.log

# 按名称查找文件
find find_test/ -name "*.txt"
# 输出：find_test/test.txt

# 按名称查找（不区分大小写）
find find_test/ -iname "*.LOG"
# 输出：find_test/level1/data.log

# 按类型查找
find find_test/ -type f  # 查找文件
# 输出：所有文件

find find_test/ -type d  # 查找目录
# 输出：所有目录

# 按大小查找
find find_test/ -size +0c  # 大于0字节的文件
find find_test/ -size -1k  # 小于1KB的文件

# 按权限查找
find find_test/ -perm 755
# 输出：find_test/test.txt

# 按修改时间查找
find find_test/ -mtime -1  # 最近1天修改的文件
find find_test/ -mtime +7  # 7天前修改的文件

# 组合条件查找
find find_test/ -name "*.txt" -o -name "*.log"
# 输出：查找.txt或.log文件

find find_test/ -type f -name "*.txt" -size +0c
# 输出：同时满足多个条件的文件

# 执行动作
find find_test/ -name "*.bak" -delete  # 删除.bak文件

find find_test/ -type f -exec ls -l {} \;
# 输出：对找到的每个文件执行ls -l

find find_test/ -name "*.log" -exec grep "content" {} \;
# 输出：在找到的.log文件中搜索"content"

# 查找并统计
find find_test/ -type f | wc -l
# 输出：文件总数

# 查找最大的文件
find find_test/ -type f -exec ls -s {} \; | sort -n -r | head -5
# 输出：前5个最大的文件

# 查找空文件和空目录
find find_test/ -empty
# 输出：空文件和空目录

# 按用户查找
find /home -user $USER -name "*.txt" 2>/dev/null
# 输出：当前用户的.txt文件

# 查找并复制
find find_test/ -name "*.txt" -exec cp {} /tmp/ \;
# 将找到的.txt文件复制到/tmp/
```

### locate - 快速查找文件

**基本语法：** `locate [选项] 模式`

**常用选项：**
- `-i` 忽略大小写
- `-l` 限制输出数量
- `-r` 使用正则表达式
- `-c` 只显示计数

**实例：**
```bash
# 更新locate数据库（需要sudo权限）
sudo updatedb

# 基本查找
locate test.txt
# 输出：系统中所有名为test.txt的文件路径

# 忽略大小写查找
locate -i TEST.TXT
# 输出：不区分大小写的结果

# 限制结果数量
locate -l 5 "*.log"
# 输出：最多5个.log文件

# 只显示计数
locate -c "*.txt"
# 输出：系统中.txt文件的总数，如：1234

# 使用正则表达式
locate -r "test.*\.txt$"
# 输出：匹配正则表达式的文件

# 查找目录
locate -d bin
# 输出：包含bin的目录路径

# 查找特定路径下的文件
locate "/home/user/*.txt"
# 输出：用户主目录下的.txt文件

# 组合使用
locate "*.log" | grep apache
# 输出：包含apache的.log文件

# 查看locate数据库信息
locate -S
# 输出：
# Database /var/lib/mlocate/mlocate.db:
#         21,100 directories
#         136,371 files
#         7,251,611 bytes in file names
#         3,264,341 bytes used to store database
```

### which - 查找可执行文件路径

**基本语法：** `which [选项] 命令名`

**常用选项：**
- `-a` 显示所有匹配项

**实例：**
```bash
# 查找命令位置
which ls
# 输出：/bin/ls

which python3
# 输出：/usr/bin/python3

which git
# 输出：/usr/bin/git

# 显示所有匹配项
which -a python
# 输出：
# /usr/bin/python
# /usr/local/bin/python

# 查找多个命令
which ls grep awk
# 输出：
# /bin/ls
# /bin/grep
# /usr/bin/awk

# 检查命令是否存在
which nonexistent_command
echo $?
# 输出：1（表示未找到）

which ls
echo $?
# 输出：0（表示找到）

# 在脚本中使用
if which docker >/dev/null 2>&1; then
    echo "Docker is installed"
else
    echo "Docker is not installed"
fi
```

### whereis - 查找命令、源码和手册页

**基本语法：** `whereis [选项] 文件名`

**常用选项：**
- `-b` 只查找可执行文件
- `-m` 只查找手册页
- `-s` 只查找源码

**实例：**
```bash
# 查找命令的所有相关文件
whereis ls
# 输出：ls: /bin/ls /usr/share/man/man1/ls.1.gz

# 只查找可执行文件
whereis -b ls
# 输出：ls: /bin/ls

# 只查找手册页
whereis -m ls
# 输出：ls: /usr/share/man/man1/ls.1.gz

# 查找多个命令
whereis python3 pip3
# 输出：
# python3: /usr/bin/python3 /usr/lib/python3 /etc/python3 /usr/share/man/man1/python3.1.gz
# pip3: /usr/bin/pip3

# 查找系统工具
whereis gcc
# 输出：gcc: /usr/bin/gcc /usr/lib/gcc /usr/share/man/man1/gcc.1.gz

whereis make
# 输出：make: /usr/bin/make /usr/share/man/man1/make.1.gz
```

---

## 系统监控

### df - 显示磁盘空间使用情况

**基本语法：** `df [选项] [文件系统]`

**常用选项：**
- `-h` 人类可读格式
- `-T` 显示文件系统类型
- `-i` 显示inode使用情况
- `-a` 显示所有文件系统

**实例：**
```bash
# 基本磁盘使用情况
df
# 输出：
# Filesystem     1K-blocks    Used Available Use% Mounted on
# /dev/sda1       20971520 8388608  11534336  43% /
# /dev/sda2       10485760 2097152   7864320  22% /home

# 人类可读格式
df -h
# 输出：
# Filesystem      Size  Used Avail Use% Mounted on
# /dev/sda1        20G  8.0G   11G  43% /
# /dev/sda2        10G  2.0G  7.5G  22% /home
# tmpfs           2.0G     0  2.0G   0% /dev/shm

# 显示文件系统类型
df -hT
# 输出：
# Filesystem     Type      Size  Used Avail Use% Mounted on
# /dev/sda1      ext4       20G  8.0G   11G  43% /
# /dev/sda2      ext4       10G  2.0G  7.5G  22% /home
# tmpfs          tmpfs     2.0G     0  2.0G   0% /dev/shm

# 显示inode使用情况
df -i
# 输出：
# Filesystem      Inodes   IUsed   IFree IUse% Mounted on
# /dev/sda1      1310720  131072 1179648   10% /
# /dev/sda2       655360   65536  589824   10% /home

# 显示特定目录的磁盘使用
df -h /home
# 输出：/home目录所在文件系统的使用情况

# 显示所有文件系统
df -a
# 输出：包括虚拟文件系统在内的所有挂载点

# 按使用率排序
df -h | sort -k5 -r
# 输出：按使用率从高到低排序的结果
```

### du - 显示目录空间使用情况

**基本语法：** `du [选项] [目录]`

**常用选项：**
- `-h` 人类可读格式
- `-s` 只显示总计
- `-a` 显示所有文件
- `-d` 指定深度
- `--max-depth` 最大深度

**实例：**
```bash
# 创建测试目录结构
mkdir -p du_test/{dir1,dir2,dir3}
echo "Small file content" > du_test/small.txt
dd if=/dev/zero of=du_test/dir1/large.dat bs=1M count=10 2>/dev/null
echo "Another file" > du_test/dir2/file.txt
dd if=/dev/zero of=du_test/dir3/medium.dat bs=1K count=500 2>/dev/null

# 显示当前目录使用情况
du -h du_test/
# 输出：
# 500K    du_test/dir3
# 19M     du_test/dir1
# 4.0K    du_test/dir2
# 19M     du_test

# 只显示总计
du -sh du_test/
# 输出：19M    du_test

# 显示所有文件和目录
du -ah du_test/
# 输出：
# 4.0K    du_test/small.txt
# 10M     du_test/dir1/large.dat
# 10M     du_test/dir1
# 4.0K    du_test/dir2/file.txt

# 限制显示深度
du -h --max-depth=1 du_test/
# 输出：只显示第一层目录

# 按大小排序
du -ah du_test/ | sort -hr
# 输出：
# 19M     du_test
# 10M     du_test/dir1/large.dat
# 10M     du_test/dir1
# 500K    du_test/dir3/medium.dat
# 500K    du_test/dir3

# 查找最大的目录
du -h du_test/*/ | sort -hr | head -3
# 输出：前3个最大的子目录

# 显示当前目录下所有子目录大小
du -sh */ 2>/dev/null | sort -hr
# 输出：当前目录下所有子目录按大小排序

# 查找大文件
find du_test/ -type f -exec du -h {} \; | sort -hr | head -5
# 输出：前5个最大的文件

# 排除特定文件类型
du -ah du_test/ --exclude="*.dat"
# 输出：排除.dat文件的大小统计
```

### free - 显示内存使用情况

**基本语法：** `free [选项]`

**常用选项：**
- `-h` 人类可读格式
- `-m` 以MB显示
- `-g` 以GB显示
- `-s` 持续监控
- `-t` 显示总计

**实例：**
```bash
# 基本内存信息
free
# 输出：
#               total        used        free      shared  buff/cache   available
# Mem:        8165536     2048000     3584000      512000     2533536     5324000
# Swap:       2097152           0     2097152

# 人类可读格式
free -h
# 输出：
#               total        used        free      shared  buff/cache   available
# Mem:           7.8G        2.0G        3.4G        500M        2.4G        5.1G
# Swap:          2.0G          0B        2.0G

# 以MB显示
free -m
# 输出：
#               total        used        free      shared  buff/cache   available
# Mem:           7972        2000        3500         500        2472        5200
# Swap:          2048           0        2048

# 显示总计
free -ht
# 输出：
#               total        used        free      shared  buff/cache   available
# Mem:           7.8G        2.0G        3.4G        500M        2.4G        5.1G
# Swap:          2.0G          0B        2.0G
# Total:         9.8G        2.0G        5.4G

# 持续监控（每2秒更新）
free -h -s 2
# 输出：每2秒更新一次的内存使用情况

# 只显示一次更新
free -h -c 1
# 输出：显示一次后退出

# 计算内存使用率
free | awk 'NR==2{printf "Memory Usage: %.2f%%\n", $3*100/$2}'
# 输出：Memory Usage: 25.12%

# 监控内存变化
watch -n 1 'free -h'
# 输出：每秒更新一次的内存监控界面
```

### iostat - I/O统计信息

**基本语法：** `iostat [选项] [间隔] [次数]`

**常用选项：**
- `-x` 显示扩展统计
- `-d` 只显示磁盘统计
- `-c` 只显示CPU统计
- `-h` 人类可读格式

**实例：**
```bash
# 安装sysstat包（如果未安装）
# sudo apt install sysstat  # Ubuntu/Debian
# sudo yum install sysstat  # CentOS/RHEL

# 基本I/O统计
iostat
# 输出：
# Linux 5.4.0 (hostname)     12/24/2023      _x86_64_        (4 CPU)
# 
# avg-cpu:  %user   %nice %system %iowait  %steal   %idle
#            2.34    0.00    1.23    0.45    0.00   95.98
# 
# Device             tps    kB_read/s    kB_wrtn/s    kB_read    kB_wrtn
# sda              12.34        123.45        67.89    1234567     678901

# 显示扩展统计信息
iostat -x
# 输出：
# Device         r/s     w/s     rkB/s     wkB/s   rrqm/s   wrqm/s  %rrqm  %wrqm     r_await    w_await aqu-sz rareq-sz wareq-sz  svctm  %util
# sda           5.67    6.78    123.45     67.89     0.12     1.34   2.07  16.50       2.34       4.56   0.03    21.78     10.01   1.23   0.85

# 只显示磁盘统计
iostat -d 2 3
# 输出：每2秒更新一次，共3次

# 显示特定设备
iostat -x sda 1
# 输出：每秒更新sda设备的详细统计

# 人类可读格式
iostat -h
# 输出：以更易读的格式显示大小

# 持续监控高I/O负载
iostat -x 1 | grep -E "Device|sda"
# 输出：持续监控sda设备的I/O情况

# 分析I/O等待时间
iostat -x 1 | awk '/sda/ && $10 > 10 {print strftime("%Y-%m-%d %H:%M:%S"), "High await:", $10}'
# 输出：当I/O等待时间超过10ms时的警告
```

### vmstat - 虚拟内存统计

**基本语法：** `vmstat [选项] [间隔] [次数]`

**常用选项：**
- `-a` 显示活跃和非活跃内存
- `-d` 显示磁盘统计
- `-s` 显示内存统计摘要
- `-t` 显示时间戳

**实例：**
```bash
# 基本虚拟内存统计
vmstat
# 输出：
# procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
#  r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
#  1  0      0 3584000 123456 2345678    0    0    10    20  100  200  2  1 97  0  0

# 每2秒更新一次，共5次
vmstat 2 5
# 输出：显示5次统计，每次间隔2秒

# 显示活跃和非活跃内存
vmstat -a
# 输出：
# procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
#  r  b   swpd   free  inact active   si   so    bi    bo   in   cs us sy id wa st
#  0  0      0 3584000 1234567 5678901    0    0    10    20  100  200  2  1 97  0  0

# 显示磁盘统计
vmstat -d
# 输出：
# disk- ------------reads------------ ------------writes----------- -----IO------
#        total merged sectors      ms  total merged sectors      ms    cur    sec
# sda    12345    123 1234567   12345  67890    678  678901    6789      0     12

# 显示内存统计摘要
vmstat -s
# 输出：
#       8165536 K total memory
#       2048000 K used memory
#       5678901 K active memory
#       1234567 K inactive memory

# 显示时间戳
vmstat -t 1
# 输出：每行都带有时间戳的统计信息

# 监控系统负载
vmstat 1 | awk '{if(NR>2 && ($1+$2)>2) print strftime("%H:%M:%S"), "High load:", $1+$2}'
# 输出：当系统负载过高时的警告

# 监控内存使用
vmstat 1 | awk 'NR>2 {if($4<1000000) print strftime("%H:%M:%S"), "Low memory:", $4"K"}'
# 输出：当可用内存低于1GB时的警告
```

### sar - 系统活动报告

**基本语法：** `sar [选项] [间隔] [次数]`

**常用选项：**
- `-u` CPU使用率
- `-r` 内存使用率
- `-d` 磁盘活动
- `-n` 网络统计
- `-q` 队列长度和负载

**实例：**
```bash
# CPU使用率统计
sar -u 1 3
# 输出：
# 15:30:01        CPU     %user     %nice   %system   %iowait    %steal     %idle
# 15:30:02        all      2.50      0.00      1.25      0.25      0.00     96.00
# 15:30:03        all      3.00      0.00      1.50      0.00      0.00     95.50

# 内存使用率统计
sar -r 1 3
# 输出：
# 15:30:01    kbmemfree kbmemused  %memused kbbuffers  kbcached kbcommit   %commit
# 15:30:02      3584000   4581536     56.07    123456   2345678  2048000     25.06

# 磁盘活动统计
sar -d 1 3
# 输出：
# 15:30:01          DEV       tps  rd_sec/s  wr_sec/s  avgrq-sz  avgqu-sz     await     svctm     %util
# 15:30:02          sda     12.00    123.45     67.89      15.92      0.03      2.50      1.25      1.50

# 网络统计
sar -n DEV 1 3
# 输出：
# 15:30:01        IFACE   rxpck/s   txpck/s    rxkB/s    txkB/s   rxcmp/s   txcmp/s  rxmcst/s
# 15:30:02         eth0    123.45     98.76     567.89    432.10      0.00      0.00      0.00

# 系统负载和队列长度
sar -q 1 3
# 输出：
# 15:30:01   runq-sz  plist-sz   ldavg-1   ldavg-5  ldavg-15   blocked
# 15:30:02         1       234      0.15      0.10      0.05         0

# 查看历史数据（从日志文件）
sar -u -f /var/log/sysstat/sa$(date +%d)
# 输出：当天的CPU使用历史

# 生成报告
sar -A -f /var/log/sysstat/sa$(date +%d) > system_report.txt
# 生成完整的系统活动报告

# 实时监控关键指标
sar -u -r -d 2 | grep -E "Average|%idle|%memused|%util"
# 输出：关键性能指标的实时监控
```

---

## 总结

本文档详细介绍了Linux系统中最常用的命令，包括：

1. **文件操作**：ls, cd, mkdir, cp, mv, rm等基础文件管理命令
2. **文本处理**：cat, grep, sed, awk, sort等强大的文本处理工具
3. **系统管理**：ps, top, kill, jobs等进程和作业控制命令
4. **网络工具**：ping, wget, curl, netstat等网络诊断和数据传输工具
5. **权限管理**：chmod, chown, su, sudo等权限和用户管理命令
6. **压缩归档**：tar, gzip, zip等文件压缩和归档工具
7. **查找搜索**：find, locate, which, whereis等文件查找命令
8. **系统监控**：df, du, free, iostat, vmstat, sar等系统性能监控工具

每个命令都提供了详细的语法说明、常用选项、实际示例和输出结果，便于学习和参考。这些命令是Linux系统管理和日常操作的基础，熟练掌握它们将大大提高工作效率。

建议读者：
- 在安全的环境中实际操作这些命令
- 结合man手册页面深入学习每个命令的高级功能
- 根据实际工作需要，重点掌握相关领域的命令
- 定期练习，形成肌肉记忆

记住：实践是掌握Linux命令的最佳方式！