echo "aaa" | grep 'a+'        # （无输出）
echo "aaa" | grep -E 'a+'     # aaa
echo "a+"  | grep 'a+'        # a+          <- BRE 里 + 是【普通字符】
echo "aaa" | grep 'a\+'       # aaa         <- BRE 里要转义才是"一次或多次"

# 同一个需求的三种写法：提取 "port=8080" 里的数字
grep -o 'port=[0-9]\+' f            # BRE：+ 要转义
grep -oE 'port=[0-9]+' f            # ERE：+ 直接用
grep -oP 'port=\K\d+' f             # PCRE：\d 简洁，\K 丢弃前缀只留数字
#              ^^ 输出 8080 而不是 port=8080

# 为什么该用 POSIX 类而不是 [a-zA-Z]
echo "café" | grep -o '[a-z]*'        # caf      <- é 不在 a-z 范围
echo "café" | grep -o '[[:alpha:]]*'  # café     <- 尊重 locale，能匹配带音标的字母

# 但要注意 locale 的影响
echo "café" | LC_ALL=C grep -o '[[:alpha:]]*'      # caf   <- C locale 下只认 ASCII
echo "café" | LC_ALL=en_US.UTF-8 grep -o '[[:alpha:]]*'   # café

grep -P '\d+' file
# grep: support for the -P option is not compiled into this --disable-perl-regexp binary

# 检查你的 grep 是否支持
grep -P '' /dev/null 2>&1 && echo "支持 -P" || echo "不支持"
ldd $(which grep) | grep pcre        # 看是否链接了 libpcre

# 常见不支持的场景
# ① Alpine 的 busybox grep —— 根本没有 -P
# ② 某些精简发行版编译时禁用了
# ③ macOS 自带的 BSD grep —— 没有 -P（要用 brew install grep 得到 ggrep）

# 可移植的替代方案
grep -oP 'port=\K\d+' f                    # 只在有 PCRE 的地方能用
grep -oE 'port=[0-9]+' f | cut -d= -f2     # ✅ 可移植
sed -n 's/.*port=\([0-9]*\).*/\1/p' f      # ✅ 可移植
awk -F'port=' '{split($2,a,/[^0-9]/); print a[1]}' f   # ✅ 可移植
perl -nle 'print $1 if /port=(\d+)/' f     # perl 一定支持 PCRE

# ① 贪婪 vs 非贪婪
echo '<a><b>' | grep -oE '<.*>'        # <a><b>     <- 贪婪：尽可能多匹配
echo '<a><b>' | grep -oP '<.*?>'       # <a>        <- 非贪婪：尽可能少
#                            ^^ ? 让 * 变成非贪婪                <b>

# BRE/ERE 没有非贪婪，只能用"排除法"绕开
echo '<a><b>' | grep -oE '<[^>]*>'     # <a>  <b>   <- 用 [^>] 代替 .
#                          ^^^^^ 匹配非 > 的字符，天然就"停在第一个 > 前"

# ② 零宽断言：匹配位置而不是字符
# (?=...)  正向肯定：后面【是】...
# (?!...)  正向否定：后面【不是】...
# (?<=...) 反向肯定：前面【是】...
# (?<!...) 反向否定：前面【不是】...

echo "price=100 cost=200" | grep -oP '\d+(?= )'      # 100    <- 后面是空格的数字
echo "price=100 cost=200" | grep -oP '(?<==)\d+'     # 100    <- 前面是 = 的数字
#                                                      200
echo "foo.log foo.txt" | grep -oP 'foo(?=\.log)'     # foo    <- 只匹配 .log 前的 foo

# ③ \K：丢弃它之前已匹配的内容（比 (?<=) 更灵活，支持变长）
echo "user=alice pass=xxx" | grep -oP 'user=\K\w+'   # alice
echo "user=alice pass=xxx" | grep -oP '(?<=user=)\w+' # alice  <- 等效，但 (?<=) 要求定长
grep -oP 'Content-Length:\s*\K\d+' headers.txt        # \K 后面可以是变长的空白

.          任意单个字符（不含换行）
*          前一项 0 次或多次
+          前一项 1 次或多次
?          前一项 0 次或 1 次
{3}        恰好 3 次
{2,5}      2 到 5 次
{2,}       至少 2 次
[abc]      a 或 b 或 c
[^abc]     除了 abc
[a-z0-9]   范围
^          行首
$          行尾
|          或
()         分组 + 捕获
\1 \2      反向引用（引用第 1、2 个分组）
\b         单词边界
\<  \>     单词开始 / 结束（GNU 扩展）
\.         转义，匹配字面的点

# 反向引用的实用例子
grep -E '(.)\1' file                  # 找出含连续重复字符的行（如 aa、11）
grep -E '\b(\w+)\s+\1\b' file         # 找出重复单词（如 "the the"）
sed -E 's/(\w+)@(\w+)/\2@\1/' file    # 交换 @ 两边的内容
echo "2026-08-12" | sed -E 's/(....)-(..)-(..)/\3\/\2\/\1/'   # 12/08/2026

# ── 基本过滤 ──
grep ERROR app.log
grep -i error app.log                    # 忽略大小写
grep -v DEBUG app.log                    # 排除 DEBUG 行
grep -w cat file                         # 只匹配整词 cat，不匹配 category
grep -x "exact line" file                # 整行完全相等

# ── 多模式（或）──
grep -E 'ERROR|WARN|FATAL' app.log
grep -e ERROR -e WARN app.log            # 等价，多个 -e
grep -F -f patterns.txt app.log          # 从文件读几千个模式（-F 让它极快）

# ── 多条件（与）：用管道 ──
grep ERROR app.log | grep timeout        # 同时含两者
grep ERROR app.log | grep -v test        # 含 ERROR 但不含 test

# ── 提取而不是过滤（-o）──
grep -o 'user=[a-z]*' app.log            # 只输出匹配部分
grep -oE '[0-9]{1,3}(\.[0-9]{1,3}){3}' app.log     # 提取所有 IP
grep -oP '"status":\K\d+' app.log        # PCRE + \K，只要值

# ── 统计 ──
grep -c ERROR app.log                    # 匹配的行数
grep -o ERROR app.log | wc -l            # 匹配的【次数】（一行多个也算多次）
grep -c '' file                          # 总行数（比 wc -l 准，见 05 篇）

# ── 上下文 ──
grep -n -A5 -B2 panic app.log            # 前 2 行后 5 行 + 行号
grep -C3 --color=always ERROR app.log | less -R

# ── 递归搜索代码 ──
grep -rn 'TODO' .                                    # 递归 + 行号
grep -rn --include='*.go' 'func main' .              # 只搜 .go
grep -rn --exclude-dir={.git,node_modules,vendor} 'TODO' .
grep -rl 'deprecated' . | xargs -r sed -i 's/deprecated/legacy/g'
#       ^^ 只列文件名，交给 sed 批量改

# ── 脚本里判断 ──
if grep -q ERROR app.log; then echo "有错误"; fi
#         ^^ -q 静默，找到第一个就退出（大文件上快得多）

# ── 找不到匹配的文件（-L）──
grep -rL 'package main' --include='*.go' .   # 哪些 go 文件不是 main 包

# ① grep 没匹配到时返回 1，在 set -e 脚本里会导致整个脚本退出
set -e
grep ERROR app.log         # 没有 ERROR -> 返回 1 -> 脚本直接死掉
# ✅ 三种修法
grep ERROR app.log || true
grep ERROR app.log || :
if grep -q ERROR app.log; then ...; fi      # 条件里的失败不触发 set -e

# 退出码约定：0=有匹配  1=无匹配  2=出错（文件不存在、正则语法错）
grep ERROR nonexist.log; echo $?    # 2

# ② --color=auto 在管道里会自动关闭（这是特性）
grep --color=auto ERROR app.log | less        # 没有颜色
grep --color=always ERROR app.log | less -R   # ✅ 强制着色 + less 保留颜色
# 但 --color=always 的转义码会混进数据，别用在需要进一步处理的管道里
grep --color=always ERROR app.log | awk '{print $1}'   # ❌ $1 里混了颜色码

# ③ 二进制文件不输出内容
grep pattern /bin/ls
# Binary file /bin/ls matches
grep -a pattern /bin/ls          # ✅ 当文本处理
grep -I pattern *               # 反过来：直接跳过二进制文件

# -F 不解析正则，用的是 Aho-Corasick 多模式字符串匹配算法
time grep -F -f 10000-patterns.txt huge.log      # 0.8s
time grep -E -f 10000-patterns.txt huge.log      # 45s   <- 慢几十倍

# 只要模式里没有正则元字符，就该加 -F
grep -F 'user.name@example.com' app.log     # . 和 @ 不用转义了

# 缩小搜索范围
grep -rn --include='*.go' pattern .         # 比全量递归快
grep -m 1 pattern huge.log                  # 找到第一个就停

# 用 LC_ALL=C 跳过 UTF-8 处理（纯 ASCII 数据时能快数倍）
LC_ALL=C grep pattern huge.log

# 现代替代：ripgrep 默认并行 + 自动跳过 .gitignore 和二进制
rg pattern                                  # 通常比 grep -r 快 5~10 倍
rg -t go 'func main'

# 验证"默认输出全部"
printf 'a\nb\nc\n' | sed 's/b/X/'
# a
# X
# c                    <- a 和 c 没被修改，但仍然输出了

printf 'a\nb\nc\n' | sed -n 's/b/X/p'
# X                    <- -n 关闭自动输出，p 只打印被替换的行

sed 's/旧/新/标志' 文件
#    ^ substitute

echo "a a a" | sed 's/a/X/'          # X a a      <- 只替换第一个
echo "a a a" | sed 's/a/X/g'         # X X X      <- global
echo "a a a" | sed 's/a/X/2'         # a X a      <- 只替换第 2 个
echo "a a a" | sed 's/a/X/2g'        # a X X      <- 从第 2 个开始全部替换

# ❌ 路径里的 / 要转义，很难读
sed 's/\/usr\/local\/bin/\/opt\/bin/g' f

# ✅ 换个分隔符（s 后面第一个字符就是分隔符）
sed 's#/usr/local/bin#/opt/bin#g' f
sed 's|/usr/local/bin|/opt/bin|g' f
sed 's,/usr/local/bin,/opt/bin,g' f

&                # 代表【整个匹配的内容】
\1 \2            # 反向引用捕获组
\n \t            # 换行、制表符（GNU）
\U \L \E         # 转大写 / 小写 / 结束转换（GNU 扩展）

echo "hello" | sed 's/.*/[&]/'                 # [hello]     <- & 是整个匹配
echo "hello world" | sed 's/\(\w*\) \(\w*\)/\2 \1/'    # world hello
echo "hello" | sed 's/.*/\U&/'                 # HELLO       <- 转大写
echo "a:b" | sed 's/:/\n/'                     # a 换行 b
echo "path=/a/b" | sed 's/=.*/&:extra/'        # path=/a/b:extra

sed '3s/a/b/' f              # 只在第 3 行替换
sed '3,7s/a/b/' f            # 第 3~7 行
sed '3,$s/a/b/' f            # 第 3 行到最后一行（$ = 末行）
sed '$d' f                   # 删除最后一行
sed '/ERROR/d' f             # 删除所有含 ERROR 的行（正则地址）
sed '/start/,/end/d' f       # 从匹配 start 的行到匹配 end 的行，整段删除
sed '/ERROR/!d' f            # ! 取反：删除【不含】ERROR 的行
sed '1~3d' f                 # GNU：从第 1 行开始每隔 3 行删（步进地址）
sed '0~2d' f                 # 删除所有偶数行
sed '2,+3d' f                # 第 2 行及其后 3 行
sed '/ERROR/,+5p' f          # 匹配行及后 5 行（看错误上下文）
sed -n '/BEGIN/,/END/p' f    # 只打印 BEGIN 到 END 之间的内容  ← 常用

# 增删改
sed '/^#/d' nginx.conf                   # 删除注释行
sed '/^$/d' f                            # 删除空行
sed '/^[[:space:]]*$/d' f                # 删除空白行（含只有空格的）
sed '/^#/d; /^$/d' nginx.conf            # 多个命令用分号分隔  ← 看配置文件常用
sed '2i\新的一行' f                       # 在第 2 行前插入
sed '$a\最后追加' f                       # 在末行后追加
sed '/listen/a\    server_name x.com;' f # 在匹配行后追加
sed '/old_line/c\new_line' f             # 整行替换
sed 'y/abc/ABC/' f                       # 字符级替换

# 提取
sed -n '10,20p' f                        # 只看 10~20 行
sed -n '$p' f                            # 只看最后一行
sed -n '/ERROR/,/RECOVERED/p' app.log    # 从错误到恢复之间的日志
sed -n 's/.*version=\([0-9.]*\).*/\1/p' f    # 提取版本号（-n + p）

# 提前退出（大文件上性能关键）
sed -n '1000q;500,600p' huge.log         # 打印 500~600 行后立即退出
sed '1000q' huge.log                     # 只要前 1000 行（比 head 慢，但可组合）

sed -i 's/old/new/g' file                # 原地修改
sed -i.bak 's/old/new/g' file            # 先备份成 file.bak  ← 推荐
sed -i'' -e 's/old/new/g' file           # macOS/BSD 的写法（-i 必须带参数）

# ① macOS/BSD 与 GNU 的差异（05 篇提过）
sed -i    's/a/b/' f       # GNU ✅   BSD ❌（会把 's/a/b/' 当备份后缀）
sed -i '' 's/a/b/' f       # BSD ✅   GNU ❌
sed -i.bak 's/a/b/' f      # ✅ 两边都能用（可移植写法）

# ② -i 会【断开软链接】
ls -l config.yaml          # config.yaml -> /real/config.yaml
sed -i 's/a/b/' config.yaml
ls -l config.yaml          # 变成普通文件了！软链接被替换
# 原因：sed -i 的实现是"写临时文件 + rename 覆盖"（见 04 篇 5.1），
#      rename 替换的是链接本身，不是它指向的目标
# ✅ 解法：先解析真实路径
sed -i 's/a/b/' "$(readlink -f config.yaml)"
# 或用 --follow-symlinks（GNU 特有）
sed -i --follow-symlinks 's/a/b/' config.yaml

# ③ -i 会改变文件的 inode、属主和权限
stat -c '%i %U %a' f       # 记录原值
sed -i 's/a/b/' f
stat -c '%i %U %a' f       # inode 变了；用 sudo 跑时属主可能变成 root
# ✅ 对权限敏感的文件（如 /etc/shadow）不要用 sed -i，用临时文件 + install 保权限

# ④ 先演练再执行
sed 's/old/new/g' file | diff file -      # 看会改成什么样
sed -n 's/old/new/gp' file                # 只打印会被改的行
sed -i 's/old/new/g' file                 # 确认后执行

# 五个相关命令
h    # 模式空间 -> 保持空间（覆盖）      Hold
H    # 模式空间 -> 保持空间（追加）
g    # 保持空间 -> 模式空间（覆盖）      Get
G    # 保持空间 -> 模式空间（追加）
x    # 两者交换                        eXchange

# 经典用法
sed 'G' f                    # 每行后加一个空行（保持空间是空的，G 追加了一个 \n）
sed 'G;G' f                  # 每行后加两个空行
sed -n '1!G;h;$p' f          # 【反转文件行序】（等价 tac）
#        ^^^^ 除第一行外把保持空间追加到模式空间，然后存回保持空间，最后打印
sed '$!N;s/\n/ /' f          # 每两行合并成一行
sed -n 'N;P;D' f             # 滑动窗口处理
sed '/pattern/{x;p;x}' f     # 在匹配行前插入保持空间的内容

# 更实际的例子：只保留每组重复行的最后一行
sed -n '$!N; /^\(.*\)\n\1$/!P; D' f       # 等价 uniq

# -E 让正则可读得多
sed 's/\([0-9]\+\)-\([0-9]\+\)/\2-\1/' f        # BRE：满屏反斜杠
sed -E 's/([0-9]+)-([0-9]+)/\2-\1/' f           # ERE：清爽  ← 用这个

# 多条命令的三种写法
sed -e 's/a/b/' -e 's/c/d/' f
sed 's/a/b/; s/c/d/' f
sed 'script.sed' -f f

awk 'BEGIN{print "开始"} {print NR": "$1} END{print "共 "NR" 行"}' file
#    ^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^
#    初始化               对每行执行           汇总

$0        整行
$1 $2 ... 第 1、2 个字段
$NF       最后一个字段（NF 是字段数，$NF 就是最后一个）
$(NF-1)   倒数第二个字段

echo "a    b   c" | awk '{print NF}'          # 3    <- 连续空格算一个分隔符
echo "   a b   " | awk '{print $1}'           # a    <- 行首空白被忽略
echo "a::b::c"   | awk -F: '{print NF}'       # 5    <- 显式指定 : 后，空字段【会】被计入
#                                                       (a, "", b, "", c)

# 原因一：CSV 用逗号分隔，空字段有意义，但 -F, 后行为与默认不同（这点是对的）
echo "a,,c" | awk -F, '{print NF; print "["$2"]"}'
# 3
# []              <- 空字段正确保留

# 原因二（真正的问题）：CSV 允许【字段内含逗号】，用引号包裹
echo 'Smith,"New York, NY",30' | awk -F, '{print $2}'
# "New York       <- ❌ 被逗号切断了！

# ✅ 方案一：GNU awk 4.0+ 的 FPAT（定义"字段是什么"而不是"分隔符是什么"）
echo 'Smith,"New York, NY",30' | awk -v FPAT='([^,]*)|("[^"]+")' '{print $2}'
# "New York, NY"                                    <- 正确

# ✅ 方案二：用专门的工具（推荐）
csvcut -c 2 data.csv          # csvkit
mlr --csv cut -f city data.csv    # miller
python3 -c "import csv,sys; [print(r[1]) for r in csv.reader(sys.stdin)]" < data.csv

awk -F: '{print $1}' /etc/passwd          # 单字符
awk -F'\t' '{print $1}' data.tsv          # tab
awk -F'[:,]' '{print $2}' f               # 【正则】：冒号或逗号都算分隔符
awk -F' *, *' '{print $2}' f              # 正则：逗号前后的空格一起吃掉
awk -F'FS-is-a-string' '{print $2}' f     # 多字符字符串
awk 'BEGIN{FS=":"} {print $1}' f          # 在 BEGIN 里设（等价 -F:）
awk -v FS=: '{print $1}' f                # 用 -v 设变量

# 输出分隔符
awk -F: '{print $1, $3}' /etc/passwd              # 默认 OFS 是空格：root 0
awk -F: 'BEGIN{OFS="\t"} {print $1, $3}' /etc/passwd    # 用 tab
awk -F: -v OFS=, '{print $1, $3}' /etc/passwd     # 用逗号
awk -F: '{print $1 ":" $3}' /etc/passwd           # 或者手动拼（注意逗号 vs 无逗号）
#              ^^^ 用逗号 print 会插入 OFS，不用逗号就是直接拼接

# ⚠️ 只有修改了字段才会用 OFS 重建 $0
echo "a b c" | awk -v OFS=- '{print $0}'          # a b c    <- 没改，原样输出
echo "a b c" | awk -v OFS=- '{$1=$1; print $0}'   # a-b-c    <- $1=$1 触发重建
#                             ^^^^^ 这是个经典技巧

# ── 正则模式 ──
awk '/ERROR/' app.log                     # 含 ERROR 的行（等价 grep ERROR）
awk '!/DEBUG/' app.log                     # 不含 DEBUG（等价 grep -v）
awk '/ERROR/ {print $1, $NF}' app.log      # 匹配的行才执行动作
awk '$3 ~ /^5/ {print}' access.log         # 【第 3 字段】匹配正则  ← 比 grep 精确
awk '$3 !~ /^2/' access.log                # 第 3 字段不匹配

# ── 比较模式 ──
awk '$3 > 1000' data                       # 数值比较
awk '$1 == "root"' /etc/passwd             # 字符串相等（用 == 不是 =）
awk -F: '$3 >= 1000 && $3 < 60000' /etc/passwd    # 普通用户（uid 范围）
awk 'NF > 5' f                             # 字段数超过 5 的行
awk 'length($0) > 200' app.log             # 超长行（排查异常日志）
awk 'NR % 2 == 0' f                        # 偶数行

# ── 范围模式 ──
awk '/BEGIN/,/END/' f                      # 从 BEGIN 到 END 之间（含两端）
awk 'NR==10,NR==20' f                      # 第 10~20 行
awk '/2026-08-12 21:/,/2026-08-12 22:/' app.log   # 时间段截取

# ── 特殊模式 ──
awk 'BEGIN{...}'                           # 读文件前
awk 'END{...}'                             # 读文件后
awk '{...}'                                # 无模式 = 所有行

# ── 组合 ──
awk '/ERROR/ && $3 > 500' f
awk '$1=="GET" || $1=="POST"' f

# 字符串处理
echo "hello world" | awk '{print toupper($1), length($2)}'        # HELLO 5
echo "2026-08-12" | awk '{print substr($0,1,4)}'                  # 2026
echo "a.b.c" | awk '{n=split($0,arr,"."); print n, arr[2]}'       # 3 b
echo "aaa" | awk '{n=gsub(/a/,"X"); print $0, n}'                 # XXX 3
echo "path=/a/b" | awk '{sub(/path=/,""); print}'                 # /a/b

# printf 格式化（比 print 可控）
awk '{printf "%-20s %8.2f %5d\n", $1, $2, $3}' data
#            ^^^^^ 左对齐 20 字符
#                  ^^^^^ 右对齐 8 字符，2 位小数
#                        ^^^^ 右对齐 5 字符整数
awk '{printf "%s\t%s\n", $1, $2}' f
awk 'BEGIN{printf "%5.1f%%\n", 99.456}'          # 99.5%   （%% 输出百分号）

# 时间处理（GNU awk）
awk 'BEGIN{print strftime("%Y-%m-%d %H:%M:%S", systime())}'
awk '{print strftime("%H:%M", $1)}' timestamps.txt

# 统计每个状态码出现次数
awk '{count[$9]++} END{for(code in count) print code, count[code]}' access.log
#     ^^^^^^^^^^^^        ^^^^^^^^^^^^^^^^ for-in 遍历
# 200 15234
# 404 89
# 500 12

# 排序输出（awk 的 for-in 顺序不确定，要排序就管道给 sort）
awk '{c[$9]++} END{for(k in c) print c[k], k}' access.log | sort -rn

# 按字段求和（分组聚合）
awk '{sum[$1] += $2} END{for(k in sum) printf "%s: %.2f\n", k, sum[k]}' data

# 去重（比 sort -u 快，且保持原顺序）
awk '!seen[$0]++' file
#    ^^^^^^^^^^^^ 第一次见到时 seen[$0] 是 0（假），! 变真 -> 打印并自增
#                 再次见到时 seen[$0] 是 1（真），! 变假 -> 不打印

awk '!seen[$1]++' file                   # 按第 1 字段去重
awk 'seen[$0]++' file                    # 反过来：只输出重复的行

# 多维数组（本质是用 SUBSEP 拼接下标）
awk '{count[$1][$2]++}' f                        # GNU awk 支持真多维
awk '{count[$1 SUBSEP $2]++} END{for(k in count){split(k,a,SUBSEP); print a[1],a[2],count[k]}}' f

# 数组常用操作
awk '{a[NR]=$0} END{for(i=NR;i>=1;i--) print a[i]}' f    # 反转文件（等价 tac）
awk 'BEGIN{if("k" in arr) ...}'                   # 判断键存在（不要用 arr["k"]，那会创建它）
awk '{delete arr[key]}'                           # 删除元素
awk 'END{print length(arr)}'                      # 数组元素个数（GNU）

# -v 传变量（唯一正确的传参方式）
threshold=500
awk -v t="$threshold" '$3 > t' data              # ✅
awk '$3 > '"$threshold" data                      # ❌ 拼字符串，值含空格/引号就崩

# 传日期
awk -v today="$(date +%F)" '$1 == today' log

# ⚠️ -v 会处理转义序列
awk -v p='a\tb' 'BEGIN{print p}'                  # a<tab>b   （\t 被解释了）
awk 'BEGIN{p=ARGV[1]; print p}' 'a\tb'            # a\tb      （原样）

# 从文件读长脚本
cat > report.awk <<'EOF'
BEGIN { FS=":"; printf "%-15s %s\n", "USER", "UID" }
$3 >= 1000 { printf "%-15s %s\n", $1, $3 }
END { print "---" }
EOF
awk -f report.awk /etc/passwd

# 从命令读取
awk 'BEGIN{ "date +%Y" | getline year; print "今年是", year }'

# 输出到命令
awk '{print $1 | "sort"}' f                       # 把输出管道给 sort
awk '{print > "/tmp/out_"$1".txt"}' f             # 【按字段分文件输出】← 很实用

# 从文件读取（做 join）
awk 'NR==FNR{map[$1]=$2; next} {print $0, map[$1]}' mapping.txt data.txt
#    ^^^^^^^^^^^^^^^^^^^^^^^^^^^ 读第一个文件时建映射表（NR==FNR 只在第一个文件成立）
#                                ^^^^^ next 跳过后续规则
#                                       ^^^^^^^^^^^^^^^^^^ 处理第二个文件时查表

# 这个 NR==FNR 技巧是 awk 做「两文件关联」的标准写法，值得记住
# 例：用 uid->用户名 映射表给日志加上用户名
awk -F: 'NR==FNR{name[$3]=$1; next} {print $0, name[$2]}' /etc/passwd uidlog.txt

awk --version | head -1
# GNU Awk 5.1.0        <- gawk，功能最强（FPAT、多维数组、strftime、-i inplace）
# awk version 20200816 <- BWK awk / onetrue awk（macOS 自带）
# （busybox awk）       <- Alpine 里的，功能最少

# Debian/Ubuntu 默认是 mawk（快但功能少），需要 gawk 的话
sudo apt install gawk
update-alternatives --config awk

# 常见的 gawk 专有功能（脚本里注意可移植性）
FPAT / FIELDWIDTHS      # CSV / 定宽字段
gensub()                # 返回替换结果
strftime() / mktime()   # 时间函数
length(arr)             # 数组长度
delete arr              # 清空整个数组
arr[a][b]               # 真多维数组
-i inplace              # 原地编辑
RS 为正则               # 多字符记录分隔符

# 需求：从 /etc/passwd 提取 uid >= 1000 的用户名

grep -E ':[0-9]{4,}:' /etc/passwd | cut -d: -f1     # grep + cut，勉强
sed -n '/:[0-9]\{4,\}:/s/^\([^:]*\).*/\1/p' /etc/passwd    # sed，难读
awk -F: '$3 >= 1000 {print $1}' /etc/passwd         # ✅ awk，最清晰
#         ^^^^^^^^^^ 直接表达"第3字段>=1000"这个语义

# ❌ 用 awk 解析 JSON（脆弱且不可维护）
cat app.log | awk -F'"status":' '{split($2,a,","); print a[1]}'

# ✅ 用 jq
cat app.log | jq -r '.status'
jq -r 'select(.level=="error") | .msg' app.log
jq -s 'group_by(.status) | map({status: .[0].status, count: length})' app.log

# Go 服务的结构化日志（slog/zap 输出 JSON）应该配 jq
journalctl -u myapp -o cat | jq -r 'select(.level=="ERROR") | "\(.time) \(.msg)"'

# ❌ 超过 20 行的 awk 脚本
# ✅ 换 Python：可读、可测、有库

# ── 基础统计 ──
wc -l access.log                                    # 总请求数

awk '{print $9}' access.log | sort | uniq -c | sort -rn        # 状态码分布
# 15234 200
#   892 404
#    12 500

awk '$9 >= 500' access.log | wc -l                  # 5xx 数量
awk '$9 ~ /^[45]/ {print $7}' access.log | sort | uniq -c | sort -rn | head
#                                                     # 出错最多的 URL

# ── TOP N ──
awk '{print $1}' access.log | sort | uniq -c | sort -rn | head -10    # TOP IP
awk '{print $7}' access.log | cut -d? -f1 | sort | uniq -c | sort -rn | head -20
#                             ^^^^^^^^^^^ 去掉 query string 再聚合    # TOP URL

# ── 流量 ──
awk '{sum += $10} END {printf "%.2f GB\n", sum/1024/1024/1024}' access.log
awk '{traffic[$7] += $10} END {for(u in traffic) print traffic[u], u}' access.log \
    | sort -rn | head -10                           # 最耗流量的 URL

# ── 响应时间（假设 $13 是 request_time）──
awk '{sum+=$13; n++} END {printf "平均 %.3fs\n", sum/n}' access.log
awk '$13 > 1 {print $13, $7}' access.log | sort -rn | head -20         # 慢请求 TOP20
awk '{print $13}' access.log | sort -n | awk '{a[NR]=$1} END{print "P95:", a[int(NR*0.95)]}'
#                                          ^^^^^^^^^^^^^^^^^^^^^^^^ 计算 P95

# ── 按时间聚合（QPS）──
awk '{print substr($4, 2, 20)}' access.log | uniq -c | sort -rn | head
#          ^^^^^^^^^^^^^^^^^^^ 提取 [12/Aug/2026:21:30:45 里的时间
# 每分钟请求数
awk '{split($4,a,":"); print a[2]":"a[3]}' access.log | uniq -c
# 每小时
awk '{split($4,a,":"); print a[2]}' access.log | uniq -c

# ── 时间段截取 ──
sed -n '/12\/Aug\/2026:21:/,/12\/Aug\/2026:22:/p' access.log
awk '$4 >= "[12/Aug/2026:21:00:00" && $4 <= "[12/Aug/2026:22:00:00"' access.log

# ── 组合分析：找出某个 IP 在错误高峰期做了什么 ──
awk '$9 >= 500 {print $1}' access.log | sort | uniq -c | sort -rn | head -1
# 假设是 1.2.3.4
grep '^1\.2\.3\.4 ' access.log | awk '{print $7, $9, $13}' | sort | uniq -c | sort -rn | head

# ── 一次输出多个指标 ──
awk '
{
    total++
    status[$9]++
    bytes += $10
    time += $13
    if ($13 > 1) slow++
}
END {
    printf "总请求: %d\n", total
    printf "总流量: %.2f MB\n", bytes/1024/1024
    printf "平均耗时: %.3f s\n", time/total
    printf "慢请求(>1s): %d (%.2f%%)\n", slow, slow*100/total
    printf "错误率: %.2f%%\n", (status["500"]+status["502"]+status["503"])*100/total
}' access.log

cut -d: -f1 /etc/passwd            # d=delimiter 分隔符, f=fields 字段
cut -d: -f1,3 /etc/passwd          # 多个字段
cut -d: -f1-3 /etc/passwd          # 范围
cut -d: -f3- /etc/passwd           # 第 3 个到最后
cut -c1-10 file                    # 按【字符】位置切
cut -b1-10 file                    # 按【字节】位置切
cut -d: -f1 --complement /etc/passwd    # 除了第 1 个字段
cut -d: -f1 --output-delimiter=' ' f    # 换输出分隔符

# ⚠️ cut 的两个局限（这就是 awk 存在的理由）
# ① 不支持"连续空白算一个分隔符"
echo "a    b" | cut -d' ' -f2       # （空）  <- 第 2 个字段是空的
echo "a    b" | awk '{print $2}'    # b       <- awk 自动处理连续空白
echo "a    b" | tr -s ' ' | cut -d' ' -f2    # b   <- 要先用 tr -s 压缩
# ② 不能重排字段顺序
cut -d: -f3,1 /etc/passwd           # 仍按 1,3 顺序输出！
awk -F: '{print $3, $1}' /etc/passwd    # ✅ awk 可以任意顺序

sort -k2,2nr -k1,1 data              # 先按第2列数值逆序，第2列相同时按第1列字典序
sort -t: -k3 -n /etc/passwd          # 按 uid 排序
du -sh * | sort -h                   # 按大小排序（-h 认识 K/M/G）
sort -u file                         # 去重
sort -o file file                    # ✅ 原地排序（-o 可以是输入文件）
LC_ALL=C sort huge.txt               # 跳过 locale 处理，快数倍
sort -S 2G -T /data/tmp huge.txt     # 大文件调优

sort file | uniq                      # 去重（uniq 只能去掉【相邻】的重复行！）
sort file | uniq -c                   # c=count 统计每行出现次数  ← 最常用
sort file | uniq -c | sort -rn        # 按频次排序   ← 经典组合
sort file | uniq -d                   # d=duplicated 只显示重复的行
sort file | uniq -D                   # 显示重复行的【所有】副本
sort file | uniq -u                   # u=unique 只显示出现一次的行
uniq -i file                          # 忽略大小写
uniq -w 10 file                       # 只比较前 10 个字符
uniq -f 2 file                        # 跳过前 2 个字段再比较
uniq -s 5 file                        # 跳过前 5 个字符

# ⚠️ uniq 只去除【相邻】重复，所以必须先 sort
printf 'a\nb\na\n' | uniq             # a b a    <- 没去掉！
printf 'a\nb\na\n' | sort | uniq      # a b      ✅
printf 'a\nb\na\n' | awk '!s[$0]++'   # a b      ✅ 且保持原始顺序（不用排序）

tr 'a-z' 'A-Z' < file                 # 转大写
tr -d '\r' < win.txt > unix.txt       # d=delete 删除字符（去 CRLF）
tr -s ' ' < file                      # s=squeeze 压缩连续重复字符
tr -c 'a-zA-Z0-9\n' '_' < file        # c=complement 取反：非字母数字都换成 _
tr -dc 'a-zA-Z0-9' < /dev/urandom | head -c 16    # 生成随机密码
tr '\0' '\n' < /proc/1/environ        # NUL 转换行（读 /proc 常用）
tr ':' '\n' <<< "$PATH"               # 拆分 PATH

# ⚠️ tr 只处理【单个字符】，不能替换字符串
echo "hello" | tr 'llo' 'xyz'         # hexyz    <- 是逐字符映射 l->x l->y o->z
echo "hello" | sed 's/llo/xyz/'       # hexyz    <- sed 才是字符串替换

# paste：把多个文件【按列】拼接
paste a.txt b.txt                     # 用 tab 连接对应行
paste -d, a.txt b.txt                 # 用逗号
paste -s a.txt                        # s=serial 把所有行合并成一行
seq 1 6 | paste - - -                 # 3 列输出（每个 - 代表一列）

# join：按公共字段关联两个【已排序】文件
join -t: -1 1 -2 1 file1 file2        # 按各自第 1 字段关联
join -t: -a1 file1 file2              # 左连接（保留 file1 未匹配的行）
# 实际上 awk 的 NR==FNR 更灵活，不要求预排序

# column：格式化成对齐的表格
mount | column -t                     # t=table 自动对齐   ← 让杂乱输出变整齐
cat /etc/passwd | column -t -s:       # 指定分隔符
printf 'a b\nlonger x\n' | column -t

# tee：分流（一份给屏幕，一份给文件）
cmd | tee output.log                  # 同时显示和保存
cmd | tee -a output.log               # a=append 追加
cmd | tee out1.log out2.log | grep x  # 多路分流后继续管道
cmd 2>&1 | tee build.log              # 连 stderr 一起保存
echo "x" | sudo tee /etc/sysctl.d/x.conf     # ✅ 用 sudo 写文件（重定向没法提权）

grep -oE 'port=[0-9]+' f | cut -d= -f2        # ERE + cut
sed -n 's/.*port=\([0-9]*\).*/\1/p' f         # sed
awk -F'port=' '{...}' f                        # awk
perl -nle 'print $1 if /port=(\d+)/' f        # perl 一定有 PCRE

echo 'Smith,"New York, NY",30' | awk -F, '{print $2}'
# "New York          <- 被切断了

printf 'a\nb\na\n' | uniq          # a b a   <- 没去掉
printf 'a\nb\na\n' | sort | uniq   # a b     ✅