Claude Code 把搜索拆成三件功能不同的工具—— Grep 找内容、Glob 找路径、Bash 兜底什么都能干。 用对工具是导航的第一性原理：用错了不仅慢,还会找不全。

三件工具的职责分工

Grep 关键参数

# 1. 最简单 — 找出现 useState 的所有文件
Grep pattern: "useState"

# 2. 限定路径 + 文件类型
Grep pattern: "useState", glob: "src/**/*.tsx"

# 3. 看上下文 (前 2 行 + 后 5 行)
Grep pattern: "useState", -B: 2, -A: 5,
     output_mode: "content"

# 4. 大小写不敏感 + 限制结果数
Grep pattern: "todo", -i: true, head_limit: 50

# 5. 多行匹配 (跨换行的 import)
Grep pattern: "import\\s+\\{[\\s\\S]*?Logger",
     multiline: true

三种 output_mode

Glob 路径模式

# Glob 支持双星号递归与逗号分组

Glob pattern: "src/**/*.ts"             # src 下所有 ts
Glob pattern: "**/*.{test,spec}.ts"     # 所有 test/spec 文件
Glob pattern: "src/!(node_modules)/**/*.ts" # 排除 node_modules
Glob pattern: "docs/*.md"                # 仅 docs 直接子文件

# 结果按 mtime 倒序 — 最近改的优先
# 结果数太多时,先看最近的几个通常足够

"搜索找不到"——99% 是模式写错了,不是它不存在。 下面是把 Grep 用准的 5 个常见技巧。

常见陷阱

高频正则模板

# 1. 函数定义(JS/TS)
"^(export\\s+)?(async\\s+)?function\\s+myFunc\\b"
"const\\s+myFunc\\s*=\\s*(async\\s*)?\\("     # 箭头函数

# 2. 类方法定义(无 function 关键字)
"^\\s+(async\\s+)?myMethod\\s*\\("

# 3. import 该模块
"from\\s+['\"][^'\"]*myModule['\"]"

# 4. 函数调用(排除定义)
"\\bmyFunc\\s*\\(" + 配合 -v 排除定义文件

# 5. TODO / FIXME / XXX 三类待办
"\\b(TODO|FIXME|XXX|HACK)\\b"     + -i

# 6. 跨行 try-catch 块
"try\\s*\\{[\\s\\S]*?\\}\\s*catch"   + multiline

# 7. 类型定义(TS interface / type)
"^(export\\s+)?(interface|type)\\s+UserProfile\\b"

两步搜索 — 缩小范围

大型仓库一次搜可能命中几千行——分两步收敛比一次搞定更高效。

# 第 1 步: 找出涉及 X 的文件(files_with_matches)
Grep pattern: "PaymentService",
     output_mode: "files_with_matches"
# 输出: 17 个文件

# 第 2 步: 在这些文件里精确找定义
Grep pattern: "^(export\\s+)?class\\s+PaymentService\\b",
     glob: "src/payments/**",
     output_mode: "content"
# 输出: 1 处定义 + 文件路径,可直接跳到 Read

find 兜底场景

# Grep / Glob 不擅长的:基于 metadata 的查找

# 1. 最近 1 小时改过的文件
$ find . -type f -mmin -60 -not -path './node_modules/*'

# 2. 大于 1MB 的源码文件(找该拆的大文件)
$ find src -type f -size +1M -name '*.ts'

# 3. 空文件 / 只有声明没实现的文件
$ find src -type f -size -100c

# 4. 软链 / 死链
$ find . -type l -! -exec test -e {} \\; -print

# 5. 修改时间组合 — 上周改过 + 今周没动
$ find . -mtime -14 -mtime +7 -name '*.go'

"改一个函数前要先看谁在调它"——这是影响面分析的核心。 没有 LSP 的纯文本搜索做不到 100% 精确,但三步法可以让你在 2 分钟内 画出函数的完整使用图。

三步法 · 找完整影响面

实战:重命名 getUser

# Step 1 — 找定义
Grep pattern: "^(export\\s+)?(async\\s+)?function\\s+getUser\\b",
     output_mode: "content"
# 输出: src/auth/user.ts:42 — function getUser(id: string)

# Step 2 — 找 callers (调用 + 排除定义文件)
Grep pattern: "\\bgetUser\\s*\\(",
     output_mode: "content",
     -n: true
# 输出 23 处调用 — 含定义本身,需手动排除

# Step 3 — 对每个 caller 取上下文
Grep pattern: "\\bgetUser\\s*\\(",
     -A: 3, -B: 1,
     output_mode: "content"
# 看 callers 在做什么 — 有的是测试,有的是 fallback

# Step 4 — 找类型流转(被赋给什么类型变量)
Grep pattern: "const\\s+\\w+\\s*=\\s*await\\s+getUser"
# 看返回值都被怎么消费

import / export 关系图

# 找谁在 import 这个模块
Grep pattern: "from\\s+['\"][^'\"]*payments/index['\"]"

# 找这个模块 export 了哪些符号
Grep pattern: "^export\\s+(const|function|class|type|interface)",
     glob: "src/payments/index.ts",
     output_mode: "content"

# 找循环依赖嫌疑(A 引 B + B 引 A)
Grep pattern: "from\\s+['\"]./auth",  glob: "src/user/**"
Grep pattern: "from\\s+['\"]./user",  glob: "src/auth/**"
# 两个都有命中 → 大概率循环依赖

跨语言查找速查表

自己直接搜适合已知关键词的精确查找。 一旦目标模糊（"权限验证逻辑都在哪?"、"哪些地方处理了 race condition?"） 或者要查 5+ 处不同方向——把任务交给 Explore agent 更高效。

直搜 vs 派 Explore 决策表

Explore agent 调用模板

# 在 Claude Code 主会话里,可以这样让它调 Explore:

> 用 Explore agent 帮我找一下:
  权限验证逻辑都分布在哪些文件里? 是用中间件还是装饰器?
  搜索广度: medium

# Claude 会调起 subagent_type=Explore 的子代理
# 子代理在隔离上下文里跑多次 Grep / Glob / Read
# 主会话只收到一份总结报告

三档广度参数

Explore 不该做的事

主会话 vs Explore 的上下文边界

50 万行 monorepo 的导航和 5000 行小项目完全不同—— 工具链一样,但策略必须升级。

5 条经验法则

Token 预算管理

缓存与思维模型

第二次找同一类东西时,不要再搜一遍——把上次的结论记下来。 Day 12 的 Memory 系统是天然的代码库导航 cache:

# 第一次摸清楚后,存成 reference 类 memory:
> 记一下: 项目的认证逻辑分布在
  - src/auth/middleware/ — Express 中间件
  - src/services/auth.ts — 业务层
  - packages/shared/jwt.ts — 共享 JWT 工具
  下次问"权限"相关问题先看这三个位置,再扩展搜索

# Claude 会保存为 reference memory
# 之后再问类似问题,Claude 直接定位,无需重新探索

四个递进的实验——从最基础的 Grep 用法到完整的影响面分析。 预计 50 分钟，全部在你最熟的项目里完成,效果最好。

1. Grep / Glob / Bash find / Read / Explore agent 五种工具的职责分工是什么? 给一个"该用哪个"的判断口诀。
2. "两步搜索"指什么? 它在 token 预算上有什么优势?
3. 查函数 callers 时为什么要用 \\bname\\s*\\( 而不是纯关键字 name?
4. 什么场景下应该派 Explore agent? 什么场景下反而不该用它?
5. 大型 monorepo 搜索慢——给出至少 3 条提速策略。