第5章文本快速查看与轻量编辑

小林coding2025/9/2大约 27 分钟Linux

05｜文本快速查看与轻量编辑

大家好，我是小林。

想象一下这样的场景：你刚刚运行了一个程序，屏幕上滚动了一堆输出信息，你想仔细查看其中的内容。或者你收到了一个配置文件，需要快速查看并修改其中的某些参数。这时候，如何在命令行中高效地处理这些文本文件呢？

在 Linux 系统中，文本文件是信息的主要载体。无论是配置文件、日志文件，还是代码文件，都需要我们能够快速查看、搜索和编辑。这一章我们要学习的，就是这些日常文本处理的必备技能。掌握了这些，你就能像翻阅书籍一样轻松处理 Linux 系统中的各种文本文件。

5.1 文件查看的艺术：选择合适的工具

在 Linux 系统中，文本文件处理是我们日常工作中最常接触的任务之一。想象一下，你正在处理一个系统日志文件，需要快速定位错误信息；或者你收到了一个配置文件，需要查看其中的设置参数。不同的场景需要不同的查看策略，就像阅读一本书一样，有时候你想快速浏览全书，有时候想仔细研读某个章节，有时候只想看看开头和结尾。

Linux 提供了多个文件查看工具，每个工具都有其独特的优势和使用场景。选择合适的工具不仅能让你的工作更高效，还能避免不必要的麻烦。

cat：简单直接的文件查看器

cat 命令是 Linux 中最基础的文件查看工具，它的名字来源于 "concatenate"（连接）。就像把一本书的所有页面一次性摊开在你面前，cat 会将整个文件的内容一次性显示出来。

让我们先创建一个测试文件来理解 cat 的工作方式：

# 创建一个简单的测试文件
$ echo "第一行内容" > test.txt
$ echo "第二行内容" >> test.txt
$ echo "第三行内容" >> test.txt

# 使用 cat 查看文件
$ cat test.txt
第一行内容
第二行内容
第三行内容

看起来很简单，对吧？但 cat 的真正威力在于它的多功能性。它不仅可以查看文件，还能连接多个文件：

# 创建两个文件
$ echo "文件A的内容" > fileA.txt
$ echo "文件B的内容" > fileB.txt

# 连接两个文件
$ cat fileA.txt fileB.txt > combined.txt
$ cat combined.txt
文件A的内容
文件B的内容

cat 的实用技巧：

# 显示行号 - 这在调试代码时特别有用
$ cat -n test.txt
     1	第一行内容
     2	第二行内容
     3	第三行内容

# 显示特殊字符 - 帮助发现隐藏的格式问题
$ cat -A test.txt
第一行内容$
第二行内容$
第三行内容$
# $ 符号表示行尾，帮助你看到每行的结束位置

# 反向显示 - 有时候从后往前看更有帮助
$ cat -n test.txt | tac
     3	第三行内容
     2	第二行内容
     1	第一行内容

cat 的局限性：想象一下，如果你要查看一个 10MB 的日志文件，使用 cat 会怎样？屏幕会快速滚动，你根本看不清内容。这就是为什么我们需要 less。

less：强大的分页查看器

less 就像是为阅读大文件而设计的电子书阅读器。它让你能够逐页浏览，前后翻页，搜索关键词，甚至跳转到特定位置。这个名字很有趣——它是 more 命令的改进版，开发者幽默地称之为 "less is more"（少即是多）。

让我们来体验 less 的强大功能：

# 打开一个较大的日志文件
$ less /var/log/syslog

在 less 中，你可以使用以下快捷键：

快捷键	功能描述
空格键 / PageDown	向下翻一页
b / PageUp	向上翻一页
/ 关键词	向下搜索关键词
? 关键词	向上搜索关键词
n	跳到下一个搜索结果
N	跳到上一个搜索结果
G	跳到文件末尾
g	跳到文件开头
q	退出 less

less 的高级技巧：

# 打开文件时直接跳到末尾 - 查看最新日志
$ less +G /var/log/syslog

# 打开文件时搜索特定关键词
$ less +/error /var/log/syslog

# 显示行号 - 便于定位问题
$ less -N /var/log/syslog

# 不退出 less 的情况下查看其他文件
$ less file1.txt
# 在 less 中输入 :e file2.txt 切换文件

为什么 less 比 cat 更适合大文件？

想象一下，cat 就像是把整本书一次性倒给你，而 less 就像是让你自己翻页阅读。对于大文件，less 只会加载当前显示的内容，内存占用更少，响应更快，而且提供了丰富的导航功能。

head 和 tail：精准定位文件的头部和尾部

有时候你并不需要查看整个文件，而是对文件的特定部分感兴趣。比如，你可能想看看配置文件的开头几行，或者日志文件的最新几条记录。这时候 head 和 tail 就派上用场了。

# 查看文件开头（默认 10 行）
$ head test.txt
第一行内容
第二行内容
第三行内容

# 查看文件前 3 行
$ head -n 3 test.txt
第一行内容
第二行内容
第三行内容

# 查看文件末尾（默认 10 行）
$ tail test.txt
第一行内容
第二行内容
第三行内容

# 查看文件末尾 2 行
$ tail -n 2 test.txt
第二行内容
第三行内容

实际应用场景：

# 查看系统信息的前 5 行
$ head -n 5 /proc/cpuinfo

# 查看用户登录记录的最后 10 条
$ tail -n 10 /var/log/auth.log

# 查看文件的开头和结尾（对比差异）
$ head -n 5 large_file.txt
$ tail -n 5 large_file.txt

tail -f：实时监控文件变化

这是 tail 命令最强大的功能之一，也是系统管理员最常用的工具之一。tail -f 会持续监控文件的变化，实时显示新增的内容。

# 实时监控系统日志
$ tail -f /var/log/syslog

# 这会持续显示文件的新增内容
# 按 Ctrl+C 退出监控

tail -f 的实际应用：

# 监控 Web 服务器访问日志
$ tail -f /var/log/nginx/access.log

# 监控应用错误日志
$ tail -f /var/log/myapp/error.log

# 同时监控多个日志文件
$ tail -f /var/log/syslog /var/log/auth.log

为什么 tail -f 如此重要？

想象一下你正在调试一个 Web 应用，你修改了代码后想看看是否有错误出现。如果没有 tail -f，你需要不断地手动查看日志文件，效率很低。而 tail -f 让你能够实时看到错误信息，大大提高了调试效率。

实际工作中的文件查看策略

让我们通过一个实际的例子来理解如何选择合适的查看工具：

场景1：查看配置文件

# 小配置文件，用 cat 一次性查看
$ cat /etc/hosts

# 大配置文件，用 less 分页查看
$ less /etc/nginx/nginx.conf

场景2：分析日志文件

# 查看最新的错误信息
$ tail -n 50 /var/log/syslog

# 实时监控日志
$ tail -f /var/log/syslog

# 搜索特定的错误信息
$ less /var/log/syslog
# 在 less 中输入 /error 搜索

场景3：查看系统信息

# 查看系统版本信息
$ cat /etc/os-release

# 查看进程信息的前几行
$ head -n 20 /proc/meminfo

最佳实践建议：

小文件用 cat：文件内容少于一屏时，cat 是最快的选择
大文件用 less：文件内容超过一屏时，less 提供更好的阅读体验
看头尾用 head/tail：只需要查看文件的开头或结尾时，使用 head 或 tail
实时监控用 tail -f：需要持续关注文件变化时，tail -f 是最佳选择

记住，选择合适的工具不仅能让你的工作更高效，还能避免不必要的麻烦。随着经验的积累，你会自然而然地形成自己的文件查看策略。

5.2 文本分析的智慧：统计、分割与标记

在处理文本文件时，我们经常需要了解文件的基本特征，比如文件有多大、有多少行、包含多少单词。有时候我们还需要将大文件分割成小文件，或者为文件添加行号以便于阅读。这些操作就像是给文件做"体检"和"手术"，让我们能够更好地理解和处理文本数据。

wc：文件的智能统计师

wc 命令就像是文件的私人医生，它能快速为你提供文件的"健康报告"——行数、单词数、字节数等基本信息。这些统计信息在很多场景下都非常有用。

让我们通过一个实际的例子来理解 wc 的价值：

# 创建一个测试文件
$ echo "Hello World" > hello.txt
$ echo "Linux is awesome" >> hello.txt
$ echo "Command line tools" >> hello.txt

# 获取文件的完整统计信息
$ wc hello.txt
 3  9 45 hello.txt
# 输出格式：行数  单词数  字节数  文件名

这个简单的输出告诉我们：文件有 3 行，9 个单词，45 个字节。看起来很简单，但这些信息在实际工作中非常有用。

wc 的实际应用场景：

# 只统计行数 - 最常用的用法
$ wc -l hello.txt
3 hello.txt

# 只统计单词数 - 估算文章长度
$ wc -w hello.txt
9 hello.txt

# 只统计字节数 - 检查文件大小
$ wc -c hello.txt
45 hello.txt

# 统计字符数（包括空格）
$ wc -m hello.txt
45 hello.txt

# 统计最长行的长度
$ wc -L hello.txt
17 hello.txt

为什么这些统计信息很重要？

想象一下这些实际场景：

代码质量检查：wc -l *.py 可以快速统计每个 Python 文件的行数，帮助识别过于复杂的文件
日志分析：wc -l access.log 可以了解网站的访问量
内容管理：wc -w article.txt 可以估算文章的字数
性能监控：wc -c large_file.txt 可以快速了解文件大小

批量文件统计：

# 统计多个文件的总计
$ wc hello.txt another.txt
  3   9  45 hello.txt
  5  12  60 another.txt
  8  21 105 total

# 统计目录下所有文本文件的总行数
$ wc -l *.txt | tail -1
 25 total

# 找出最大的文件
$ wc -l *.txt | sort -nr | head -5

split：智能文件分割器

有时候我们需要处理非常大的文件，比如几个 GB 的日志文件。直接处理这样的文件可能会很慢，甚至导致内存不足。这时候 split 命令就派上用场了，它就像是文件的外科医生，能够精确地将大文件分割成易于管理的小文件。

让我们创建一个大文件来演示 split 的用法：

# 创建一个包含 100 行的大文件
$ seq 1 100 > large_file.txt

# 按行数分割（每 30 行一个文件）
$ split -l 30 large_file.txt small_part_
$ ls small_part_*
small_part_aa  small_part_ab  small_part_ac  small_part_ad

# 检查分割结果
$ wc -l small_part_*
 30 small_part_aa
 30 small_part_ab
 30 small_part_ac
 10 small_part_ad
100 total

split 的多种分割方式：

# 按文件大小分割（每 1KB 一个文件）
$ split -b 1K large_file.txt size_part_

# 按文件大小分割（每 1MB 一个文件）
$ split -b 1M huge_file.txt mega_part_

# 按行数分割并使用数字后缀
$ split -d -l 1000 large_file.txt part_
# 这样会生成 part_00, part_01, part_02...

# 自定义后缀长度
$ split -a 3 -l 1000 large_file.txt part_
# 这样会生成 part_aaa, part_aab, part_aac...

split 的实际应用场景：

日志文件处理：将大型日志文件分割成小文件，便于分析
数据传输：将大文件分割成小块，便于网络传输
并行处理：将大文件分割后，可以并行处理提高效率
备份管理：将大备份文件分割成标准大小的块

安全分割的技巧：

# 分割前先检查文件大小
$ wc -l large_file.txt
100000 large_file.txt

# 分割时显示进度
$ split -l 10000 large_file.txt part_ && echo "分割完成"

# 验证分割结果
$ wc -l part_* | tail -1
100000 total

综合应用：文本处理工作流

让我们通过一个实际的工作流程来综合运用这些工具：

场景：分析大型日志文件

# 1. 首先了解文件大小
$ wc -l large_log.txt
50000 large_log.txt

# 2. 将文件分割成小文件
$ split -l 5000 large_log.txt log_part_

# 3. 统计处理结果
$ wc -l log_part_*

场景：代码质量检查

# 1. 统计所有 Python 文件的行数
$ wc -l *.py | sort -nr

# 2. 找出可能过大的文件
$ wc -l *.py | awk '$1 > 500 {print $2}'

这些工具组合起来，能够帮助我们更好地理解和处理文本文件。记住，工具的选择应该基于具体的需求：

需要快速了解文件大小？ 用 wc
需要处理大文件？ 用 split

随着实践的深入，你会发现自己能够熟练地运用这些工具来解决各种文本处理问题。

5.3 命令行编辑的艺术：nano 编辑器

在 Linux 命令行环境中，我们不仅需要查看文件，还需要能够编辑文件。想象一下，你正在配置一个 Web 服务器，需要修改配置文件；或者你正在编写一个简单的脚本，需要快速编辑代码。这时候，一个好的命令行编辑器就显得尤为重要。

为什么选择 nano？

在 Linux 世界中，有两个主要的命令行编辑器：vim 和 nano。Vim 功能强大但学习曲线陡峭，而 nano 则以其简单直观的特点成为新手的最佳选择。就像学习驾驶一样，你可以选择手动挡的跑车（vim）或自动挡的家庭轿车（nano）——两者都能带你到达目的地，但 nano 显然更容易上手。

nano 的入门体验

让我们开始体验 nano 的简单易用：

# 创建并编辑一个新文件
$ nano my_first_file.txt

当你运行这个命令时，你会看到一个干净的编辑界面，最显著的特点是屏幕底部有完整的快捷键提示：

^G 获取帮助  ^O 写入     ^R 读档     ^Y 上一页   ^K 剪切文字  ^C 位置显示
^X 退出      ^J 对齐     ^W 搜索     ^V 下一页   ^U 粘贴文字  ^T 拼写检查

这里的 ^ 符号代表 Ctrl 键，所以 ^G 就是 Ctrl+G。这种直观的提示让新手无需记忆复杂的命令。

nano 的核心操作

让我们通过一个实际的例子来学习 nano 的基本操作：

# 创建一个简单的配置文件
$ nano config.txt

在 nano 编辑器中输入以下内容：

# Web 服务器配置文件
# 这是一个示例配置

server {
    listen 80;
    server_name localhost;
    
    location / {
        root /var/www/html;
        index index.html;
    }
    
    # 错误页面配置
    error_page 404 /404.html;
    error_page 500 502 503 504 /50x.html;
}

保存文件：

按 Ctrl+O（写入文件）
系统会提示文件名，按 Enter 确认
状态栏会显示"已写入 [文件名]"

退出编辑器：

按 Ctrl+X（退出）
如果文件有修改，系统会询问是否保存
按 Y 确认保存，N 放弃保存，Ctrl+C 取消退出

nano 的实用技巧

导航和编辑：

快捷键	功能描述
Ctrl+C	显示当前光标位置（行号、列号）
Ctrl+W	搜索文本（支持正则表达式）
Ctrl+\	替换文本（查找并替换）
Ctrl+A	跳到行首
Ctrl+E	跳到行尾
Ctrl+Y	上一页
Ctrl+V	下一页

剪切和粘贴：

快捷键	功能描述
Ctrl+K	剪切当前行（连续按可剪切多行）
Ctrl+U	粘贴剪切的文本
Ctrl+6	标记文本开始，然后移动光标选择文本
Ctrl+K	剪切选中的文本

高级搜索功能：

# 在 nano 中按 Ctrl+W 后，可以使用以下选项：
# Ctrl+T：转到指定行号
# Ctrl+C：取消搜索
# Ctrl+Y：查找上一个匹配项
# Ctrl+V：查找下一个匹配项

nano 的高级功能

命令行选项：

选项	功能描述	示例
+行号	打开文件时跳转到指定行	`nano +10 config.txt`
-Y 语法	启用语法高亮	`nano -Y python script.py`
-i	搜索时忽略大小写	`nano -i file.txt`
-B	创建备份文件	`nano -B important_file.txt`
-v	以只读模式打开文件	`nano -v system_file.txt`
-N	显示行号	`nano -N file.txt`

实际的编辑场景：

场景1：快速修改配置文件

# 修改系统配置文件
$ sudo nano /etc/hosts
# 添加新的主机映射
127.0.0.1   myproject.local
# 保存并退出

场景2：编写简单脚本

# 创建一个备份脚本
$ nano backup.sh

# 在编辑器中输入：
#!/bin/bash
# 简单的备份脚本

echo "开始备份..."
cp -r /home/user/documents /backup/
echo "备份完成！"

# 保存后给脚本添加执行权限
$ chmod +x backup.sh

场景3：编辑代码文件

# 编辑 Python 代码
$ nano -Y python myapp.py

# 在编辑器中输入：
#!/usr/bin/env python3

def greet(name):
    return f"Hello, {name}!"

if __name__ == "__main__":
    print(greet("World"))

nano 与其他编辑器的对比

nano vs vim：

特性	nano	vim
学习曲线	平缓	陡峭
操作提示	有	无
功能丰富度	基础	丰富
启动速度	快	快
适用人群	新手	专家

nano vs 图形界面编辑器：

特性	nano	图形编辑器
资源占用	低	高
远程编辑	优秀	困难
批量操作	支持	有限
系统兼容性	广泛	有限

实际工作中的最佳实践

安全编辑重要文件：

# 1. 先备份重要文件
$ cp important_config.conf important_config.conf.bak

# 2. 使用 nano 编辑
$ nano important_config.conf

# 3. 编辑后验证语法（如果是配置文件）
# 例如：sudo nginx -t 来验证 nginx 配置

批量编辑文件：

# 编辑多个相关文件
for file in *.conf; do
    nano "$file"
    # 编辑完一个文件后，再编辑下一个
done

在远程服务器上编辑：

# 通过 SSH 连接到远程服务器
$ ssh user@remote-server

# 在远程服务器上编辑文件
$ nano /etc/nginx/sites-available/default

常见问题与解决方案

问题1：误修改了系统文件

# 解决方案：使用版本控制或备份
$ sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak
$ sudo nano /etc/ssh/sshd_config

问题2：文件权限不足

# 解决方案：使用 sudo
$ sudo nano /etc/hosts

问题3：编辑大文件时性能问题

# 解决方案：对于超大文件，先分割再编辑
$ split -l 10000 huge_file.txt part_
$ nano part_aa

进阶学习路径

当你熟练掌握了 nano 的基本操作后，可以考虑学习更高级的编辑技巧：

掌握快捷键：尝试不依赖鼠标，完全使用键盘操作
学习正则表达式：在搜索和替换中使用正则表达式
自定义配置：创建 ~/.nanorc 文件来自定义 nano 的行为
脚本化编辑：结合其他命令实现批量编辑操作

记住，nano 虽然简单，但它是一个功能完整的文本编辑器。对于大多数日常编辑任务来说，nano 已经足够了。当你需要更强大的功能时，再考虑学习 vim 或 emacs 也不迟。

最重要的是，选择一个你觉得舒适的编辑器，然后坚持使用它。熟练掌握一个工具比浅尝辄止地使用多个工具更有价值。

5.4 数据流的智慧：输入输出重定向与管道

在 Linux 命令行中，每个程序都有三个标准的数据流：标准输入（stdin）、标准输出（stdout）和标准错误（stderr）。默认情况下，程序从键盘读取输入，将输出显示在屏幕上，错误信息也显示在屏幕上。但有时候，我们想要改变这种默认的数据流向——这就是重定向和管道的作用。

理解数据流的概念

想象一下你在厨房里做饭：

标准输入就像是你从冰箱取食材（数据来源）
标准输出就像是你把做好的菜端到餐桌上（正常结果）
标准错误就像是你把失败的食材扔进垃圾桶（错误信息）
重定向就像是改变食材的来源或菜品的去向
管道就像是一个传送带，让多个厨师接力处理食材

输出重定向：掌控程序的输出

输出重定向让我们能够控制程序的输出去向，而不是让它们直接显示在屏幕上。这在很多场景下都非常有用。

基本输出重定向

# 覆盖重定向（>）：清空文件后写入新内容
$ echo "第一行内容" > output.txt
$ cat output.txt
第一行内容

# 再次执行会覆盖原内容
$ echo "新的内容" > output.txt
$ cat output.txt
新的内容

你可能会问："为什么要用 > 而不是直接查看输出？" 想象一下你运行了一个需要 10 分钟才能完成的命令，你不想一直等待在屏幕前，而是想把结果保存下来以后查看。

追加重定向

# 追加重定向（>>）：在文件末尾添加内容
$ echo "第一行" > log.txt
$ echo "第二行" >> log.txt
$ echo "第三行" >> log.txt
$ cat log.txt
第一行
第二行
第三行

实际应用场景：

# 创建日志文件
$ echo "$(date): 系统启动" >> system.log
$ echo "$(date): 用户登录" >> system.log
$ echo "$(date): 程序运行" >> system.log

# 批量记录信息
for i in {1..5}; do
    echo "处理第 $i 个任务" >> task.log
done

错误输出重定向

有时候我们想要单独处理错误信息，比如将错误信息记录到日志文件中：

# 错误输出重定向（2>）
$ ls nonexistent_file 2> error.log
$ cat error.log
ls: cannot access 'nonexistent_file': No such file or directory

# 正常输出仍然显示在屏幕上
$ ls existing_file nonexistent_file 2> error.log
existing_file
$ cat error.log
ls: cannot access 'nonexistent_file': No such file or directory

同时重定向标准输出和错误输出

# 传统语法：将标准错误重定向到标准输出
$ command > output.log 2>&1

# 现代语法：更简洁的写法
$ command &> output.log

# 分别重定向到不同文件
$ command > success.log 2> error.log

为什么需要错误输出重定向？

想象一下你在运行一个重要的备份脚本，你想要：

将正常的备份信息保存到 backup_success.log
将错误信息保存到 backup_error.log
即使有错误，脚本也要继续执行

#!/bin/bash
# 备份脚本示例
backup_files="/home/user/documents /home/user/photos"
backup_dest="/backup"

for source_dir in $backup_files; do
    echo "备份 $source_dir ..." >> backup_success.log
    rsync -av "$source_dir" "$backup_dest/" >> backup_success.log 2>> backup_error.log
done

echo "备份完成" >> backup_success.log

输入重定向：改变程序的数据来源

输入重定向让我们能够从文件而不是键盘读取输入，这在自动化脚本中非常有用。

基本输入重定向

# 创建一个包含水果名称的文件
$ cat > fruits.txt << EOF
apple
banana
cherry
date
EOF

# 使用输入重定向对水果进行排序
$ sort < fruits.txt
apple
banana
cherry
date

# 统计文件行数
$ wc -l < fruits.txt
4

实际应用场景：

# 批量发送邮件
$ mail -s "系统报告" admin@example.com < report.txt

# 数据库批量导入
$ mysql -u root -p database < backup.sql

# 程序测试
$ ./myprogram < test_input.txt

Here Document：内联文档

Here Document 让我们能够直接在脚本中嵌入多行文本，而不需要创建临时文件：

# 创建一个简单的脚本
$ cat << 'EOF' > hello.sh
#!/bin/bash
# 这是一个简单的问候脚本

echo "Hello, World!"
echo "当前时间：$(date)"
echo "当前用户：$(whoami)"
EOF

# 给脚本添加执行权限
$ chmod +x hello.sh
$ ./hello.sh
Hello, World!
当前时间：2025-09-02 10:30:15
当前用户：user

Here Document 的高级用法：

# 变量替换（默认行为）
$ cat << EOF
当前目录：$(pwd)
当前用户：$(whoami)
EOF

# 禁用变量替换（使用单引号）
$ cat << 'EOF'
这是一个变量：$HOME
EOF

# 缩进处理（使用 <<-）
$ if true; then
    cat <<- EOF
    这是缩进的文本
    缩进会被忽略
    EOF
fi

管道：命令间的数据传送带

管道是 Linux 最强大的功能之一，它让我们能够将多个命令连接起来，形成一个完整的数据处理流水线。

管道的基本概念

# 查看文件内容并搜索关键词
$ cat /var/log/syslog | grep error

# 统计文件行数
$ cat large_file.txt | wc -l

# 查看最常用的 10 个命令
$ history | awk '{print $2}' | sort | uniq -c | sort -nr | head -10

管道的工作原理：

想象一下这是一个数据处理工厂：

history 产生原始数据（命令历史）
awk '{print $2}' 提取命令名称（第一道工序）
sort 将相同命令排列在一起（第二道工序）
uniq -c 统计每个命令的使用次数（第三道工序）
sort -nr 按使用次数降序排序（第四道工序）
head -10 显示前 10 个最常用的命令（最终产品）

管道的实际应用

场景1：日志分析

# 分析 Web 服务器日志，找出访问量最大的 IP
$ cat access.log | awk '{print $1}' | sort | uniq -c | sort -nr | head -10

# 监控实时错误日志
$ tail -f /var/log/app.log | grep -i error

# 统计不同 HTTP 状态码的数量
$ cat access.log | awk '{print $9}' | sort | uniq -c | sort -nr

场景2：系统监控

# 监控 CPU 使用率
$ top -b -n 1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1

# 查找占用内存最多的进程
$ ps aux | sort -rk 4 | head -10

# 监控磁盘空间
$ df -h | awk '$5 > 80 {print $6 " 使用率: " $5}'

场景3：文件处理

# 批量重命名文件
$ ls *.old | while read file; do
    mv "$file" "${file%.old}.new"
done

# 查找并删除空文件
$ find . -type f -size 0 | xargs rm -v

# 批量压缩文件
$ find . -name "*.log" -mtime +30 | xargs gzip

重定向与管道的区别

很多人容易混淆这两个概念，让我们澄清一下：

重定向：改变命令与文件之间的关系

# 将命令输出保存到文件
$ ls > file_list.txt

# 从文件读取输入
$ sort < unsorted.txt

管道：改变命令与命令之间的关系

# 将一个命令的输出作为另一个命令的输入
$ ls | sort

# 多个命令的连接
$ cat file.txt | grep keyword | wc -l

实际工作中的最佳实践

创建系统报告：

#!/bin/bash
# 系统报告生成脚本

REPORT_FILE="system_report_$(date +%Y%m%d).txt"

echo "系统报告 - $(date)" > "$REPORT_FILE"
echo "=================" >> "$REPORT_FILE"
echo "" >> "$REPORT_FILE"

echo "磁盘使用情况：" >> "$REPORT_FILE"
df -h >> "$REPORT_FILE"
echo "" >> "$REPORT_FILE"

echo "内存使用情况：" >> "$REPORT_FILE"
free -h >> "$REPORT_FILE"
echo "" >> "$REPORT_FILE"

echo "CPU 信息：" >> "$REPORT_FILE"
lscpu | grep "Model name" >> "$REPORT_FILE"
echo "" >> "$REPORT_FILE"

echo "报告生成完成：$REPORT_FILE"

安全的文件操作：

# 备份重要文件
$ cp important_config.conf important_config.conf.bak

# 测试重定向操作
$ echo "测试内容" > temp_test.txt
$ cat temp_test.txt

# 确认无误后执行实际操作
$ command > important_config.conf

常见陷阱和注意事项

⚠️ 高危操作警告：

# 危险：覆盖重要文件
$ echo "test" > /etc/hosts

# 更危险：清空整个文件
$ > important_file.txt

# 极其危险：在错误目录执行重定向
$ cd / && command > some_file.txt

安全操作建议：

建议内容	具体操作
重要操作前先备份	`cp file.txt file.txt.bak`
使用临时文件测试	先在临时文件上测试命令
确认当前目录	执行重定向前先用 `pwd` 确认位置
使用追加模式	不确定时用 `>>` 而不是 `>`
检查文件权限	确保有写入权限再执行重定向

进阶技巧

进程替换：

# 将命令的输出作为临时文件
$ diff <(ls dir1) <(ls dir2)

# 同时比较两个命令的输出
$ comm <(sort file1.txt) <(sort file2.txt)

命名管道：

# 创建命名管道
$ mkfifo mypipe

# 在一个终端写入
$ echo "Hello" > mypipe

# 在另一个终端读取
$ cat mypipe
Hello

掌握了重定向和管道，你就掌握了 Linux 命令行的精髓。这些工具让你能够灵活地控制数据流，构建强大的数据处理流水线。记住，熟能生巧，多在实际工作中使用这些工具，你会逐渐发现它们的强大威力。

练习题

如何实时监控日志文件并只显示包含 "error" 的行？

查看答案

思路与步骤：使用 tail -f 实时监控文件，通过管道 grep 过滤关键词
示例命令：

# 方法1：实时监控并过滤错误信息
$ tail -f /var/log/syslog | grep -i error

# 方法2：加上一些额外选项，显示行号
$ tail -f /var/log/syslog | grep -n -i error

# 方法3：如果要保存到文件同时查看
$ tail -f /var/log/syslog | grep -i error | tee error_log.txt

grep -i 选项表示忽略大小写，这样能匹配 "error"、"ERROR"、"Error" 等各种形式。tee 命令可以同时在屏幕显示和保存到文件。

如何创建一个脚本来统计某个目录下所有 .txt 文件的总行数？

查看答案

思路与步骤：使用 find 查找文件，wc -l 统计行数，通过管道和 awk 汇总
示例命令：

# 方法1：使用 find 和 wc 组合
$ find . -name "*.txt" -exec wc -l {} \;

# 方法2：更优雅的方式，显示总行数
$ find . -name "*.txt" -exec cat {} \; | wc -l

# 方法3：创建一个脚本文件
$ cat > count_lines.sh << 'EOF'
#!/bin/bash
echo "统计 .txt 文件总行数"
find . -name "*.txt" -exec cat {} \; | wc -l
EOF

$ chmod +x count_lines.sh
$ ./count_lines.sh

第一个方法会显示每个文件的行数，第二个方法直接显示总行数。脚本方式更便于重复使用。

如何使用 nano 编辑器在文件的第 10 行插入新内容？

查看答案

思路与步骤：使用 nano 的行号功能定位到指定行，然后插入内容
示例命令：

# 方法1：打开文件时直接跳转到第 10 行
$ nano +10 filename.txt

# 在 nano 编辑器中：
# 1. 使用 Ctrl+C 查看当前行号
# 2. 移动光标到第 10 行
# 3. 按 Enter 创建新行
# 4. 输入要插入的内容
# 5. 按 Ctrl+O 保存，Ctrl+X 退出

# 方法2：使用命令行方式（适合脚本）
$ sed -i '10i\这是新插入的内容' filename.txt

在 nano 中，你可以使用 Ctrl+C 随时查看当前光标位置，这对精确定位很有帮助。sed 命令更适合在脚本中批量处理。

速记卡

cat file.txt：查看整个文件内容（一次性展示）
less file.txt：分页查看大文件（电子书阅读器）
tail -f file.log：实时监控文件变化（实时观察）
head -n 20 file.txt：查看文件前 20 行（看头部）
wc -l file.txt：统计文件行数（数行数）
nano file.txt：简单编辑文件（新手友好的编辑器）
command > file.txt：重定向输出到文件（保存结果）
command | grep keyword：管道过滤输出（筛选内容）

常见坑

cat 大文件：屏幕快速滚动看不清，应该用 less 分页查看
忘记 tail -f 需要手动退出：用 Ctrl+C 结束监控，不要直接关闭终端
> 和 >> 混淆：> 覆盖文件，>> 追加内容，用错可能导致数据丢失
nano 中直接关闭终端：编辑的内容会丢失，要记得先保存再退出
重定向时忘记备份：重要文件操作前先备份，养成好习惯
管道命令失败：检查前一个命令是否有输出，管道需要数据流
忽略错误输出：某些命令的错误信息很重要，用 2>&1 捕获所有输出
在错误目录操作：重定向文件会保存在当前目录，先用 pwd 确认位置

章节总结

文本文件处理是 Linux 命令行日常使用中最频繁的操作之一。通过掌握 cat、less、head、tail 这些查看命令，你能够根据不同的场景选择合适的工具——小文件用 cat，大文件用 less，看头尾用 head/tail，实时监控用 tail -f。

wc、split、nl 这些工具提供了文本统计和处理的能力，让你能够更好地理解和组织文件内容。而 nano 编辑器则是你修改文件的得力助手，特别是对于新手来说，它的直观操作界面大大降低了学习门槛。

输入输出重定向和管道是 Linux 命令行的精髓所在。重定向让你能够保存命令结果、从文件读取输入，而管道则让你能够将多个命令组合成强大的数据处理流水线。这些工具的组合使用，能让你在命令行环境中高效地处理各种文本任务。

记住，在处理重要文件时一定要小心谨慎。重定向操作会覆盖文件内容，编辑时要记得保存。养成备份重要文件的习惯，这样即使操作失误也能恢复数据。随着实践的积累，这些工具会成为你日常工作中不可或缺的助手。

第5章 文本快速查看与轻量编辑

第5章文本快速查看与轻量编辑