find [起始路径...] [全局选项] [表达式]
     ^^^^^^^^^^^^  ^^^^^^^^^^  ^^^^^^^^

find . -name '*.log' -print
#      └─测试─────┘ └动作┘
# 含义：对每个文件，先判断名字是否匹配 *.log，为真则执行 -print

# 规则一：相邻的两个表达式之间默认是 -a（AND）
find . -type f -name '*.log'
find . -type f -a -name '*.log'        # 完全等价

# 规则二：整个表达式里【没有任何动作】时，自动在最外层加 -print
find . -name '*.log'
find . -name '*.log' -print            # 完全等价

# -a 短路：左边为假，右边根本不执行
find . -type f -name '*.go'
#      ^^^^^^^ 先判断类型（读 inode 里已有的字段，几乎免费）
#              ^^^^^^^^^^^^ 类型不是文件就跳过，不用做字符串匹配

find . -name '*.go' -type f
#      ^^^^^^^^^^^^ 对【每一个】条目都做字符串匹配（包括所有目录）
#                   然后才判断类型

# 差异在大目录树上是可测量的：先用便宜的测试过滤掉大部分候选

# ❌ 慢：对每个文件都起一个 grep 进程
find / -exec grep -l "pattern" {} \; 2>/dev/null

# ✅ 快：先用便宜的条件把候选集缩小几个数量级
find /var/log -maxdepth 2 -type f -name '*.log' -size -100M \
     -exec grep -l "pattern" {} +

find . -name '*.tmp' -o -name '*.log' -delete

# 实际的求值结构（-a 优先级高于 -o）：
find . ( -name '*.tmp' )  -o  ( -name '*.log' -a -delete )
#        ^^^^^^^^^^^^^^^        ^^^^^^^^^^^^^^^^^^^^^^^^^^
#        左分支：只是个测试         右分支：测试 AND 删除
#
# 又因为整个表达式里【有动作】（-delete），所以不会自动加 -print？
# —— 不对！-delete 只在右分支里，左分支为真时短路，
#    此时 find 认为该文件"匹配了表达式"，而 GNU find 的规则是：
#    只要表达式里存在动作，就不加隐式 -print。
#    所以 .tmp 文件既不被删也不被打印，看起来"什么都没发生"。

mkdir -p /tmp/ftest && cd /tmp/ftest
touch a.tmp b.tmp c.log d.log

find . -name '*.tmp' -o -name '*.log' -delete
ls
# a.tmp  b.tmp                    <- .log 被删了，.tmp 还在！

touch c.log d.log      # 重新造两个

find . \( -name '*.tmp' -o -name '*.log' \) -delete
#      ^^                                 ^^
#      括号在 shell 里是特殊字符，必须转义（或用引号 '(' ')'）
ls
# （空）                          <- 全部删掉了

# ❌ 只对 .log 执行 ls
find . -name '*.tmp' -o -name '*.log' -exec ls -l {} \;

# ✅
find . \( -name '*.tmp' -o -name '*.log' \) -exec ls -l {} \;

# 排查技巧：写危险命令前，先把动作换成 -print 看看命中了什么
find . \( -name '*.tmp' -o -name '*.log' \) -print
# 确认无误后再换成 -delete

# 非
find . ! -name '*.go'                    # 不是 .go 的
find . -not -name '*.go'                 # 等价
find . -type f ! -path '*/node_modules/*'   # 排除某个目录下的文件

# 复杂组合：找出（.go 或 .py）且大于 1M 且不在 vendor 里的文件
find . \( -name '*.go' -o -name '*.py' \) -a -size +1M -a ! -path '*/vendor/*'

# 排除多个目录（-prune 更高效，见 2.4）
find . -type d \( -name node_modules -o -name .git \) -prune -o -type f -print

# ❌ 慢：仍然会递归进 node_modules 里的几万个文件，只是不输出
find . -type f ! -path '*/node_modules/*'

# ✅ 快：遇到 node_modules 目录直接剪枝，不进入
find . -name node_modules -prune -o -type f -print
#      ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^
#      匹配到就剪枝（-prune 返回真）  或者：是文件就打印

find 路径 <排除条件> -prune -o <真正的条件> -print
#                          ^^                  ^^^^^^
#                          必须有 -o          必须显式写 -print

# 排除多个目录
find . \( -name node_modules -o -name .git -o -name vendor \) -prune -o -type f -print

# 只排除目录但保留同名文件（-type d 更精确）
find . -type d -name .git -prune -o -type f -name '*.go' -print

# 常用封装
alias ff='find . \( -name node_modules -o -name .git -o -name .venv \) -prune -o -type f'
ff -name '*.go' -print

find . -name '*.log'          # 名字匹配（glob 通配，【必须加引号】）
find . -iname '*.LOG'         # i = 忽略大小写
find . -path '*/test/*.go'    # 匹配【完整路径】而不只是文件名
find . -ipath '*/TEST/*'      # 忽略大小写的路径匹配
find . -regex '.*/[0-9]+\.log'      # 整个路径匹配正则（默认是 emacs 正则）
find . -regextype posix-extended -regex '.*/[0-9]+\.log'   # 换成扩展正则
find . -lname '*/target'      # 软链接的【目标】匹配

# ❌ 没引号时，通配符先被 shell 展开了
find . -name *.log
# 如果当前目录恰好有 a.log b.log，shell 会展开成：
# find . -name a.log b.log      -> find: paths must precede expression: 'b.log'
# 如果当前目录【没有】.log 文件，shell 展开失败保持原样，反而"碰巧能用"
# —— 这就是为什么它"有时候能跑"，这种不确定性最危险

# ✅ 加引号，让 find 自己处理通配符
find . -name '*.log'
find . -name "*.log"

find . -name '*.log'          # 能匹配隐藏文件 .hidden.log（find 不特殊对待点开头）
ls *.log                      # shell 的 glob 不匹配 . 开头的

find . -type f          # f = file，普通文件
find . -type d          # d = directory
find . -type l          # l = symbolic link
find . -type s          # s = socket
find . -type p          # p = named pipe (FIFO)
find . -type b          # b = block device
find . -type c          # c = character device

# 组合
find /dev -type c -name 'tty*'
find . -xtype l         # 【悬空软链接】：链接指向的目标不存在   ← 部署检查常用

find . -size +100M      # 大于 100MB
find . -size -1k        # 小于 1KB
find . -size 0          # 恰好为 0（也可以用 -empty）
find . -empty           # 空文件【或】空目录
find . -type f -empty   # 只要空文件

# 单位（大小写敏感！）
#   c = 字节（byte）      ← 最直观
#   k = KiB (1024)
#   M = MiB
#   G = GiB
#   b = 512 字节块（【默认单位，容易踩坑】）
#   w = 2 字节字

find . -size +1000      # ⚠️ 这是 1000 个【512 字节块】= 500KB，不是 1000 字节！
find . -size +1000c     # ✅ 这才是 1000 字节

# ⚠️ 另一个坑：-size 是【向上取整】的
# 一个 1 字节的文件，-size 1k 会匹配（因为它占用了 1 个 k 单位）
find . -size -1M        # 实际是"占用不足 1M 个单位"，即小于 1MB 的

# 三种时间（对应 04 篇讲的三个时间戳）
-mtime / -mmin      # 内容修改时间   ← 最常用
-atime / -amin      # 访问时间
-ctime / -cmin      # inode 变更时间（权限、属主、链接数改变也会更新）

# 数字的三种形式
find . -mtime +7        # 【超过】7 天
find . -mtime -7        # 【不到】7 天（7 天内）
find . -mtime 7         # 【恰好】第 7 天那一天（很少用）

# 验证
touch -d '7 days ago 12:00' /tmp/f7
find /tmp -name f7 -mtime +7      # （无输出）
find /tmp -name f7 -mtime +6      # /tmp/f7

# ✅ 想精确表达「7 天前及更早」，用 -newermt 取反
find /var/log -type f ! -newermt '7 days ago' -delete
#                     ^^^^^^^^^^^^^^^^^^^^^^^ 不比"7天前那个时刻"新 = 7 天前或更早
#                     精确到秒，不做取整

find . -newer ref.txt              # 比 ref.txt 的 mtime 新
find . -newermt '2026-08-01'       # 比这个时刻新（mt = mtime）
find . -newermt '2 hours ago'      # 支持自然语言
find . ! -newermt '2026-08-01'     # 早于这个时刻
find . -newerct '1 day ago'        # ct = ctime
find . -newerat '1 hour ago'       # at = atime

# 时间区间：找 8 月 1 日到 8 月 5 日之间修改的
find . -newermt '2026-08-01' ! -newermt '2026-08-06'

# 分钟粒度（排查刚发生的事故时用）
find /var/log -mmin -30            # 30 分钟内修改过的
find /etc -mmin -60 -type f        # 一小时内被改过的配置  ← 事故排查常用

find . -user lhx                   # 属主是 lhx
find . -uid 1000                   # 按 uid（用户被删后只剩数字时用）
find . -group docker
find . -nouser                     # 属主的 uid 在 /etc/passwd 里不存在（用户被删了）
find . -nogroup

# 权限匹配的三种模式（最容易混）
find . -perm 644                   # 权限【恰好】是 644
find . -perm -644                  # 【至少】包含这些位（可以有更多权限）
find . -perm /644                  # 【任意一位】匹配即可（u+r 或 g+r 或 o+r）

# 安全审计常用
find / -perm -4000 -type f 2>/dev/null       # 所有 SUID 程序  ← 必查
find / -perm -2000 -type f 2>/dev/null       # 所有 SGID 程序
find / -perm -002 -type f 2>/dev/null        # 所有【其他人可写】的文件  ← 高危
find /home -perm -o+w -type d                # 其他人可写的目录
find ~/.ssh -type f ! -perm 600              # ssh 密钥权限不对的（ssh 会拒绝使用）

find . -inum 2621441               # 按 inode 号找（找一个文件的所有硬链接）
find . -samefile /path/to/f        # 同上，更直观：找出与该文件同 inode 的所有名字
find . -links +1 -type f           # 硬链接数大于 1 的文件
find . -maxdepth 2                 # 最多向下 2 层   ← 全局选项，写在最前面
find . -mindepth 1                 # 至少 1 层（排除起始目录本身）
find . -xdev                       # 不跨文件系统（等价 -mount）  ← 扫 / 时必加
find . -follow                     # 跟随软链接（默认不跟）
find . -readable -writable         # 当前用户可读/可写的
find . -executable -type f

find . -name '*.log' -exec gzip {} \;      # 形式一：分号结尾
find . -name '*.log' -exec gzip {} +       # 形式二：加号结尾

mkdir -p /tmp/bench && cd /tmp/bench && touch f{1..5000}

time find . -type f -exec touch {} \;
# real  0m8.234s          <- 5000 次 fork + exec

time find . -type f -exec touch {} +
# real  0m0.061s          <- 几次调用搞定，快 130 倍

# ① {} 需要出现在命令中间或多次
find . -name '*.txt' -exec mv {} {}.bak \;
#                             ^^ ^^^^^^ 两个 {}，只能用 \;

# ② 命令一次只能处理一个文件
find . -name '*.tar.gz' -exec tar -xzf {} -C /tmp/out \;

# ③ 需要用 shell 特性（管道、重定向、变量）
find . -name '*.log' -exec sh -c 'gzip -c "$1" > "$1.gz"' _ {} \;
#                                                          ^^ _ 是占位的 $0
# 用 + 的版本（更快，但脚本要自己遍历参数）
find . -name '*.log' -exec sh -c 'for f; do gzip -c "$f" > "$f.gz"; done' _ {} +
#                                     ^^^^ for f 默认遍历 "$@"

find . -name '*.log' -execdir gzip {} \;
#                     ^^^^^^^^ 在【文件所在的目录】里执行命令，{} 是 ./文件名

# ① 避免路径中的空格、特殊字符引发的问题（{} 只是 ./basename）
# ② 防御【竞态攻击】：
#    用 -exec 时，find 传的是完整路径，从 find 找到文件到命令执行之间，
#    攻击者可能把路径中的某个目录换成软链接，导致命令作用到别的文件上。
#    -execdir 先 chdir 到目标目录再执行，规避了这个窗口。

# ⚠️ 注意 -execdir 也支持 + 形式，但会按目录分批
find . -name '*.log' -execdir gzip {} +

find /tmp/cache -type f -mtime +7 -delete

# ① -delete 隐含了 -depth（先处理子目录再处理父目录），
#    所以它能删非空目录树，但也意味着遍历顺序变了，
#    与 -prune 一起用时行为可能不符合预期
find . -name node_modules -prune -o -name '*.tmp' -delete    # ⚠️ -prune 会失效

# ② 用了 -o 必须加括号（第 2.2 节的陷阱）
find . \( -name '*.a' -o -name '*.b' \) -delete

# ③ 删目录时目录必须为空（除非它自己也被匹配到并按 -depth 顺序处理）
find . -type d -empty -delete         # 删空目录
find . -depth -type d -empty -delete  # 递归删多层空目录

# ④ 【永远先用 -print 演练一遍】
find /data -type f -mtime +30 -print | head -20    # 先看命中什么
find /data -type f -mtime +30 -delete              # 确认后再删

# 找出最大的 10 个文件（比 ls -lS 强：能递归）
find . -type f -printf '%s\t%p\n' | sort -rn | head -10

# 找出最新修改的 10 个文件
find . -type f -printf '%T@ %p\n' | sort -rn | head -10 | cut -d' ' -f2-
#                      ^^^ Unix 时间戳，才能正确按数值排序

# 统计各扩展名的文件数
find . -type f -printf '%f\n' | grep -oP '\.[^.]+$' | sort | uniq -c | sort -rn

# 统计总大小（不起 du）
find . -name '*.log' -printf '%s\n' | awk '{s+=$1} END{print s/1024/1024 " MB"}'

# 生成一份带权限的清单
find /etc -maxdepth 1 -printf '%M %u:%g %10s %TY-%Tm-%Td %p\n'

# 快速数文件个数（比 | wc -l 快，不用构造完整输出）
find . -type f -printf '.' | wc -c

# 找出软链接及其目标
find /etc -type l -printf '%p -> %l\n'

find . -name '*.log' -ls              # 类似 ls -dils 的详细输出
find . -name '*.log' -print           # 输出路径 + 换行
find . -name '*.log' -print0          # 输出路径 + \0  ← 配合 xargs -0
find . -name '*.log' -fprint out.txt  # 输出到文件
find . -name '*.log' -quit            # 找到第一个就退出（判断"是否存在"时高效）

# 判断某类文件是否存在（不需要遍历完）
if find /data -name '*.lock' -print -quit | grep -q .; then echo "有锁文件"; fi

echo "/tmp/a.txt" | rm
# rm: missing operand         <- rm 不读 stdin，它只看命令行参数

echo "/tmp/a.txt" | xargs rm
#                   ^^^^^ 把 stdin 的内容转成命令行参数：rm /tmp/a.txt

rm /data/logs/*.log
# bash: /usr/bin/rm: Argument list too long
#       ^^ shell 展开出几十万个参数，超过内核的 ARG_MAX
getconf ARG_MAX          # 2097152 字节

find /data/logs -name '*.log' -print0 | xargs -0 rm
#                                       ^^^^^ 自动按 ARG_MAX 分批调用 rm

find . -name '*.log' | xargs rm

# 造一个"合法但恶劣"的文件名
mkdir -p /tmp/xtest && cd /tmp/xtest
touch 'important file.log'        # 名字里有空格
touch $'weird\nname.log'          # 名字里有换行！

find . -name '*.log' | xargs rm
# rm: cannot remove './important': No such file or directory
# rm: cannot remove 'file.log': No such file or directory
#     ^^ xargs 默认按【空白】分隔，一个文件名被拆成了两个参数

# 换行的情况更糟：可能删掉完全不相干的文件

find . -name '*.log' -print0 | xargs -0 rm
#                    ^^^^^^^          ^^
#                    用 \0 分隔        按 \0 切分

# 记忆：find 的 -print0 与 xargs 的 -0 永远成对出现

grep -rlZ 'pattern' . | xargs -0 sed -i 's/a/b/g'
#         ^ Z = --null，输出文件名用 \0 分隔
sort -z / uniq -z / cut -z / tr -d '\0'
readlink -z / realpath -z / du -0 / stat --printf='%n\0'

find . -name '*.log' -exec rm {} +          # ✅ 同样安全，且更简单

# ❌ 危险：如果 find 没找到任何文件，xargs 仍会执行一次 rm（无参数）
find /tmp -name '*.nonexistent' | xargs rm
# rm: missing operand           <- 这次只是报错，但换成别的命令可能出事
echo "" | xargs ls
# （列出了当前目录！因为 ls 无参数时列出 .）

# ✅ 加 -r
find /tmp -name '*.nonexistent' -print0 | xargs -0 -r rm
# ⚠️ -r 是 GNU 扩展，BSD/macOS 没有（macOS 的 xargs 默认就不执行空输入）

# 默认 xargs 把参数追加到命令末尾
find . -name '*.log' -print0 | xargs -0 cp -t /backup/      # ✅ 用 -t 指定目标

# 参数要放在中间时用 -I
find . -name '*.log' -print0 | xargs -0 -I {} cp {} /backup/
#                                       ^^^^^ 用 {} 占位
find . -name '*.txt' -print0 | xargs -0 -I {} mv {} {}.bak

# ⚠️ -I 隐含 -L 1，即【每次只处理一个】，会退化成一个文件一个进程（慢）
# 所以能用 -t 或 -exec ... + 的话优先用它们

# ⚠️ -I 与 -0 一起用时，某些版本行为有差异，建议改用 -exec 或 while read

# 串行压缩 1000 个日志（单核跑满）
find . -name '*.log' -print0 | xargs -0 -n1 gzip

# 并行 8 个进程（CPU 密集型任务能快接近 8 倍）
find . -name '*.log' -print0 | xargs -0 -P 8 -n 1 gzip
#                                       ^^^^ 并发数
find . -name '*.log' -print0 | xargs -0 -P "$(nproc)" -n 1 gzip

# 并行删除百万小文件（IO 密集，并发数不宜太高）
find /cache -type f -print0 | xargs -0 -P 4 -n 1000 rm -f

# 并行 ping 一批主机
cat hosts.txt | xargs -P 20 -I {} sh -c 'ping -c1 -W1 {} >/dev/null && echo "{} up"'

# ⚠️ 并行时多个进程的输出会交错混在一起
#    要保证输出完整性，用 GNU parallel（它会缓冲每个任务的输出）
find . -name '*.log' | parallel -j8 gzip {}

# ✅ 处理任意文件名的 while 循环（需要复杂逻辑时）
while IFS= read -r -d '' f; do
    echo "处理: $f"
    # 复杂的多步逻辑
done < <(find . -name '*.log' -print0)
#  ^^^^ IFS= 防止首尾空白被吃
#       -r 防止反斜杠被转义
#       -d '' 以 \0 为分隔符

# 安装：多数发行版已收录
sudo apt install fd-find          # Debian/Ubuntu（命令是 fdfind 或 fd）
sudo dnf install fd-find          # Fedora
brew install fd                   # macOS

# 语法比 find 直观得多
fd '\.log$'                       # 正则默认启用（不需要 -regex）
fd -e log                         # 按扩展名（-e = --extension）
fd -t f -t l                      # 按类型（可多个，f=file l=link d=directory）
fd -s pattern                     # 大小写敏感（默认智能：全小写则不敏感）
fd -H hidden                      # 搜索隐藏文件（-H = --hidden）
fd -I node_modules                # 搜索忽略的目录（-I = --no-ignore）
fd -E node_modules pattern        # -E 排除（可多个）

# 默认彩色输出、自动 .gitignore、速度快（用 Rust 写的）
# 但不如 find 强大：没有 -mtime、-perm、-user 这些

rg 'pattern' /path                # 递归搜索内容（比 grep -r 快很多）
rg -t go 'func main'              # 只搜 .go 文件
rg -g '*.{yml,yaml}' key          # 按 glob 筛选
rg --files-with-matches ERROR     # 只输出文件名（等价 grep -rl）
rg -C 3 pattern                   # 上下文各 3 行

# 自动跳过 .git、node_modules、二进制文件，速度极快
# 服务器上排查日志时比 find + grep 的组合快得多

# 原理：updatedb 预先扫描整个文件系统建索引（通常由 cron 每天跑一次）
#      locate 查询这个索引（毫秒级）

sudo updatedb                     # 手动更新索引
locate nginx.conf                 # 瞬间找到
locate -i nginx                   # 忽略大小写
locate -c '*.log'                 # 只统计数量
locate -r '/var/log/.*\.log$'     # 用正则

# 优势：极快，适合「这个文件在系统的哪个角落」这种问题
# 劣势：① 索引可能过期（刚创建的文件找不到）
#      ② 看得到所有文件的路径（包括你无权访问的）—— 信息泄漏
#      ③ 可能被 /etc/updatedb.conf 排除掉某些目录
cat /etc/updatedb.conf            # 看哪些目录被排除了

# macOS 用的是 mdfind（Spotlight 的 CLI）
mdfind -name nginx.conf

# 现代组合：fd 找文件 + rg 搜内容
fd -e go -x rg 'TODO'             # -x = --exec，类似 find 的 -exec {} +
fd -e log -x gzip                 # 并行压缩

# 仍然需要 find 的场景
find / -perm -4000 -type f        # SUID 审计
find /var/log -mtime +30 -delete  # 按时间清理
find . -newer ref -exec ...       # 比某个时刻新的文件

# 删除 30 天前的压缩日志
find /var/log -name '*.gz' -mtime +30 -delete

# 删除 7 天内没被访问的缓存（atime 不可靠，见注意）
find /var/cache/myapp -type f -atime +7 -delete
# ⚠️ atime 在很多文件系统上默认不更新（relatime），不可靠
#    改用 mtime（修改时间）或 ctime（状态变更时间）更准确

# 递归删除所有空目录
find /data -type d -empty -delete

# 删除多层嵌套的空目录
find /data -depth -type d -empty -delete
#          ^^^^^^ -depth 先处理子目录

# 清理临时构建产物（并行删除加速）
find . -name node_modules -o -name .venv -o -name target | \
    xargs -P 4 -I {} rm -rf {}

# 只删文件、保留目录结构
find /data/cache -type f -delete

# 给所有 .txt 加上日期前缀
find . -name '*.txt' -type f -print0 | \
    xargs -0 -I {} sh -c 'mv "$1" "$(dirname "$1")/$(date +%Y%m%d)_$(basename "$1")"' _ {}

# 转小写（需要 rename 命令，Perl 版）
find . -name '*.JPG' -print0 | xargs -0 rename 's/\.JPG$/.jpg/'

# 批量去掉空格
find . -name '* *' -print0 | \
    while IFS= read -r -d '' f; do mv "$f" "${f// /_}"; done

# 扁平化：把子目录里的文件全部移到当前目录
find . -mindepth 2 -type f -exec mv {} . \;

# 统计各类型文件的总大小
find . -type f -printf '%f\n' | \
    awk -F. '{ext=$NF} {size[ext]+=$1} END {for(e in size) print e, size[e]}'

# 更准确的版本（用 -printf '%s'）
find . -type f -printf '%s %f\n' | \
    awk -F. '{ext=$(NF-1)"."$NF; size[ext]+=$1} END {for(e in size) printf "%-20s %10.2f MB\n", e, size[e]/1024/1024}'

# 找出重复文件（按内容 md5）
find . -type f -exec md5sum {} + | sort | uniq -w32 -d --all-repeated=separate

# 找出最近一小时改过的配置
find /etc -type f -mmin -60 -ls

# 找出大于 1GB 的文件并按大小排序
find / -type f -size +1G -printf '%s %p\n' 2>/dev/null | sort -rn | head -20

# 统计文件数（比 ls | wc 准确且快）
find . -type f -printf . | wc -c

# 统计各目录深度的文件数
find . -printf '%d\n' | sort -n | uniq -c

# 找出所有 SUID/SGID 程序（定期审计）
find / -type f \( -perm -4000 -o -perm -2000 \) -ls 2>/dev/null

# 找出所有人可写的文件（高危）
find / -type f -perm -002 ! -type l -ls 2>/dev/null

# 找出不属于任何已知用户的文件（用户被删后残留）
find /home -nouser -ls

# 修复 ~/.ssh 的权限
find ~/.ssh -type f -exec chmod 600 {} +
find ~/.ssh -type d -exec chmod 700 {} +

# 递归改属主
find /var/www -exec chown www-data:www-data {} +

# 找出最近被改过权限的文件（ctime）
find /etc -cmin -60 -ls

# 只处理已跟踪的文件
git ls-files -z | xargs -0 grep 'TODO'

# 处理已跟踪 + 未跟踪但不在 .gitignore 里的
git ls-files --others --exclude-standard -z | xargs -0 ...

# 找出所有不在 git 里的文件（排查遗漏）
comm -23 <(find . -type f | sort) <(git ls-files | sort)

# 删除所有不在 git 里的文件（危险！先 -n 演练）
git clean -fdxn                   # -n 演练
git clean -fdx                    # 真删

# 增量备份：只复制修改过的文件
find /data -newer /backup/last_backup_timestamp -print0 | \
    rsync -av --files-from=- --from0 / /backup/

# 硬链接快照（Time Machine 风格）
cp -al /backup/last /backup/$(date +%Y%m%d)
find /data -newer /backup/last -print0 | \
    xargs -0 -I {} cp --parents {} /backup/$(date +%Y%m%d)/

# 查找差异
find dir1 dir2 -printf '%P\n' | sort | uniq -u   # 只在一边存在的文件

find [路径...] [全局选项] [表达式]

# 恰好第 7 天那一天（7*86400 ~ 8*86400-1 秒之间）
find . -mtime 7

# 【超过】8 天（age >= 8，即 > 7 取整后）
find . -mtime +7

# 7 天内（age < 7）
find . -mtime -7

# 默认：从当前时刻往回算
find . -mtime +7              # 此刻前 7*86400 秒之前

# -daystart：从今天 0 点往回算
find . -daystart -mtime +7    # 今天 0 点前的第 7 个完整日

# 实用性：-daystart 语义更符合"日志按天归档"的直觉

-newer FILE          比 FILE 的 mtime 新
-anewer FILE         比 FILE 的 atime 新
-cnewer FILE         比 FILE 的 ctime 新
-newerXY REF         X=a/c/m/t，Y=a/c/m/t（X是被比较的时间，Y是参考的时间）
                     t = 直接用时间字符串

find . -newermt '2026-08-01 15:30:00'
find . -newermt '1 week ago'
find . -newermt @1722499200          # Unix 时间戳
find . ! -newermt '7 days ago'       # 7 天前及更早

# 条件格式化：只有非空时才输出
find . -type l -printf '%p -> %l\n'        # 软链接加箭头
find . -printf '%M %u %10s %p\n'           # 类似 ls -l

# 配合 NUL 做安全的管道（比 -print0 更灵活）
find . -name '*.log' -printf '%p\0' | while IFS= read -r -d '' f; do ...; done

# ① 限制深度（最便宜的优化）
find /var/log -maxdepth 2 -name '*.log'

# ② 先用便宜的条件过滤
find . -type f -name '*.go' ...           # 比倒过来快

# ③ 不跨文件系统（跳过挂载点）
find / -xdev ...

# ④ 剪枝而不是过滤
find . -name node_modules -prune -o ...

# ⑤ 用 -quit 找到就退出（判断存在时）
if find /data -name '*.lock' -print -quit | grep -q .; then ...

# ⑥ 用 + 而不是 \;
find . -exec cmd {} +

# ⑦ 并行（xargs -P）
find . -print0 | xargs -0 -P $(nproc) cmd

# ⑧ 避免 -exec 里跑 shell（每次都 fork bash）
find . -name '*.txt' -exec sh -c '...' _ {} \;        # 慢
find . -name '*.txt' -exec mycommand {} +             # 快

# ⑨ 大量文件时，ls + grep 可能比 find 快（目录已在 dentry cache 里）
ls -1 | grep '.log$'                  # 单层目录

find . \( -name '*.tmp' -o -name '*.log' \) -delete

find . -name '*.log' -print0 | xargs -0 rm

find . -name '*.log' -exec rm {} +

find /var/log -type f ! -newermt '7 days ago' -delete

# ❌ 慢：仍递归进 node_modules
find . -type f ! -path '*/node_modules/*'

# ✅ 快：遇到就剪枝
find . -name node_modules -prune -o -type f -print

find 路径 <排除条件> -prune -o <真正的条件> -print

find / -perm -4000 -type f -ls 2>/dev/null
# 定期审计，发现可疑的立即排查

find / -type f -perm -002 ! -type l -ls 2>/dev/null
# ! -type l 排除软链接（软链接自身权限永远是 777 但无意义）

# ❌ 危险：find 没找到任何文件，xargs 仍会执行一次 rm（无参数）
find /tmp -name '*.nonexistent' | xargs rm
# rm: missing operand               <- 只是报错，但换成别的命令可能出事
echo "" | xargs ls
# （列出了当前目录！）

# ✅ 加 -r
find /tmp -name '*.nonexistent' -print0 | xargs -0 -r rm