一、简介

1.1 什么是 grep

grep（Global Regular Expression Print）是一个强大的文本搜索工具，它使用正则表达式搜索文本，并打印匹配的行。

核心特点：

支持正则表达式
高效的文本搜索
支持递归目录搜索
丰富的输出格式选项
可以搜索二进制文件

1.2 grep 家族

┌─────────────────────────────────────────────────────────────────────┐
│                    grep 家族                                        │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌─────────────┐                                                   │
│  │ grep        │  基本正则表达式 (BRE)                              │
│  └─────────────┘                                                   │
│                                                                     │
│  ┌─────────────┐                                                   │
│  │ egrep       │  扩展正则表达式 (ERE) = grep -E                    │
│  └─────────────┘                                                   │
│                                                                     │
│  ┌─────────────┐                                                   │
│  │ fgrep       │  固定字符串 (无正则) = grep -F                     │
│  └─────────────┘                                                   │
│                                                                     │
│  ┌─────────────┐                                                   │
│  │ rgrep       │  递归搜索 = grep -r                                │
│  └─────────────┘                                                   │
│                                                                     │
│  ┌─────────────┐                                                   │
│  │ rg (ripgrep)│  更快的现代替代品                                  │
│  └─────────────┘                                                   │
│                                                                     │
│  ┌─────────────┐                                                   │
│  │ ag (the_silver_searcher)│ 另一个快速替代品                       │
│  └─────────────┘                                                   │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

1.3 工作原理

┌─────────────────────────────────────────────────────────────────────┐
│                    grep 工作流程                                    │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│    输入文件/标准输入                                                │
│         │                                                           │
│         ▼                                                           │
│    ┌─────────────┐                                                 │
│    │  读取一行   │                                                 │
│    └──────┬──────┘                                                 │
│           │                                                         │
│           ▼                                                         │
│    ┌─────────────┐                                                 │
│    │  编译正则   │                                                 │
│    └──────┬──────┘                                                 │
│           │                                                         │
│           ▼                                                         │
│    ┌─────────────┐    匹配    ┌─────────────┐                      │
│    │  匹配测试   │ ─────────► │  输出结果   │                      │
│    └──────┬──────┘            └─────────────┘                      │
│           │ 不匹配                                                │
│           ▼                                                         │
│    ┌─────────────┐                                                 │
│    │  跳过此行   │                                                 │
│    └──────┬──────┘                                                 │
│           │                                                         │
│           ▼                                                         │
│    ┌─────────────┐                                                 │
│    │  还有行？   │ ──Yes──► 读取下一行                             │
│    └─────────────┘                                                 │
│           │ No                                                      │
│           ▼                                                         │
│         结束                                                        │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

二、安装

2.1 各平台安装

Linux

# Debian/Ubuntu
sudo apt update
sudo apt install grep

# CentOS/RHEL
sudo yum install grep

# Alpine
apk add grep

# Arch Linux
sudo pacman -S grep

macOS

# macOS 自带 grep (BSD grep)
# 建议安装 GNU grep
brew install grep

# 使用 ggrep 命令
ggrep --version

# 或创建别名
alias grep='ggrep'

Windows

# Coreutils
winget install Microsoft.Coreutils

# Git Bash 自带 grep

# 或通过 Chocolatey
choco install grep

# 或使用 WSL
wsl grep

# 或使用 findstr（Windows 内置）
findstr "pattern" file.txt

2.2 验证安装

grep --version
# 输出: grep (GNU grep) 3.7

# 测试运行
echo "hello world" | grep "hello"
# 输出: hello world

2.3 GNU grep vs BSD grep

# GNU grep (Linux)
# 选项更多，功能更全
grep -P 'pattern' file.txt  # Perl 正则

# BSD grep (macOS)
# 部分选项不同
# 不支持 -P（Perl 正则）

# 兼容建议
# 使用基本选项，避免 GNU 特有功能

三、基础语法

3.1 命令格式

grep [选项] 模式 [文件...]

# 基本搜索
grep "pattern" file.txt

# 多个文件
grep "pattern" file1.txt file2.txt

# 使用管道
cat file.txt | grep "pattern"
command | grep "pattern"

# 递归搜索
grep -r "pattern" /path/to/dir/

3.2 常用选项

搜索控制

选项	说明	示例
`-E`	扩展正则表达式	`grep -E 'a\|b'`
`-F`	固定字符串（无正则）	`grep -F 'a.*b'`
`-G`	基本正则表达式（默认）	`grep -G 'pattern'`
`-P`	Perl 正则表达式	`grep -P '\d+'`
`-e`	指定多个模式	`grep -e 'a' -e 'b'`
`-f`	从文件读取模式	`grep -f patterns.txt`
`-i`	忽略大小写	`grep -i 'hello'`
`-v`	反向匹配（不匹配）	`grep -v 'pattern'`
`-w`	匹配整个单词	`grep -w 'word'`
`-x`	匹配整行	`grep -x 'line'`

输出控制

选项	说明	示例
`-c`	只输出匹配行数	`grep -c 'pattern'`
`-l`	只输出文件名	`grep -l 'pattern' *.txt`
`-L`	只输出不匹配的文件名	`grep -L 'pattern' *.txt`
`-m N`	匹配 N 次后停止	`grep -m 10 'pattern'`
`-o`	只输出匹配部分	`grep -o 'pattern'`
`-q`	静默模式	`grep -q 'pattern'`
`-s`	抑制错误消息	`grep -s 'pattern'`

输出格式

选项	说明	示例
`-b`	显示字节偏移	`grep -b 'pattern'`
`-H`	显示文件名	`grep -H 'pattern'`
`-h`	不显示文件名	`grep -h 'pattern'`
`-n`	显示行号	`grep -n 'pattern'`
`-T`	制表符分隔	`grep -T 'pattern'`
`-Z`	文件名后加 NUL	`grep -Z 'pattern'`
`--color`	彩色输出	`grep --color 'pattern'`

上下文控制

选项	说明	示例
`-A N`	显示后 N 行	`grep -A 3 'pattern'`
`-B N`	显示前 N 行	`grep -B 3 'pattern'`
`-C N`	显示前后各 N 行	`grep -C 3 'pattern'`
`--group-separator`	组分隔符	`grep --group-separator='---'`

文件和目录

选项	说明	示例
`-r`	递归搜索	`grep -r 'pattern' dir/`
`-R`	递归搜索（跟随符号链接）	`grep -R 'pattern' dir/`
`--include`	包含文件模式	`grep --include='*.txt'`
`--exclude`	排除文件模式	`grep --exclude='*.log'`
`--exclude-dir`	排除目录	`grep --exclude-dir='.git'`
`-a`	处理二进制文件	`grep -a 'pattern' bin`
`-I`	跳过二进制文件	`grep -I 'pattern'`

四、基础操作

4.1 基本搜索

简单搜索

# 在文件中搜索
grep "hello" file.txt

# 忽略大小写
grep -i "hello" file.txt
grep -i "HELLO" file.txt  # 同上

# 显示行号
grep -n "hello" file.txt
# 输出: 3:hello world

# 只显示匹配部分
grep -o "hello" file.txt

# 显示匹配次数
grep -c "hello" file.txt

多文件搜索

# 搜索多个文件
grep "hello" file1.txt file2.txt file3.txt

# 使用通配符
grep "hello" *.txt

# 显示文件名
grep -H "hello" *.txt
# 输出: file1.txt:hello

# 只显示匹配的文件名
grep -l "hello" *.txt
# 输出: file1.txt

# 只显示不匹配的文件名
grep -L "hello" *.txt

# 递归搜索目录
grep -r "hello" /path/to/dir/

# 递归并显示行号
grep -rn "hello" /path/to/dir/

反向搜索

# 查找不匹配的行
grep -v "hello" file.txt

# 查找不包含某个词的行
grep -v "error" log.txt

# 排除空行
grep -v "^$" file.txt

# 排除注释行
grep -v "^#" file.txt

# 多条件排除
grep -v -e "^#" -e "^$" file.txt

4.2 单词和行匹配

# 匹配整个单词
echo "hello helloworld" | grep -w "hello"
# 输出: hello helloworld（高亮第一个 hello）
# 注意：只匹配独立的 "hello"

# 实际效果
echo "hello world helloworld" | grep -ow "hello"
# 输出: hello（只输出匹配的单词）

# 匹配整行
grep -x "exact line content" file.txt

# 匹配空行
grep -x "" file.txt

4.3 上下文显示

# 显示匹配行及后 3 行
grep -A 3 "pattern" file.txt

# 显示匹配行及前 3 行
grep -B 3 "pattern" file.txt

# 显示匹配行及前后各 3 行
grep -C 3 "pattern" file.txt

# 组合使用
grep -A 2 -B 2 "pattern" file.txt

# 无限上下文（显示所有行）
grep --context=999999 "pattern" file.txt

# 添加分隔符
grep --group-separator="---" -C 2 "pattern" file.txt

4.4 统计与计数

# 统计匹配行数
grep -c "pattern" file.txt

# 统计多个文件
grep -c "pattern" *.txt

# 统计匹配单词数
grep -o "word" file.txt | wc -l

# 统计每个文件的匹配数
for f in *.txt; do echo "$f: $(grep -c 'pattern' "$f")"; done

# 使用 awk 统计
grep -c "pattern" *.txt | awk -F: '{sum+=$2} END {print sum}'

4.5 颜色高亮

# 启用颜色
grep --color "pattern" file.txt

# 自动颜色（推荐）
grep --color=auto "pattern" file.txt

# 总是显示颜色
grep --color=always "pattern" file.txt

# 永不显示颜色
grep --color=never "pattern" file.txt

# 自定义颜色
export GREP_COLORS='ms=01;31:mc=01;31:sl=:cx=:fn=35:ln=32:bn=32:se=36'
grep --color "pattern" file.txt

# 常用设置（添加到 ~/.bashrc）
alias grep='grep --color=auto'

五、正则表达式

5.1 基本正则表达式 (BRE)

# 基本字符匹配
grep "hello" file.txt          # 匹配 hello
grep "h.llo" file.txt          # . 匹配任意单个字符
grep "h*llo" file.txt          # * 匹配前一个字符 0 次或多次

# 行首行尾
grep "^hello" file.txt         # 匹配行首的 hello
grep "world$" file.txt         # 匹配行尾的 world
grep "^hello world$" file.txt  # 匹配整行

# 字符类
grep "[abc]" file.txt          # 匹配 a 或 b 或 c
grep "[a-z]" file.txt          # 匹配任意小写字母
grep "[0-9]" file.txt          # 匹配任意数字
grep "[A-Za-z]" file.txt       # 匹配任意字母

# 排除字符类
grep "[^abc]" file.txt         # 匹配不是 a、b、c 的字符
grep "[^0-9]" file.txt         # 匹配非数字字符

# 转义字符
grep "a\.b" file.txt           # 匹配 a.b（字面点号）
grep "a\*b" file.txt           # 匹配 a*b（字面星号）
grep "\^hello" file.txt        # 匹配 ^hello（字面插入符）

# 词首词尾锚定
grep "\<hello" file.txt        # 匹配以 hello 开头的单词
grep "world\>" file.txt        # 匹配以 world 结尾的单词
grep "\<hello\>" file.txt      # 匹配单词 hello

5.2 扩展正则表达式 (ERE)

# 使用 -E 选项或 egrep
grep -E "pattern" file.txt
egrep "pattern" file.txt

# 扩展元字符
grep -E "a+" file.txt          # + 匹配 1 次或多次
grep -E "a?" file.txt          # ? 匹配 0 次或 1 次
grep -E "a{3}" file.txt        # {n} 匹配恰好 n 次
grep -E "a{3,}" file.txt       # {n,} 匹配至少 n 次
grep -E "a{3,5}" file.txt      # {n,m} 匹配 n 到 m 次

# 分组和引用
grep -E "(ab)+" file.txt       # () 分组
grep -E "(ab)\1" file.txt      # \1 引用第一组
grep -E "(a)(b)\1\2" file.txt  # 多个引用

# 或运算
grep -E "cat|dog" file.txt     # 匹配 cat 或 dog
grep -E "(cat|dog)s" file.txt  # 匹配 cats 或 dogs
grep -E "^(cat|dog)" file.txt  # 匹配以 cat 或 dog 开头

# 组合示例
grep -E "[0-9]{3}-[0-9]{4}" file.txt    # 匹配 123-4567
grep -E "[a-z]+@[a-z]+\.[a-z]+" file.txt  # 简单邮箱匹配
grep -E "^(http|https|ftp)://" file.txt   # URL 协议

5.3 Perl 正则表达式 (PCRE)

# 使用 -P 选项（仅 GNU grep）
grep -P "pattern" file.txt

# Perl 特性
grep -P "\d" file.txt          # \d 数字
grep -P "\D" file.txt          # \D 非数字
grep -P "\w" file.txt          # \w 单词字符
grep -P "\W" file.txt          # \W 非单词字符
grep -P "\s" file.txt          # \s 空白字符
grep -P "\S" file.txt          # \S 非空白字符
grep -P "\bword\b" file.txt    # \b 单词边界

# 前瞻后顾
grep -P "foo(?=bar)" file.txt  # 正前瞻：foo 后面是 bar
grep -P "foo(?!bar)" file.txt  # 负前瞻：foo 后面不是 bar
grep -P "(?<=foo)bar" file.txt # 正后顾：bar 前面是 foo
grep -P "(?<!foo)bar" file.txt # 负后顾：bar 前面不是 foo

# 常用模式
grep -P "\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b" file.txt  # IP 地址
grep -P "\b[\w.+-]+@[\w.-]+\.[a-z]{2,}\b" file.txt        # 邮箱
grep -P "https?://[\w./%-]+" file.txt                     # URL

5.4 字符类

POSIX 字符类

# POSIX 字符类（适用于所有正则类型）
grep "[[:alpha:]]" file.txt    # 字母
grep "[[:digit:]]" file.txt    # 数字
grep "[[:alnum:]]" file.txt    # 字母和数字
grep "[[:space:]]" file.txt    # 空白字符
grep "[[:punct:]]" file.txt    # 标点符号
grep "[[:upper:]]" file.txt    # 大写字母
grep "[[:lower:]]" file.txt    # 小写字母
grep "[[:cntrl:]]" file.txt    # 控制字符
grep "[[:print:]]" file.txt    # 可打印字符
grep "[[:graph:]]" file.txt    # 可见字符
grep "[[:blank:]]" file.txt    # 空格和制表符
grep "[[:xdigit:]]" file.txt   # 十六进制数字

5.5 实用正则示例

# 邮箱
grep -E "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}" file.txt
grep -P "\b[\w.+-]+@[\w.-]+\.[a-z]{2,}\b" file.txt

# IP 地址
grep -E "[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}" file.txt
grep -P "\b\d{1,3}(\.\d{1,3}){3}\b" file.txt

# URL
grep -E "https?://[^[:space:]]+" file.txt
grep -P "https?://[\w./%-]+" file.txt

# 手机号（中国）
grep -E "1[3-9][0-9]{9}" file.txt
grep -P "\b1[3-9]\d{9}\b" file.txt

# 日期（YYYY-MM-DD）
grep -E "[0-9]{4}-[0-9]{2}-[0-9]{2}" file.txt

# 时间（HH:MM:SS）
grep -E "[0-9]{2}:[0-9]{2}:[0-9]{2}" file.txt

# 十六进制颜色
grep -E "#[0-9a-fA-F]{6}" file.txt
grep -E "#[0-9a-fA-F]{3,6}" file.txt

# HTML 标签
grep -E "<[^>]+>" file.txt
grep -E "</?[a-z][a-z0-9]*[^>]*>" file.txt

# IPv6（简化版）
grep -P "[0-9a-fA-F:]{3,}" file.txt

# MAC 地址
grep -E "([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}" file.txt

# 身份证号（中国）
grep -E "[0-9]{17}[0-9Xx]" file.txt

# 信用卡号
grep -E "[0-9]{4}[- ]?[0-9]{4}[- ]?[0-9]{4}[- ]?[0-9]{4}" file.txt

# 邮编（中国）
grep -E "[0-9]{6}" file.txt

# 密码强度（至少 8 位，含大小写和数字）
grep -P "^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$" file.txt

六、高级选项

6.1 多模式搜索

使用 -e 选项

# 搜索多个模式（或关系）
grep -e "hello" -e "world" file.txt

# 等价于
grep -E "hello|world" file.txt

# 多个 -e 可以组合其他选项
grep -e "error" -e "warning" -e "critical" log.txt

使用 -f 选项

# 从文件读取模式
cat > patterns.txt << EOF
hello
world
pattern
EOF

grep -f patterns.txt file.txt

# 结合其他选项
grep -i -f patterns.txt file.txt

# 反向匹配
grep -v -f patterns.txt file.txt

6.2 文件过滤

包含/排除文件

# 只搜索 .txt 文件
grep -r --include="*.txt" "pattern" dir/

# 排除 .log 文件
grep -r --exclude="*.log" "pattern" dir/

# 多个模式
grep -r --include="*.txt" --include="*.md" "pattern" dir/
grep -r --exclude="*.log" --exclude="*.tmp" "pattern" dir/

# 使用通配符
grep -r --include="*.py" --include="*.js" "pattern" src/

排除目录

# 排除 .git 目录
grep -r --exclude-dir=".git" "pattern" .

# 排除多个目录
grep -r --exclude-dir={.git,node_modules,vendor} "pattern" .

# 排除目录模式
grep -r --exclude-dir=".*" "pattern" .  # 排除所有隐藏目录

# 常用组合
grep -r --exclude-dir={.git,.svn,node_modules} --exclude="*.min.js" "pattern" .

6.3 二进制文件处理

# 默认行为：显示匹配的二进制文件名
grep "pattern" binary_file

# 像处理文本一样处理
grep -a "pattern" binary_file

# 跳过二进制文件
grep -I "pattern" .

# 只显示二进制文件是否匹配
grep -q "pattern" binary_file && echo "Found"

# 在二进制文件中查找文本
strings binary_file | grep "pattern"

6.4 行为控制

匹配次数限制

# 只匹配前 10 次
grep -m 10 "pattern" file.txt

# 每个文件只匹配 1 次
grep -m 1 "pattern" *.txt

# 结合递归
grep -r -m 1 "pattern" dir/

退出状态码

# 0: 找到匹配
# 1: 未找到匹配
# 2: 发生错误

# 在脚本中使用
if grep -q "pattern" file.txt; then
    echo "Found"
else
    echo "Not found"
fi

# 静默检查
grep -q "pattern" file.txt && echo "Found"

# 检查多个文件
grep -q "pattern" file.txt file2.txt
echo $?  # 0: 至少一个文件匹配

6.5 输出控制

只显示文件名

# 显示包含匹配的文件
grep -l "pattern" *.txt

# 显示不包含匹配的文件
grep -L "pattern" *.txt

# 结合递归
grep -rl "pattern" dir/
grep -rL "pattern" dir/

# 统计文件数
grep -rl "pattern" dir/ | wc -l

只显示匹配部分

# 只输出匹配的字符串
grep -o "pattern" file.txt

# 统计匹配次数
grep -o "pattern" file.txt | wc -l

# 结合行号
grep -n -o "pattern" file.txt

# 只显示匹配部分（带行号和偏移）
grep -b -o "pattern" file.txt

行号和偏移

# 显示行号
grep -n "pattern" file.txt

# 显示字节偏移
grep -b "pattern" file.txt

# 同时显示
grep -n -b "pattern" file.txt

# 输出格式
# 行号:字节偏移:内容

七、搜索技巧

7.1 递归搜索

基本递归

# 递归搜索
grep -r "pattern" dir/

# 跟随符号链接
grep -R "pattern" dir/

# 显示行号
grep -rn "pattern" dir/

# 只显示文件名
grep -rl "pattern" dir/

带过滤的递归

# 只搜索 Python 文件
grep -r --include="*.py" "pattern" dir/

# 排除日志文件
grep -r --exclude="*.log" "pattern" dir/

# 排除目录
grep -r --exclude-dir={.git,node_modules} "pattern" .

# 完整示例
grep -rn \
    --include="*.py" \
    --include="*.js" \
    --exclude-dir={.git,node_modules,vendor} \
    --exclude="*.min.js" \
    "pattern" src/

7.2 组合搜索

与其他命令组合

# 结合 find
find . -name "*.txt" -exec grep "pattern" {} +

# 结合 xargs
find . -name "*.txt" | xargs grep "pattern"

# 结合 sort
grep "pattern" file.txt | sort

# 结合 uniq
grep "pattern" file.txt | sort | uniq -c

# 结合 head/tail
grep "pattern" file.txt | head -10

# 结合 awk/sed
grep "pattern" file.txt | awk '{print $1}'
grep "pattern" file.txt | sed 's/old/new/'

# 多次过滤
grep "pattern1" file.txt | grep "pattern2"

# 统计结果
grep "pattern" file.txt | wc -l

管道技巧

# 查找进程
ps aux | grep "process"
ps aux | grep "[p]rocess"  # 避免匹配 grep 自身

# 查看端口
netstat -tlnp | grep ":80"

# 查看日志
tail -f log.txt | grep --line-buffered "error"

# 实时监控
dmesg -w | grep --line-buffered "usb"

# 组合多个命令
cat file.txt | grep "pattern" | sort | uniq -c | sort -rn | head

7.3 排除技巧

# 排除 grep 自身
ps aux | grep "process" | grep -v "grep"
# 或使用技巧
ps aux | grep "[p]rocess"

# 排除多个模式
grep -v -e "pattern1" -e "pattern2" file.txt

# 排除空行和注释
grep -v -e "^$" -e "^#" file.txt

# 排除特定单词
grep -v "TODO" file.txt

# 使用正则排除
grep -v "^#" file.txt  # 排除以 # 开头的行
grep -v "~$" file.txt  # 排除以 ~ 结尾的文件

7.4 模式组合

# AND（同时匹配两个模式）
grep "pattern1" file.txt | grep "pattern2"

# OR（匹配任一模式）
grep -E "pattern1|pattern2" file.txt
grep -e "pattern1" -e "pattern2" file.txt

# NOT（不匹配模式）
grep -v "pattern" file.txt

# 复杂组合
grep -E "pattern1|pattern2" file.txt | grep -v "pattern3"

# 使用 Perl 正则（仅 GNU grep）
grep -P "pattern1(?=.*pattern2)" file.txt  # pattern1 后有 pattern2

八、实战示例

8.1 日志分析

Apache/Nginx 日志

# 查找特定 IP 的访问
grep "192.168.1.1" access.log

# 统计各状态码数量
grep -o '" [0-9]\{3\}' access.log | sort | uniq -c

# 查找 404 错误
grep '" 404 ' access.log

# 查找特定时间段的日志
grep "01/Jan/2024:10:" access.log

# 查找 POST 请求
grep '"POST ' access.log

# 查找慢请求（响应时间 > 1s）
grep -E '" [0-9]{3} [0-9]+ [1-9][0-9]*\.[0-9]' access.log

# 提取 User-Agent
grep -o '" "[^"]*"$' access.log | sort | uniq -c | sort -rn | head

# 统计每个 IP 的访问次数
awk '{print $1}' access.log | sort | uniq -c | sort -rn | head
# 或使用 grep
grep -oE '^[0-9.]+' access.log | sort | uniq -c | sort -rn | head

应用日志

# 查找错误
grep -i "error" app.log

# 查找异常
grep -i "exception" app.log

# 查找特定级别的日志
grep "\[ERROR\]" app.log
grep "\[WARN\]" app.log

# 查找特定时间
grep "2024-01-01 10:" app.log

# 统计各级别日志数量
grep -oE '\[(ERROR|WARN|INFO|DEBUG)\]' app.log | sort | uniq -c

# 查找包含特定文本的错误
grep "error.*database" app.log

# 提取错误堆栈
grep -A 10 "Exception" app.log

系统日志

# 查找登录失败
grep "Failed password" /var/log/auth.log

# 查找 sudo 使用
grep "sudo:" /var/log/auth.log

# 查找服务启动
grep "Started\|Starting" /var/log/syslog

# 查找磁盘错误
grep -i "disk\|I/O error" /var/log/syslog

# 查找内核消息
grep "kernel:" /var/log/syslog

# 实时监控日志
tail -f /var/log/syslog | grep --line-buffered "error"

8.2 代码搜索

代码内容搜索

# 在代码中搜索函数定义
grep -rn "def function_name" src/

# 搜索 TODO 注释
grep -rn "TODO\|FIXME" src/

# 搜索特定模式
grep -rn "import.*requests" *.py

# 搜索类定义
grep -rn "class.*:" *.py

# 搜索函数调用
grep -rn "function_name(" src/

# 搜索字符串
grep -rn '".*error.*"' src/

搜索配置

# 查找配置项
grep -rn "DATABASE_URL" .

# 查找 API 密钥（注意安全）
grep -rn "api_key\|apikey\|API_KEY" .

# 查找密码（检查安全）
grep -rn "password\|PASSWORD" . --include="*.py"

# 查找 URL
grep -rn "http://" . --include="*.py"

代码统计

# 统计代码行数（排除空行和注释）
grep -v -e "^$" -e "^#" file.py | wc -l

# 统计函数数量
grep -c "^def " file.py

# 统计类数量
grep -c "^class " file.py

# 统计导入
grep "^import\|^from" file.py

8.3 系统管理

进程管理

# 查找进程
ps aux | grep nginx

# 查找端口占用
netstat -tlnp | grep :80
lsof -i :80 | grep LISTEN

# 查找用户进程
ps aux | grep username

# 查找僵尸进程
ps aux | grep Z

# 查找占用 CPU 最高的进程
ps aux --sort=-%cpu | head -10

# 查找占用内存最高的进程
ps aux --sort=-%mem | head -10

文件搜索

# 在文件名中搜索
find . -name "*.log"

# 在文件内容中搜索
grep -r "pattern" .

# 搜索大文件
find . -size +100M

# 搜索最近修改的文件
find . -mtime -1

# 搜索特定权限的文件
find . -perm 755

网络分析

# 查看连接状态
netstat -an | grep ESTABLISHED

# 统计各状态连接数
netstat -an | grep tcp | awk '{print $6}' | sort | uniq -c

# 查看监听端口
netstat -tlnp | grep LISTEN

# 查找特定 IP 的连接
netstat -an | grep "192.168.1.1"

# 查看路由表
route -n | grep default

8.4 文本处理

数据提取

# 提取邮箱
grep -oE "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}" file.txt

# 提取 URL
grep -oE "https?://[^[:space:]]+" file.txt

# 提取 IP 地址
grep -oE "[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}" file.txt

# 提取日期
grep -oE "[0-9]{4}-[0-9]{2}-[0-9]{2}" file.txt

# 提取手机号
grep -oE "1[3-9][0-9]{9}" file.txt

# 提取 JSON 值
grep -oE '"key":\s*"[^"]*"' file.json

数据清洗

# 去除空行
grep -v "^$" file.txt

# 去除注释
grep -v "^#" file.txt

# 去除空白行和注释
grep -v -e "^$" -e "^#" file.txt

# 去除行尾空格
grep -v "^[[:space:]]*$" file.txt

# 提取非空行
grep "." file.txt

数据验证

# 验证邮箱格式
grep -E "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$" emails.txt

# 验证手机号
grep -E "^1[3-9][0-9]{9}$" phones.txt

# 验证 IP 地址
grep -E "^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$" ips.txt

# 验证日期
grep -E "^[0-9]{4}-[0-9]{2}-[0-9]{2}$" dates.txt

8.5 安全检查

敏感信息检测

# 检查密码
grep -rn "password\s*=" . --include="*.py"

# 检查 API 密钥
grep -rn "api_key\s*=" . --include="*.py"

# 检查私钥
grep -rn "PRIVATE KEY" .

# 检查 AWS 凭证
grep -rn "AKIA[0-9A-Z]{16}" .

# 检查数据库连接
grep -rn "mysql://\|postgres://\|mongodb://" .

日志安全检查

# 检查登录失败
grep "Failed password" /var/log/auth.log | grep -v "invalid"

# 检查暴力破解
grep "Failed password" /var/log/auth.log | awk '{print $11}' | sort | uniq -c | sort -rn | head

# 检查成功登录
grep "Accepted password" /var/log/auth.log

# 检查 sudo 使用
grep "COMMAND=" /var/log/auth.log

# 检查新增用户
grep "new user" /var/log/auth.log

九、性能优化

9.1 搜索速度优化

使用正确的选项

# 使用 -F 处理固定字符串（更快）
grep -F "literal string" file.txt

# 限制搜索深度
grep -r --max-depth=3 "pattern" dir/

# 限制匹配次数
grep -m 100 "pattern" large_file.txt

# 跳过二进制文件
grep -I "pattern" .

# 使用 LC_ALL=C 加速
LC_ALL=C grep "pattern" file.txt

减少文件范围

# 只搜索需要的文件类型
grep -r --include="*.py" "pattern" .

# 排除不需要的目录
grep -r --exclude-dir={.git,node_modules,vendor} "pattern" .

# 排除大文件
find . -type f -size -10M -exec grep "pattern" {} +

9.2 内存优化

# 避免一次性读取大文件
grep "pattern" large_file.txt | head

# 使用流式处理
tail -f log.txt | grep --line-buffered "error"

# 分块处理
split -l 100000 large_file.txt chunk_
grep "pattern" chunk_* > result.txt

9.3 替代工具

# ripgrep (rg) - 更快的 grep 替代品
rg "pattern" dir/
rg -t py "pattern"  # 只搜索 Python 文件

# the_silver_searcher (ag)
ag "pattern" dir/
ag --python "pattern"

# ack - 专为程序员设计
ack "pattern"
ack --python "pattern"

# 性能比较
time grep -r "pattern" .
time rg "pattern" .
time ag "pattern" .

9.4 并行搜索

# 使用 GNU parallel
find . -name "*.txt" | parallel grep "pattern" {}

# 使用 xargs -P
find . -name "*.txt" | xargs -P 4 grep "pattern"

# 使用 grep -r（已优化）
grep -r "pattern" .

十、技巧与最佳实践

10.1 实用别名

# 添加到 ~/.bashrc 或 ~/.zshrc

# 彩色输出
alias grep='grep --color=auto'
alias fgrep='fgrep --color=auto'
alias egrep='egrep --color=auto'

# 常用组合
alias gr='grep -rn --color=auto'
alias gri='grep -rni --color=auto'
alias grv='grep -rnv --color=auto'

# 递归搜索
alias grep-recursive='grep -rn --color=auto --exclude-dir={.git,.svn,node_modules}'

# 搜索代码
alias grep-code='grep -rn --color=auto --include="*.py" --include="*.js" --include="*.java"'

10.2 调试技巧

# 显示匹配的行号和文件名
grep -Hn "pattern" file.txt

# 只显示匹配部分（调试正则）
grep -o "pattern" file.txt

# 统计匹配次数
grep -c "pattern" file.txt

# 测试正则表达式
echo "test string" | grep -E "pattern"

# 逐步调试
grep "pattern1" file.txt | grep "pattern2"

10.3 常见陷阱

陷阱 1：特殊字符未转义

# 错误
grep "a.*b" file.txt  # .* 会被解释为正则

# 正确（固定字符串）
grep -F "a.*b" file.txt

# 或转义
grep "a\.\*b" file.txt

陷阱 2：匹配 grep 自身

# 问题
ps aux | grep nginx  # 会匹配到 grep nginx

# 解决方案 1
ps aux | grep nginx | grep -v grep

# 解决方案 2（技巧）
ps aux | grep "[n]ginx"

# 解决方案 3
pgrep nginx

陷阱 3：文件通配符不工作

# 问题
grep "pattern" *.txt  # 文件太多时失败

# 解决方案
find . -name "*.txt" -exec grep "pattern" {} +
# 或
grep -r "pattern" --include="*.txt" .

陷阱 4：大文件处理

# 问题
grep "pattern" huge_file.txt  # 可能很慢

# 解决方案
grep -m 100 "pattern" huge_file.txt  # 限制匹配次数
# 或使用更快的方法
LC_ALL=C grep -F "pattern" huge_file.txt

陷阱 5：管道中的缓冲

# 问题
tail -f log.txt | grep "error"  # 可能有延迟

# 解决方案
tail -f log.txt | grep --line-buffered "error"

10.4 最佳实践

1. 明确搜索意图

# 固定字符串 - 使用 -F
grep -F "exact string" file.txt

# 简单模式 - 使用基本正则
grep "pattern" file.txt

# 复杂模式 - 使用扩展正则
grep -E "pattern1|pattern2" file.txt

# 高级模式 - 使用 Perl 正则
grep -P "\d{3}-\d{4}" file.txt

2. 限制搜索范围

# 好：明确文件类型
grep -r --include="*.py" "pattern" src/

# 差：搜索所有文件
grep -r "pattern" .

3. 使用静默模式检查

# 好：只检查是否存在
if grep -q "pattern" file.txt; then
    echo "Found"
fi

# 差：输出到 /dev/null
if grep "pattern" file.txt > /dev/null 2>&1; then
    echo "Found"
fi

4. 处理二进制文件

# 明确指定
grep --binary-files=text "pattern" binary_file
# 或
grep -a "pattern" binary_file

# 或跳过
grep -I "pattern" dir/

5. 使用合适的颜色

# 自动颜色（推荐）
grep --color=auto "pattern" file.txt

# 总是显示颜色（用于管道）
grep --color=always "pattern" file.txt | less -R

十一、grep 变体

11.1 egrep

# egrep = grep -E（扩展正则）
egrep "pattern1|pattern2" file.txt

# 现代用法
grep -E "pattern1|pattern2" file.txt

11.2 fgrep

# fgrep = grep -F（固定字符串）
fgrep "a.*b" file.txt  # 字面匹配 a.*b

# 现代用法
grep -F "a.*b" file.txt

# 适用场景
grep -F -f patterns.txt file.txt  # 多个固定字符串

11.3 ripgrep (rg)

# 安装
# Ubuntu/Debian: sudo apt install ripgrep
# macOS: brew install ripgrep

# 使用
rg "pattern" .
rg -t py "pattern"  # 只搜索 Python 文件
rg -i "pattern"     # 忽略大小写
rg -v "pattern"     # 反向匹配
rg -l "pattern"     # 只显示文件名

# 优势
# - 更快
# - 自动忽略 .git 等目录
# - 更好的 Unicode 支持
# - 更智能的默认行为

11.4 the_silver_searcher (ag)

# 安装
# Ubuntu/Debian: sudo apt install silversearcher-ag
# macOS: brew install the_silver_searcher

# 使用
ag "pattern" .
ag --python "pattern"
ag -i "pattern"

# 优势
# - 比 grep 快
# - 自动忽略 .git 等目录
# - 更好的性能

11.5 ack

# 安装
# Ubuntu/Debian: sudo apt install ack
# macOS: brew install ack

# 使用
ack "pattern"
ack --python "pattern"
ack -i "pattern"

# 优势
# - 专为程序员设计
# - 自动识别文件类型
# - 更友好的输出

11.6 工具对比

工具	速度	功能	特点
grep	基准	最全	系统自带
egrep	基准	扩展正则	grep -E
fgrep	快	固定字符串	grep -F
rg	快	全面	现代化
ag	快	代码搜索	程序员友好
ack	中	代码搜索	文件类型识别

十二、grep vs 其他工具

12.1 grep vs sed

# grep：搜索并显示
grep "pattern" file.txt

# sed：搜索并替换
sed 's/pattern/replacement/' file.txt

# grep 适合：查找内容
# sed 适合：编辑内容

12.2 grep vs awk

# grep：简单搜索
grep "pattern" file.txt

# awk：搜索并处理
awk '/pattern/ {print $1, $3}' file.txt

# grep 适合：简单过滤
# awk 适合：复杂处理

12.3 grep vs find

# find：按文件属性搜索
find . -name "*.txt"

# grep：按文件内容搜索
grep -r "pattern" .

# 组合使用
find . -name "*.txt" -exec grep "pattern" {} +

12.4 grep vs cut

# cut：按位置提取
cut -d',' -f1,3 file.csv

# grep：按内容过滤
grep "pattern" file.csv

# 组合使用
grep "pattern" file.csv | cut -d',' -f1

12.5 grep vs sort/uniq

# grep + sort + uniq：查找并统计
grep "pattern" file.txt | sort | uniq -c

# grep：只查找
grep "pattern" file.txt

12.6 选择建议

任务	推荐工具
简单搜索	grep
固定字符串搜索	grep -F
复杂正则	grep -E / grep -P
递归代码搜索	rg / ag / grep -r
搜索并替换	sed
按列处理	awk
按文件属性搜索	find
统计去重	grep + sort + uniq

附录

A. 命令速查表

搜索选项

选项	说明
`-i`	忽略大小写
`-v`	反向匹配
`-w`	匹配整个单词
`-x`	匹配整行
`-E`	扩展正则
`-F`	固定字符串
`-P`	Perl 正则
`-e`	多个模式
`-f`	从文件读取模式

输出选项

选项	说明
`-c`	只显示计数
`-l`	只显示文件名
`-n`	显示行号
`-o`	只显示匹配部分
`-H`	显示文件名
`-h`	不显示文件名
`-q`	静默模式
`--color`	彩色输出

上下文选项

选项	说明
`-A N`	显示后 N 行
`-B N`	显示前 N 行
`-C N`	显示前后 N 行

文件选项

选项	说明
`-r`	递归搜索
`-R`	递归（跟随符号链接）
`--include`	包含文件模式
`--exclude`	排除文件模式
`--exclude-dir`	排除目录
`-a`	处理二进制文件
`-I`	跳过二进制文件

B. 正则表达式速查

基本元字符

元字符	说明
`.`	任意单个字符
`*`	前一个字符 0 次或多次
`^`	行首
`$`	行尾
`[abc]`	字符集
`[^abc]`	排除字符集
`\`	转义字符

扩展元字符

元字符	说明
`+`	1 次或多次
`?`	0 次或 1 次
`\|`	或
`()`	分组
`{n}`	恰好 n 次
`{n,}`	至少 n 次
`{n,m}`	n 到 m 次

Perl 元字符

元字符	说明
`\d`	数字
`\D`	非数字
`\w`	单词字符
`\W`	非单词字符
`\s`	空白字符
`\S`	非空白字符
`\b`	单词边界

C. POSIX 字符类

类	说明
`[:alpha:]`	字母
`[:digit:]`	数字
`[:alnum:]`	字母和数字
`[:space:]`	空白字符
`[:upper:]`	大写字母
`[:lower:]`	小写字母
`[:punct:]`	标点符号
`[:cntrl:]`	控制字符
`[:print:]`	可打印字符
`[:graph:]`	可见字符
`[:blank:]`	空格和制表符
`[:xdigit:]`	十六进制数字

grep 命令完整使用手册

一、简介

1.1 什么是 grep

1.2 grep 家族

1.3 工作原理

二、安装

2.1 各平台安装

Linux

macOS

Windows

2.2 验证安装

2.3 GNU grep vs BSD grep

三、基础语法

3.1 命令格式

3.2 常用选项

搜索控制

输出控制

输出格式

上下文控制

文件和目录

四、基础操作

4.1 基本搜索

简单搜索

多文件搜索

反向搜索

4.2 单词和行匹配

4.3 上下文显示

4.4 统计与计数

4.5 颜色高亮

五、正则表达式

5.1 基本正则表达式 (BRE)

5.2 扩展正则表达式 (ERE)

5.3 Perl 正则表达式 (PCRE)

5.4 字符类

POSIX 字符类

5.5 实用正则示例

六、高级选项

6.1 多模式搜索

使用 -e 选项

使用 -f 选项

6.2 文件过滤

包含/排除文件

排除目录

6.3 二进制文件处理

6.4 行为控制

匹配次数限制

退出状态码

6.5 输出控制

只显示文件名

只显示匹配部分

行号和偏移

七、搜索技巧

7.1 递归搜索

基本递归

带过滤的递归

7.2 组合搜索

与其他命令组合

管道技巧

7.3 排除技巧

7.4 模式组合

八、实战示例

8.1 日志分析

Apache/Nginx 日志

应用日志

系统日志

8.2 代码搜索

代码内容搜索

搜索配置

代码统计

8.3 系统管理

进程管理

文件搜索

网络分析

8.4 文本处理

数据提取

数据清洗

数据验证

8.5 安全检查

敏感信息检测

日志安全检查