前言

Linux 作为服务器端的主流操作系统，是每位开发者必备的技能。无论你从事前端、后端还是运维工作，都不可避免地要和 Linux 命令行打交道。本文以常用命令 + 实战场景的方式，帮你快速上手。

为什么要学命令行？

  • 🖥️ 生产服务器通常没有图形界面，只能通过终端操作
  • ⚡ 命令行操作比图形界面更高效
  • 🤖 便于编写脚本实现自动化
  • 📦 很多开发工具（Git、Docker、Node.js 等）天然适合命令行使用

一、基础概念

Shell 是什么？

Shell 是用户与 Linux 内核之间的命令解释器。你输入命令 → Shell 翻译 → 内核执行。

常见的 Shell：

  • bash（最常用，本文默认）
  • zsh（功能更丰富，macOS 默认）
  • sh（最基础的 Shell）

命令基本格式

1
命令 [选项] [参数]

示例：

1
2
ls -l /home          # ls 是命令，-l 是选项，/home 是参数
tar -xzvf file.tar.gz  # 多个选项可以合并写

二、文件与目录管理（最常用）⭐

2.1 pwd — 显示当前目录

1
2
pwd
# 输出：/home/zhangsan

场景：你进了一个很深的目录，想知道自己到底在哪。

2.2 ls — 列出目录内容

1
2
3
4
5
6
7
8
ls              # 列出当前目录
ls /var/log     # 列出指定目录
ls -l           # 详细信息（权限、大小、时间等）
ls -a           # 显示隐藏文件（.开头）
ls -lh          # 人类可读的文件大小（K、M、G）
ls -lt          # 按修改时间排序
ls -ltr         # 按时间倒序，最新的在最下面
ls -S           # 按文件大小排序

场景：查看最近修改的日志文件

1
ls -lt /var/log | head -10

输出示例：

1
2
3
-rw-r--r-- 1 root root  12K May 30 15:30 syslog
-rw-r--r-- 1 root root  8.5K May 30 15:30 auth.log
-rw-r--r-- 1 root root  3.2K May 30 14:00 nginx/access.log

ls -l 输出解读：

1
2
3
4
5
6
7
8
9
10
11
12
-rw-r--r-- 1 zhangsan staff 2048 May 30 14:00 doc.txt
│└┬┘└┬┘└┬┘ │ └──┬──┘ └─┬─┘ └─┬──┘ └──┬──┘ └──┬──┘
│ │  │  │  │     │       │      │       │       └─ 文件名
│ │  │  │  │     │       │      │       └─ 修改时间
│ │  │  │  │     │       │      └─ 文件大小（字节）
│ │  │  │  │     │       └─ 所属组
│ │  │  │  │     └─ 所属用户
│ │  │  │  └─ 硬链接数
│ │  │  └─ 其他用户权限（r=读 w=写 x=执行）
│ │  └─ 组用户权限
│ └─ 所有者权限
└─ 文件类型（-=文件 d=目录 l=链接）

2.3 cd — 切换目录

1
2
3
4
5
cd /home/zhangsan   # 进入指定目录
cd ..               # 返回上级目录
cd ../..            # 返回上两级
cd ~                # 回到用户主目录
cd -                # 回到上一次所在的目录（非常实用！）

场景：你从 /var/log/nginx 切换到 /etc/nginx 修改配置，然后想快速回去看日志：

1
2
3
4
cd /var/log/nginx    # 看日志
cd /etc/nginx        # 改配置
# ... 改完配置后
cd -                 # 直接回到 /var/log/nginx 🎉

2.4 mkdir — 创建目录

1
2
3
mkdir myproject             # 创建单层目录
mkdir -p a/b/c/d            # 递归创建多层目录
mkdir -p project/{src,dist,docs,test}   # 同时创建多个子目录

场景：快速搭建项目目录结构

1
2
mkdir -p my-web-app/{src/{components,utils,styles,assets},public,tests,docs}
tree my-web-app
1
2
3
4
5
6
7
8
9
my-web-app/
├── docs/
├── public/
├── src/
│   ├── assets/
│   ├── components/
│   ├── styles/
│   └── utils/
└── tests/

2.5 touch — 创建空文件 / 更新文件时间戳

1
2
3
touch README.md                # 创建空文件
touch file1.txt file2.txt      # 同时创建多个文件
touch -t 202605301500 file.txt # 修改文件时间戳

2.6 cp — 复制文件或目录

1
2
3
4
5
6
cp source.txt dest.txt         # 复制文件
cp file1.txt file2.txt dir/    # 复制多个文件到目录
cp -r dir1/ dir2/              # 递归复制目录
cp -i source.txt dest.txt      # 覆盖前询问（推荐）
cp -p source.txt dest.txt      # 保留文件属性（权限、时间戳）
cp -a dir1/ dir2/              # 归档复制（保留所有属性和链接）

场景：备份配置文件

1
2
# 修改配置前先备份（好习惯！）
cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak.$(date +%Y%m%d)

2.7 mv — 移动 / 重命名

1
2
3
4
mv old_name.txt new_name.txt   # 重命名
mv file.txt /target/dir/       # 移动文件
mv dir1/ dir2/                 # 移动/重命名目录
mv -i source.txt dest.txt      # 覆盖前询问

场景：批量重命名图片

1
2
3
4
# 将 photo_1.jpg ~ photo_10.jpg 改名为 img_1.jpg ~ img_10.jpg
for i in {1..10}; do
    mv "photo_$i.jpg" "img_$i.jpg"
done

2.8 rm — 删除文件或目录（慎用！）

1
2
3
4
5
rm file.txt              # 删除文件
rm -i file.txt           # 删除前确认
rm -f file.txt           # 强制删除，不询问
rm -r directory/         # 递归删除目录
rm -rf directory/        # 强制递归删除（⚠️ 非常危险！）

🚫 千万不要执行 rm -rf /——这会让系统彻底崩溃！

安全删除的好习惯：

1
2
3
4
5
6
# 先把要删的东西移到"回收站"
mkdir -p ~/.trash
mv file_to_delete.txt ~/.trash/

# 确认无误后再清空回收站
rm -rf ~/.trash/*

2.9 查看文件内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# cat — 查看整个文件（适合小文件）
cat file.txt
cat -n file.txt          # 显示行号
cat file1.txt file2.txt  # 合并查看多个文件

# less — 分页查看（适合大文件，推荐）
less /var/log/syslog
# 快捷键：空格=下一页 b=上一页 /=搜索 n=下一个匹配 q=退出

# head — 查看开头
head -20 /var/log/syslog # 前 20 行

# tail — 查看末尾
tail -20 /var/log/syslog # 最后 20 行
tail -f /var/log/syslog  # 实时追踪文件更新（监控日志必备！）

# more — 分页查看（类似 less 但功能较少）
more file.txt

场景：实时监控应用日志

1
2
3
4
5
6
7
8
# 查看最新日志并持续追踪
tail -f /var/log/nginx/access.log

# 过滤并追踪特定关键词
tail -f /var/log/nginx/error.log | grep "ERROR"

# 同时监控多个日志文件
tail -f /var/log/nginx/access.log /var/log/nginx/error.log

三、文件查找与搜索

3.1 find — 按条件查找文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 按文件名查找
find /home -name "*.log"              # 在 /home 下找 .log 文件
find /projects -name "*.js"           # 找所有 JS 文件
find . -iname "README*"               # 不区分大小写

# 按类型查找
find . -type f -name "*.txt"          # 只找文件
find . -type d -name "node_modules"   # 只找目录

# 按大小查找
find /var/log -type f -size +100M     # 找大于 100MB 的文件
find . -type f -size -1k             # 找小于 1KB 的文件

# 按时间查找
find . -type f -mtime -7             # 最近 7 天修改过的文件
find . -type f -mtime +30            # 30 天前修改过的文件
find . -type f -mmin -60             # 最近 60 分钟内修改过的

# 组合条件
find . -type f -name "*.log" -size +10M  # 大于 10MB 的日志文件

# 对查找结果执行操作
find . -type f -name "*.tmp" -delete     # 删除所有 .tmp 文件
find . -type f -name "*.txt" -exec ls -lh {} \;  # 对每个结果执行命令

场景：清理 30 天前的旧日志

1
find /var/log/myapp -type f -name "*.log" -mtime +30 -delete

场景：查找并删除所有 node_modules 目录

1
find /projects -type d -name "node_modules" -prune -exec rm -rf {} \;

3.2 grep — 文本内容搜索

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 基本搜索
grep "error" app.log                   # 搜索包含 error 的行
grep -i "error" app.log                # 不区分大小写
grep -v "DEBUG" app.log                # 排除包含 DEBUG 的行（反向匹配）
grep -n "error" app.log                # 显示行号
grep -c "error" app.log                # 统计匹配行数

# 递归搜索
grep -r "TODO" ./src/                  # 递归搜索目录
grep -rl "CONFIG" ./ --include="*.js"  # 只列出文件名

# 正则表达式
grep -E "ERROR|FATAL" app.log          # 匹配多个关键词
grep -E "^2026-05-30" app.log          # 以日期开头的行
grep -oE "status=\d+" app.log          # 只输出匹配部分

# 上下文
grep -A 3 "error" app.log              # 显示匹配行和后 3 行
grep -B 3 "error" app.log              # 显示匹配行和前 3 行
grep -C 3 "error" app.log              # 显示匹配行和前后各 3 行

场景：排查 Nginx 错误日志

1
2
3
4
5
# 查看所有 500 错误及其上下文
grep -C 5 "500" /var/log/nginx/access.log

# 统计每个 IP 的请求数（配合其他命令）
grep -oE '^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+' /var/log/nginx/access.log | sort | uniq -c | sort -rn

场景：在项目中搜索 TODO 注释

1
grep -rn "TODO\|FIXME\|HACK" ./src/ --include="*.js" --include="*.ts"

3.3 which / whereis — 查找命令位置

1
2
3
4
5
6
which node              # 找出命令的完整路径
which python3
# 输出：/usr/bin/python3

whereis nginx           # 查找命令、源码、手册页
# 输出：nginx: /usr/sbin/nginx /etc/nginx /usr/share/nginx

四、用户与权限管理

4.1 chmod — 修改文件权限

权限用数字表示：r=4, w=2, x=1

1
2
3
4
5
6
7
8
9
10
chmod 755 script.sh            # rwxr-xr-x（所有者可读写执行，其他人只读执行）
chmod 644 file.txt             # rw-r--r--（所有者可读写，其他人只读）
chmod 600 secret.key           # rw-------（只有所有者可读写）
chmod 777 public/              # rwxrwxrwx（所有人都可读写执行，不安全！）

# 符号方式
chmod u+x script.sh            # 给所有者加上执行权限
chmod g-w file.txt             # 去掉组用户的写权限
chmod a+r file.txt             # 给所有人读权限
chmod -R 755 project/          # 递归修改整个目录

常见权限速查：

权限 数字 适用场景
755 目录 所有者可写，其他人可读可进入
644 文件 所有者可写，其他人只读
600 私密文件 只有所有者可读写（如 SSH 密钥）
700 脚本/程序 只有所有者可读写执行

4.2 chown — 修改文件所有者

1
2
3
chown zhangsan file.txt                # 改所有者
chown zhangsan:staff file.txt          # 同时改所有者和组
chown -R zhangsan:staff /var/www/      # 递归修改

4.3 sudo — 以超级用户权限执行

1
2
3
4
sudo apt update                   # 以 root 权限执行命令
sudo -u postgres createdb mydb    # 以指定用户身份执行
sudo !!                           # 以 sudo 重新执行上一条命令（非常实用！）
sudo -i                           # 切换到 root 用户

4.4 whoami / id / groups — 查看用户信息

1
2
3
4
whoami          # 我是谁
id              # 用户 ID 和组信息
groups          # 所属的组
who             # 当前登录的所有用户

五、进程管理

5.1 ps — 查看进程

1
2
3
ps aux              # 查看所有进程（BSD 风格）
ps -ef              # 查看所有进程（System V 风格）
ps aux | grep nginx # 查找 nginx 进程

ps aux 输出解读：

1
2
3
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.1 225712  9184 ?        Ss   08:00   0:02 /sbin/init
nginx    12345  0.0  0.3 445328 28600 ?        S    08:01   0:01 nginx: worker process
列 含义
USER 进程所属用户
PID 进程 ID
%CPU CPU 占用百分比
%MEM 内存占用百分比
VSZ 虚拟内存大小（KB）
RSS 物理内存大小（KB）
STAT 进程状态（S=睡眠 R=运行 Z=僵尸）
TIME 累计 CPU 时间

5.2 top / htop — 动态查看进程

1
2
3
top             # 实时显示系统进程（按 q 退出）
top -u zhangsan # 只看某用户的进程
htop            # top 的增强版（界面更友好，需单独安装）

场景：找出吃 CPU 最多的进程

1
ps aux --sort=-%cpu | head -5

5.3 kill — 终止进程

1
2
3
4
5
6
7
kill 12345                     # 发送 TERM 信号（优雅终止）
kill -9 12345                  # 发送 KILL 信号（强制终止）
kill -15 12345                 # 等同于默认的 kill

pkill nginx                    # 按进程名终止
pkill -f "python app.py"      # 按完整命令行匹配
killall node                   # 终止所有同名进程

常用信号：

信号编号 名称 作用
1 SIGHUP 重新加载配置
9 SIGKILL 强制杀死（不可捕获）
15 SIGTERM 优雅终止（默认）

场景：Nginx 平滑重启

1
2
3
4
# 重新加载配置而不中断服务
kill -HUP $(cat /var/run/nginx.pid)
# 或者
nginx -s reload

5.4 后台运行与任务管理

1
2
3
4
5
6
7
8
9
10
11
12
13
# 后台运行
node app.js &                       # 命令末尾加 & 后台运行
nohup node app.js &                 # 终端关闭后继续运行
nohup node app.js > app.log 2>&1 &  # 同时重定向输出

# 查看后台任务
jobs                # 查看当前终端的后台任务

# 暂停和恢复
Ctrl + Z            # 暂停当前前台任务
bg                  # 将暂停的任务放到后台继续运行
fg                  # 将后台任务调回前台
bg %1               # 指定任务编号

场景：在服务器上运行长期任务

1
2
3
4
5
# 使用 nohup 确保 SSH 断开后任务继续执行
nohup python3 train_model.py > training.log 2>&1 &

# 查看输出
tail -f training.log

5.5 lsof — 查看进程打开的文件

1
2
3
4
lsof -i :3000                   # 查看哪个进程占用了 3000 端口
lsof -p 12345                   # 查看指定进程打开的文件
lsof /var/log/syslog            # 查看哪些进程在使用这个文件
lsof -u zhangsan                # 查看某用户打开的文件

场景：端口被占用，找出是谁

1
2
3
4
5
6
7
lsof -i :8080
# 输出：
# COMMAND   PID     USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
# node    12345 zhangsan   23u  IPv4  12345      0t0  TCP *:8080 (LISTEN)

# 找到后可以 kill 掉
kill 12345

六、磁盘与空间管理

6.1 df — 查看磁盘使用情况

1
2
3
df -h               # 人类可读格式显示
df -h /home         # 查看某个目录所在分区的使用情况
df -i               # 查看 inode 使用情况（小文件过多时会耗尽）

输出示例：

1
2
3
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1        50G   20G   28G  42% /
/dev/sdb1       200G   80G  110G  43% /data

6.2 du — 查看目录大小

1
2
3
4
du -sh *                    # 当前目录下每个文件/目录的大小
du -sh /var/log             # 查看指定目录总大小
du -h --max-depth=1 /home   # 只显示第 1 层子目录
du -sh * | sort -rh | head  # 按大小排序，找出最大的

场景：磁盘满了，找出占空间的大户

1
2
3
4
5
6
7
8
9
10
11
# 1. 先看哪个分区满了
df -h

# 2. 逐层排查
du -sh /* 2>/dev/null | sort -rh | head -10

# 3. 进一步定位
du -h --max-depth=1 /var | sort -rh | head -10

# 4. 找大文件（超过 100MB）
find / -type f -size +100M -exec ls -lh {} \; 2>/dev/null

6.3 free — 查看内存使用情况

1
2
free -h             # 人类可读格式
free -h -s 2        # 每 2 秒刷新一次

输出示例：

1
2
3
              total        used        free      shared  buff/cache   available
Mem:           7.7G        2.3G        3.1G        200M        2.3G        5.0G
Swap:          2.0G        100M        1.9G

七、网络相关

7.1 curl — 发送 HTTP 请求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# GET 请求
curl https://api.example.com/users
curl -I https://www.baidu.com              # 只显示响应头

# POST 请求
curl -X POST https://api.example.com/login \
  -H "Content-Type: application/json" \
  -d '{"username":"admin","password":"123456"}'

# 带请求头
curl -H "Authorization: Bearer token123" \
  https://api.example.com/profile

# 下载文件
curl -O https://example.com/file.tar.gz    # 保持原文件名
curl -o myfile.tar.gz https://example.com/file.tar.gz  # 指定文件名

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

# 显示请求耗时详情
curl -w "\ntime_total: %{time_total}s\n" -o /dev/null -s https://example.com

场景：测试 API 接口

1
2
3
4
5
6
7
8
# 快速测试接口是否正常
curl -s -o /dev/null -w "%{http_code}" https://blog.iot2045.cn
# 输出：200（表示正常）

# 测试 POST 接口
curl -X POST http://localhost:3000/api/articles \
  -H "Content-Type: application/json" \
  -d '{"title":"测试文章","content":"这是内容"}'

7.2 wget — 下载文件

1
2
3
wget https://example.com/file.tar.gz      # 下载文件
wget -c https://example.com/large.zip     # 断点续传
wget -r -l 2 https://example.com/docs/    # 递归下载（2 层深度）

7.3 netstat / ss — 查看网络连接

1
2
3
4
5
6
7
8
# netstat（传统工具）
netstat -tlnp           # 查看监听的 TCP 端口
netstat -an             # 查看所有连接
netstat -anp | grep :80 # 查看 80 端口连接

# ss（更快的替代品，推荐）
ss -tlnp                # 查看监听的 TCP 端口
ss -an                  # 查看所有连接

场景：确认服务是否启动并监听

1
2
3
4
ss -tlnp | grep nginx
# 输出：
# LISTEN  0  511  *:80   *:*   users:(("nginx",pid=1234,fd=6))
# LISTEN  0  511  *:443  *:*   users:(("nginx",pid=1234,fd=7))

7.4 ping — 测试网络连通性

1
2
ping -c 4 blog.iot2045.cn     # 发 4 个包后停止
ping -i 2 google.com          # 每 2 秒发一次

7.5 scp — 远程拷贝

1
2
3
4
5
6
7
8
9
10
11
# 上传到远程服务器
scp local_file.txt zhangsan@192.168.1.100:/home/zhangsan/

# 从远程服务器下载
scp zhangsan@192.168.1.100:/var/log/app.log ./

# 递归拷贝目录
scp -r myproject/ zhangsan@192.168.1.100:/home/zhangsan/

# 指定端口
scp -P 2222 file.txt zhangsan@192.168.1.100:~/

7.6 ssh — 远程登录

1
2
3
ssh zhangsan@192.168.1.100              # 基本登录
ssh -p 2222 zhangsan@192.168.1.100      # 指定端口
ssh -i ~/.ssh/my_key zhangsan@server    # 指定密钥

SSH 免密登录配置：

1
2
3
4
5
6
7
8
# 1. 生成 SSH 密钥对（如果还没有）
ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

# 2. 将公钥复制到远程服务器
ssh-copy-id zhangsan@192.168.1.100

# 3. 之后就可以免密登录了
ssh zhangsan@192.168.1.100

八、打包与压缩

8.1 tar — 归档（最常用）

1
2
3
4
5
6
7
8
9
10
11
12
13
# 打包并压缩（最常用组合）
tar -czvf archive.tar.gz /path/to/dir/    # 打包为 .tar.gz（gzip）
tar -cjvf archive.tar.bz2 /path/to/dir/   # 打包为 .tar.bz2（bzip2，更小）
tar -cJvf archive.tar.xz /path/to/dir/    # 打包为 .tar.xz（xz，最小）

# 解压
tar -xzvf archive.tar.gz                  # 解压 .tar.gz
tar -xjvf archive.tar.bz2                 # 解压 .tar.bz2
tar -xJvf archive.tar.xz                  # 解压 .tar.xz
tar -xvf archive.tar -C /target/dir/      # 解压到指定目录

# 查看压缩包内容（不解压）
tar -tzvf archive.tar.gz

参数速记：

参数 含义
c 创建（create）
x 解压（extract）
z gzip 压缩/解压
j bzip2 压缩/解压
v 显示过程（verbose）
f 指定文件名（file）
C 解压到指定目录

8.2 zip / unzip

1
2
3
4
zip -r archive.zip directory/              # 压缩
unzip archive.zip                          # 解压
unzip -l archive.zip                       # 查看内容（不解压）
unzip archive.zip -d /target/dir/          # 解压到指定目录

九、文本处理（管道组合）

Linux 的强大之处在于可以通过管道（|）将多个命令组合在一起。

9.1 管道符 | — 命令串联

1
2
# 基础用法：将前一个命令的输出作为后一个命令的输入
command1 | command2 | command3

9.2 sort — 排序

1
2
3
4
5
sort file.txt                 # 按字母排序
sort -n file.txt              # 按数字排序
sort -r file.txt              # 倒序
sort -t ',' -k 2 file.csv     # 以逗号分隔，按第 2 列排序
sort -u file.txt              # 排序并去重

9.3 uniq — 去重

1
2
3
4
uniq file.txt                 # 去除相邻重复行
sort file.txt | uniq          # 排序后去重（通常配合使用）
sort file.txt | uniq -c       # 统计重复次数
sort file.txt | uniq -d       # 只显示重复的行

9.4 wc — 统计

1
2
3
wc -l file.txt                # 统计行数
wc -c file.txt                # 统计字节数
wc -w file.txt                # 统计单词数

9.5 awk — 文本分析工具

1
2
3
4
5
6
7
8
9
10
11
# 打印第 1、3 列
awk '{print $1, $3}' data.txt

# 按分隔符处理
awk -F ':' '{print $1, $7}' /etc/passwd

# 条件过滤
awk '$3 > 1000' data.txt

# 统计求和
awk '{sum += $1} END {print sum}' numbers.txt

9.6 sed — 流编辑器

1
2
3
4
5
6
7
8
9
10
11
12
# 替换文本
sed 's/old/new/' file.txt                # 替换每行第一个匹配
sed 's/old/new/g' file.txt               # 全局替换
sed -i 's/old/new/g' file.txt            # 直接修改文件（慎用！）
sed -i.bak 's/old/new/g' file.txt        # 修改前先备份

# 删除行
sed '/pattern/d' file.txt                # 删除匹配的行
sed '2,5d' file.txt                      # 删除第 2 到 5 行

# 打印指定行
sed -n '10,20p' file.txt                 # 打印第 10 到 20 行

9.7 实战组合：日志分析

场景 1：找出访问量 Top 10 的 IP

1
2
3
4
5
6
cat /var/log/nginx/access.log \
  | awk '{print $1}' \
  | sort \
  | uniq -c \
  | sort -rn \
  | head -10

输出示例：

1
2
3
4
1523 192.168.1.100
 892 10.0.0.55
 456 172.16.0.88
 ...

场景 2：统计 API 接口响应时间分布

1
2
3
4
5
6
7
8
9
10
11
12
13
# 假设日志格式中包含请求耗时（单位：秒）
cat /var/log/nginx/access.log \
  | awk '{print $NF}' \
  | sort -n \
  | awk '{
      if ($1 < 0.1) fast++
      else if ($1 < 1.0) normal++
      else slow++
    } END {
      print "快速(<0.1s):", fast
      print "正常(0.1-1s):", normal
      print "慢(>1s):", slow
    }'

场景 3：查找一段日志

1
2
3
4
5
# 查找 14:00 到 15:00 之间的日志
sed -n '/14:00/,/15:00/p' /var/log/syslog

# 带关键词过滤
sed -n '/14:00/,/15:00/p' /var/log/syslog | grep -i "error"

十、软件包管理

Debian/Ubuntu 系（apt）

1
2
3
4
5
6
7
8
sudo apt update                          # 更新软件包列表
sudo apt upgrade                         # 升级所有软件包
sudo apt install nginx                   # 安装软件
sudo apt remove nginx                    # 卸载软件（保留配置）
sudo apt purge nginx                     # 完全卸载（含配置文件）
apt search keyword                       # 搜索软件包
apt show nginx                           # 查看软件包详情
sudo apt autoremove                      # 清理无用依赖

CentOS/RHEL 系（yum / dnf）

1
2
3
4
sudo yum install nginx                   # 安装
sudo yum update nginx                    # 更新
sudo yum remove nginx                    # 卸载
yum search keyword                       # 搜索

十一、系统信息查看

1
2
3
4
5
6
7
8
9
10
uname -a                    # 系统内核信息
lsb_release -a              # 发行版信息
cat /etc/os-release         # 系统版本
uptime                      # 系统运行时间、负载
hostname                    # 主机名
cat /proc/cpuinfo           # CPU 信息
cat /proc/meminfo           # 内存详细信息
lscpu                       # CPU 架构信息
lsblk                       # 磁盘分区信息
dmesg | tail -20            # 内核日志（最近 20 行）

十二、Shell 重定向与快捷键

12.1 输出重定向

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 标准输出重定向
command > file.txt          # 覆盖写入文件
command >> file.txt         # 追加写入文件

# 标准错误重定向
command 2> error.log        # 错误输出写入文件
command 2>> error.log       # 错误输出追加到文件

# 同时重定向标准输出和标准错误
command > all.log 2>&1      # 都写入同一个文件
command &> all.log          # 同上（bash 简写）

# 丢弃输出
command > /dev/null 2>&1    # 不显示任何输出

12.2 终端快捷键

快捷键 作用
Ctrl + C 终止当前命令
Ctrl + D 退出终端 / EOF
Ctrl + Z 挂起当前任务
Ctrl + L 清屏（等同 clear）
Ctrl + A 光标移动到行首
Ctrl + E 光标移动到行尾
Ctrl + U 删除光标前的内容
Ctrl + K 删除光标后的内容
Ctrl + W 删除前一个单词
Ctrl + R 搜索历史命令（强烈推荐！）
Tab 自动补全
↑ / ↓ 浏览历史命令
!! 重复上一条命令

十三、实用 Shell 技巧

13.1 命令历史

1
2
3
4
5
history                    # 查看命令历史
history \| grep "ssh"      # 搜索历史命令
!123                       # 执行历史中第 123 条命令
!!                         # 重复上一条命令
!$                         # 引用上一条命令的最后一个参数

场景示例：

1
2
mkdir -p /var/www/my-long-project-name
cd !$    # 等同于 cd /var/www/my-long-project-name

13.2 别名设置

1
2
3
4
5
6
7
8
9
10
11
12
13
# 查看已有别名
alias

# 设置临时别名（仅当前会话有效）
alias ll='ls -alF'
alias la='ls -A'
alias ..='cd ..'
alias ...='cd ../..'

# 永久设置（写入 ~/.bashrc）
echo "alias ll='ls -alF'" >> ~/.bashrc
echo "alias gst='git status'" >> ~/.bashrc
source ~/.bashrc          # 重新加载配置

13.3 环境变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 查看所有环境变量
env
printenv

# 查看特定变量
echo $HOME
echo $PATH

# 设置环境变量（临时）
export MY_VAR="hello"
export PATH=$PATH:/usr/local/myapp/bin

# 永久设置
echo 'export NODE_ENV=production' >> ~/.bashrc

13.4 一行命令完成常见任务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 统计代码行数（排除 node_modules）
find . -name "*.js" -not -path "*/node_modules/*" | xargs wc -l | tail -1

# 批量创建 100 个测试文件
touch test_{1..100}.txt

# 快速备份文件
cp important.conf{,.bak.$(date +%Y%m%d)}

# 用 Python 启动一个简易 HTTP 服务器
python3 -m http.server 8000

# 查找并替换多个文件中的字符串
grep -rl 'old_domain.com' ./ --include="*.md" | xargs sed -i 's/old_domain.com/new_domain.com/g'

# 监控命令执行时间
time npm run build

# 每隔 1 秒执行一次命令（watch）
watch -n 1 'ps aux | grep nginx'
watch -n 2 'df -h'

十四、常见场景完全指南

场景 A：部署一个 Node.js 应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# 1. 登录服务器
ssh user@your-server-ip

# 2. 更新系统
sudo apt update && sudo apt upgrade -y

# 3. 安装 Node.js（使用 NodeSource）
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs

# 4. 验证安装
node --version && npm --version

# 5. 创建应用目录
sudo mkdir -p /var/www/myapp
sudo chown -R $USER:$USER /var/www/myapp

# 6. 克隆代码
cd /var/www/myapp
git clone https://github.com/your-repo.git .

# 7. 安装依赖并构建
npm install
npm run build

# 8. 使用 PM2 管理进程
sudo npm install -g pm2
pm2 start dist/main.js --name myapp
pm2 save
pm2 startup   # 设置开机自启

# 9. 配置 Nginx 反向代理
sudo apt install -y nginx
sudo vim /etc/nginx/sites-available/myapp

Nginx 配置示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
server {
    listen 80;
    server_name your-domain.com;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_cache_bypass $http_upgrade;
    }
}
1
2
3
4
# 10. 启用站点并重启 Nginx
sudo ln -s /etc/nginx/sites-available/myapp /etc/nginx/sites-enabled/
sudo nginx -t             # 测试配置
sudo systemctl restart nginx

场景 B：定时备份数据库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 1. 创建备份脚本
cat > ~/backup-mysql.sh << 'EOF'
#!/bin/bash
BACKUP_DIR="/backup/mysql"
DB_USER="root"
DB_PASS="your_password"
DB_NAME="my_blog"
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p "$BACKUP_DIR"
mysqldump -u$DB_USER -p$DB_PASS $DB_NAME | gzip > "$BACKUP_DIR/${DB_NAME}_${DATE}.sql.gz"

# 只保留最近 7 天的备份
find "$BACKUP_DIR" -type f -name "*.sql.gz" -mtime +7 -delete

echo "Backup completed: ${DB_NAME}_${DATE}.sql.gz"
EOF

# 2. 赋予执行权限
chmod +x ~/backup-mysql.sh

# 3. 添加定时任务（每天凌晨 2 点执行）
crontab -e
# 添加以下行：
# 0 2 * * * /home/user/backup-mysql.sh >> /var/log/backup.log 2>&1

场景 C：排查服务故障

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 1. 确认服务是否在运行
sudo systemctl status nginx
# 或者
ps aux | grep nginx

# 2. 检查端口是否在监听
ss -tlnp | grep :80

# 3. 查看最近日志
sudo tail -100 /var/log/nginx/error.log

# 4. 检查系统资源
free -h          # 内存够不够
df -h            # 磁盘满没满
top -bn1 | head  # CPU 高不高

# 5. 测试本地端口连通性
curl -I http://localhost:80

# 6. 重启服务
sudo systemctl restart nginx

常用命令速查表

分类 命令 说明
目录 pwd 显示当前路径
目录 ls -lah 显示详细文件列表
目录 cd ~ 回到主目录
目录 mkdir -p a/b/c 递归创建目录
文件 touch file 创建空文件
文件 cp -r src dst 递归复制
文件 mv old new 移动/重命名
文件 rm -rf dir 强制删除（慎用！）
查看 cat file 查看文件
查看 less file 分页查看
查看 tail -f file 实时追踪文件
查找 find . -name "*.js" 按名称查找
查找 grep -r "text" . 递归搜索文本
权限 chmod 755 file 修改权限
权限 chown user file 修改所有者
进程 ps aux | grep name 查找进程
进程 kill -9 PID 强制终止进程
进程 top 系统监控
磁盘 df -h 磁盘空间
磁盘 du -sh dir/ 目录大小
网络 curl -I url HTTP 请求头
网络 ss -tlnp 监听端口
网络 scp file user@host: 远程拷贝
压缩 tar -czvf a.tar.gz d/ 打包压缩
压缩 tar -xzvf a.tar.gz 解压
文本 sort | uniq -c 排序去重统计
文本 sed 's/a/b/g' 文本替换
文本 awk '{print $1}' 提取列
系统 uname -a 系统信息
系统 uptime 运行时间/负载
系统 free -h 内存信息

进一步学习建议

  1. 动手实践：在虚拟机或 WSL 中安装 Linux，每天用命令行操作
  2. 学习 Shell 脚本：自动化重复任务，推荐《鸟哥的 Linux 私房菜》
  3. 掌握 Vim：Linux 下的必备编辑器，至少学会基本操作
  4. 了解 systemd：现代 Linux 的服务管理方式（systemctl 系列命令）
  5. 熟悉正则表达式：配合 grep、sed、awk 发挥强大威力

结语

本文涵盖了 Linux 开发中最常用的命令和实战场景。对于初学者，建议不要试图一次记住所有命令，而是在日常使用中逐步积累：

  • 遇到一个场景 → 查对应命令 → 多敲几遍 → 自然记住
  • 善用 man command 查看命令手册
  • 善用 command --help 查看简要帮助
  • 善用 Ctrl + R 搜索历史命令

记住：命令行不可怕，可怕的是不敢动手试。打开终端，开始你的 Linux 之旅吧！🐧