Claude Code 从入门到精通
·
Claude Code 从入门到精通
一份面向零基础读者的完整教程，带你从安装到高级配置，全面掌握 Claude Code。
目录
第一部分：基础入门
第1章：Claude Code 简介
1.1 什么是 Claude Code？
Claude Code 是 Anthropic 公司开发的一款 AI 编程助手工具。它运行在命令行（终端）中，可以帮助你完成各种编程任务。
简单来说： Claude Code 就是一个住在你电脑终端里的智能编程助手，你可以用自然语言（说人话）告诉它你想做什么，它会帮你完成。
┌─────────────────────────────────────────────────────────────┐
│ │
│ 你（人类） │
│ │ │
│ │ 自然语言（说人话） │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Claude Code（AI 助手） │ │
│ │ │ │
│ │ • 理解你的需求 │ │
│ │ • 生成代码 │ │
│ │ • 编辑文件 │ │
│ │ • 执行命令 │ │
│ │ • 调试程序 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ │ 操作文件、执行命令 │
│ ▼ │
│ 你的电脑（文件系统、终端） │
│ │
└─────────────────────────────────────────────────────────────┘
1.2 Claude Code 能做什么？
Claude Code 可以帮你完成以下任务：
| 功能 | 说明 | 示例 |
|---|---|---|
| 代码生成 | 根据描述生成代码 | “帮我写一个计算器程序” |
| 代码编辑 | 修改现有代码 | “把这段代码改成异步的” |
| 代码调试 | 找出并修复 bug | “为什么这段代码报错了？” |
| 代码重构 | 优化代码结构 | “重构这个函数，让它更简洁” |
| 测试编写 | 编写单元测试 | “为这个函数写测试用例” |
| Git 操作 | 版本控制 | “提交当前修改” |
| 文件操作 | 读写文件 | “创建一个新文件” |
| 项目管理 | 管理整个项目 | “帮我初始化一个 React 项目” |
1.3 Claude Code 与其他 AI 工具的区别
┌─────────────────────────────────────────────────────────────────────────────┐
│ AI 编程工具对比 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ 工具 运行环境 操作方式 文件操作 │
│ ───────────────────────────────────────────────────────────────── │
│ Claude Code 命令行/终端 自然语言对话 直接操作文件 │
│ GitHub Copilot IDE 插件 代码补全 仅代码补全 │
│ ChatGPT 网页/APP 对话式 需要复制粘贴 │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
核心区别：
┌─────────────────────────────────────────────────────────────┐
│ │
│ Claude Code 独特优势 │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ 直接操作文件 │ │ 执行系统命令 │ │ 理解整个项目 │ │
│ │ │ │ │ │ │ │
│ │ 不需要复制 │ │ 可以运行 │ │ 看懂代码库 │ │
│ │ 粘贴代码 │ │ 测试、构建 │ │ 的结构 │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
1.4 为什么选择 Claude Code？
┌─────────────────────────────────────────────────────────────┐
│ │
│ 选择 Claude Code 的 5 个理由 │
│ │
│ 1. 强大的代码理解能力 ──── 能理解复杂的代码库结构 │
│ │
│ 2. 直接操作文件 ────────── 不需要复制粘贴 │
│ │
│ 3. 自然语言交互 ────────── 用日常语言描述需求即可 │
│ │
│ 4. 安全性高 ────────────── 执行危险操作前会确认 │
│ │
│ 5. 可扩展性强 ──────────── 支持 MCP、钩子等高级功能 │
│ │
└─────────────────────────────────────────────────────────────┘
1.5 本章小结
- Claude Code 是一个 AI 编程助手
- 它运行在命令行中，用自然语言交互
- 可以完成代码生成、编辑、调试、测试等多种任务
- 相比其他工具，它能直接操作文件和执行命令
第2章：安装与配置
2.1 系统要求
在安装 Claude Code 之前，请确保你的电脑满足以下要求：
┌─────────────────────────────────────────────────────────────┐
│ │
│ 系统要求 │
│ │
│ 操作系统： │
│ ├── Windows 10/11 │
│ ├── macOS 10.15 或更高版本 │
│ └── Linux（Ubuntu 20.04+, Debian 10+, Fedora 34+ 等） │
│ │
│ 软件要求： │
│ ├── Node.js 18 或更高版本 │
│ ├── npm（通常随 Node.js 一起安装） │
│ └── 终端/命令行工具 │
│ │
└─────────────────────────────────────────────────────────────┘
2.2 安装 Node.js
如果你还没有安装 Node.js，请按以下步骤操作：
Windows 用户：
┌─────────────────────────────────────────────────────────────┐
│ │
│ 安装 Node.js 步骤（Windows） │
│ │
│ 步骤 1：打开浏览器 │
│ └── 访问 https://nodejs.org │
│ │
│ 步骤 2：下载 │
│ └── 点击 "LTS"（长期支持版）下载按钮 │
│ │
│ 步骤 3：安装 │
│ └── 运行安装程序，一路点击 "Next" │
│ │
│ 步骤 4：验证 │
│ └── 打开命令提示符（Win+R，输入 cmd） │
│ └── 输入：node --version │
│ └── 显示版本号即表示安装成功 │
│ │
└─────────────────────────────────────────────────────────────┘
验证安装：
node --version
npm --version
如果显示版本号（如 v18.17.0），说明安装成功。
macOS 用户：
┌─────────────────────────────────────────────────────────────┐
│ │
│ 安装 Node.js 步骤（macOS） │
│ │
│ 方法 1：使用 Homebrew（推荐） │
│ └── 打开终端（Spotlight 搜索 "Terminal"） │
│ └── 运行：brew install node │
│ │
│ 方法 2：官网下载 │
│ └── 访问 https://nodejs.org │
│ └── 下载安装包 │
│ │
└─────────────────────────────────────────────────────────────┘
Linux 用户：
# Ubuntu/Debian
sudo apt update
sudo apt install nodejs npm
# 或者使用 NodeSource 安装最新版
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt install nodejs
2.3 安装 Claude Code
Node.js 安装完成后，就可以安装 Claude Code 了。
┌─────────────────────────────────────────────────────────────┐
│ │
│ 安装 Claude Code 流程 │
│ │
│ ┌─────────────┐ │
│ │ 打开终端 │ │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 输入安装命令 │ ──→ npm install -g @anthropic-ai/claude-code │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 等待安装完成 │ │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 验证安装 │ ──→ claude --version │
│ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
步骤 1：打开终端
- Windows：按
Win+R，输入cmd，回车 - macOS：按
Cmd+空格，输入 “Terminal”，回车 - Linux：按
Ctrl+Alt+T
步骤 2：运行安装命令
npm install -g @anthropic-ai/claude-code
这个命令的意思是：
npm install- 使用 npm 安装包-g- 全局安装（在任何地方都能使用）@anthropic-ai/claude-code- Claude Code 的包名
步骤 3：验证安装
claude --version
如果显示版本号，说明安装成功。
2.4 首次启动配置
┌─────────────────────────────────────────────────────────────┐
│ │
│ 首次启动配置流程 │
│ │
│ ┌─────────────┐ │
│ │ 输入 claude │ │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 显示登录链接 │ │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 浏览器登录 │ ──→ 登录 Anthropic 账号 │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 授权访问 │ │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 选择模型 │ ──→ 推荐选择 Sonnet │
│ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
步骤 1：启动 Claude Code
claude
步骤 2：登录 Anthropic 账号
首次启动时，Claude Code 会引导你完成登录：
- 系统会显示一个链接
- 在浏览器中打开该链接
- 登录你的 Anthropic 账号（如果没有，需要注册）
- 授权 Claude Code 访问你的账号
- 返回终端，完成登录
步骤 3：选择模型
Claude Code 会询问你想使用哪个模型：
┌─────────────────────────────────────────────────────────────┐
│ │
│ 可选模型 │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Claude Sonnet ──── 平衡速度和质量（推荐新手使用） │ │
│ │ │ │
│ │ Claude Opus ────── 最强大，但速度较慢 │ │
│ │ │ │
│ │ Claude Haiku ───── 最快，但能力稍弱 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 建议新手选择 Sonnet │
│ │
└─────────────────────────────────────────────────────────────┘
2.5 配置 API 密钥（可选）
如果你有 Anthropic API 密钥，可以直接配置：
方法 1：环境变量
# Windows (命令提示符)
set ANTHROPIC_API_KEY=你的API密钥
# Windows (PowerShell)
$env:ANTHROPIC_API_KEY="你的API密钥"
# macOS/Linux
export ANTHROPIC_API_KEY="你的API密钥"
方法 2：配置文件
创建或编辑 ~/.claude/config.json 文件：
{
"apiKey": "你的API密钥"
}
2.6 配置文件位置
Claude Code 的配置文件存放在以下位置：
┌─────────────────────────────────────────────────────────────┐
│ │
│ 配置文件位置 │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Windows │ │
│ │ └── C:\Users\你的用户名\.claude\ │ │
│ │ │ │
│ │ macOS │ │
│ │ └── ~/.claude/ │ │
│ │ │ │
│ │ Linux │ │
│ │ └── ~/.claude/ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 主要文件： │
│ ├── config.json ───── 主配置文件 │
│ ├── settings.json ─── 设置文件 │
│ └── memory/ ────────── 记忆目录 │
│ │
└─────────────────────────────────────────────────────────────┘
2.7 本章小结
- 安装 Claude Code 前需要先安装 Node.js 18+
- 使用
npm install -g @anthropic-ai/claude-code安装 - 首次启动需要登录 Anthropic 账号
- 配置文件存放在
~/.claude/目录
第3章：基本操作界面
3.1 启动 Claude Code
打开终端，输入以下命令启动 Claude Code：
claude
你会看到类似这样的欢迎界面：
┌─────────────────────────────────────────────────────────────┐
│ │
│ Claude Code 启动界面 │
│ │
│ ╭──────────────────────────────────────────────╮ │
│ │ │ │
│ │ Claude Code │ │
│ │ │ │
│ │ /help for commands, /quit to exit │ │
│ │ │ │
│ ╰──────────────────────────────────────────────╯ │
│ │
│ > █ │
│ ↑ │
│ └── 这是提示符，等待你的输入 │
│ │
└─────────────────────────────────────────────────────────────┘
3.2 界面元素说明
┌─────────────────────────────────────────────────────────────┐
│ │
│ 界面元素说明 │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ > █ ← 提示符（Prompt） │ │
│ │ │ │ │
│ │ │ 表示 Claude Code 正在等待你的输入 │ │
│ │ │ 你可以在这里输入任何你想说的话或命令 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 输入类型： │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ /help ──→ 斜杠命令（内置功能） │ │
│ │ │ │
│ │ 帮我写代码 ──→ 自然语言（发送给 Claude） │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
提示符（Prompt）
>符号表示 Claude Code 正在等待你的输入- 你可以在这里输入任何你想说的话或命令
斜杠命令
- 以
/开头的命令是 Claude Code 的内置命令 - 例如：
/help、/quit、/clear
普通输入
- 不以
/开头的内容会被当作自然语言发送给 Claude - Claude 会理解你的意图并执行相应操作
3.3 基本交互方式
方式 1：直接对话
你可以像和人聊天一样与 Claude Code 交互：
┌─────────────────────────────────────────────────────────────┐
│ │
│ 直接对话示例 │
│ │
│ 你输入： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ > 帮我创建一个 hello.py 文件，打印 "Hello, World!" │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ Claude Code 会： │
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 1. 理解需求 │ → │ 2. 创建文件 │ → │ 3. 写入代码 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
│ 然后告诉你完成了！ │
│ │
└─────────────────────────────────────────────────────────────┘
方式 2：使用斜杠命令
> /help
这会显示所有可用的命令列表。
方式 3：混合使用
你可以在对话中混合使用自然语言和命令：
> 先看看当前目录有什么文件，然后帮我创建一个新项目
3.4 常用斜杠命令
┌─────────────────────────────────────────────────────────────┐
│ │
│ 常用斜杠命令速查 │
│ │
│ ┌──────────────┬────────────────────┬─────────────────┐ │
│ │ 命令 │ 功能 │ 示例 │ │
│ ├──────────────┼────────────────────┼─────────────────┤ │
│ │ /help │ 显示帮助信息 │ /help │ │
│ │ /quit │ 退出 Claude Code │ /quit │ │
│ │ /clear │ 清空当前对话 │ /clear │ │
│ │ /config │ 打开配置 │ /config │ │
│ │ /model │ 切换模型 │ /model sonnet │ │
│ │ /compact │ 压缩对话历史 │ /compact │ │
│ │ /cost │ 显示当前费用 │ /cost │ │
│ │ /memory │ 管理记忆 │ /memory │ │
│ └──────────────┴────────────────────┴─────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
3.5 输入技巧
多行输入
如果需要输入多行内容，可以使用 Shift+Enter 换行（而非直接 Enter）：
┌─────────────────────────────────────────────────────────────┐
│ │
│ 多行输入示例 │
│ │
│ > 第一行内容 │
│ 第二行内容 │
│ 第三行内容 │
│ │
│ 提示：使用 Shift+Enter 换行，直接 Enter 会发送消息 │
│ │
└─────────────────────────────────────────────────────────────┘
代码块输入
如果需要输入代码，可以直接粘贴代码：
┌─────────────────────────────────────────────────────────────┐
│ │
│ 代码块输入示例 │
│ │
│ > 请帮我看看这段代码有什么问题： │
│ │
│ def hello(): │
│ print("Hello) │
│ │
│ Claude Code 会自动识别代码并分析问题 │
│ │
└─────────────────────────────────────────────────────────────┘
文件路径自动补全
输入文件路径时，可以使用 Tab 键 自动补全：
┌─────────────────────────────────────────────────────────────┐
│ │
│ Tab 自动补全示例 │
│ │
│ 你输入： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ > 帮我看看 src/ma<Tab> │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 自动补全为： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ > 帮我看看 src/main.py │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 前提：src/main.py 文件必须存在 │
│ │
└─────────────────────────────────────────────────────────────┘
3.6 查看帮助
任何时候都可以输入 /help 查看帮助：
┌─────────────────────────────────────────────────────────────┐
│ │
│ 查看帮助 │
│ │
│ 你输入： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ > /help │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 帮助信息会显示： │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ • 所有可用的斜杠命令 │ │
│ │ • 命令的简要说明 │ │
│ │ • 使用示例 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
3.7 退出 Claude Code
有几种方式可以退出：
┌─────────────────────────────────────────────────────────────┐
│ │
│ 退出 Claude Code 的方法 │
│ │
│ 方法 1：使用斜杠命令 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ > /quit │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 方法 2：使用快捷键 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 按 Ctrl+C 两次 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 方法 3：使用 exit 命令 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ > exit │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
3.8 本章小结
- 使用
claude命令启动 Claude Code >提示符表示等待输入- 斜杠命令（如
/help）是内置功能 - 自然语言输入会被 Claude 理解并执行
- 使用
/quit或Ctrl+C退出 - Tab 键可以自动补全文件路径
第4章：核心命令详解
4.1 文件操作命令
查看文件
┌─────────────────────────────────────────────────────────────┐
│ │
│ 查看文件内容 │
│ │
│ 你输入： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ > 帮我看看 main.py 的内容 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ Claude Code 会： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 1. 找到 main.py 文件 │ │
│ │ 2. 读取文件内容 │ │
│ │ 3. 显示内容给你 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
创建文件
> 创建一个新文件 config.json，内容是默认配置
Claude Code 会创建文件并写入默认配置内容。
编辑文件
> 把 main.py 里的 print("Hello") 改成 print("Hello, World!")
Claude Code 会找到对应代码并修改。
删除文件
> 删除 temp.txt 文件
Claude Code 会确认后删除文件。
4.2 目录操作命令
查看目录结构
> 显示当前目录的结构
创建目录
> 创建一个 src 目录
切换目录
> 切换到 src 目录
4.3 代码相关命令
运行代码
┌─────────────────────────────────────────────────────────────┐
│ │
│ 运行代码示例 │
│ │
│ 你输入： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ > 运行 main.py │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ Claude Code 会执行： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ python main.py │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 并显示运行结果 │
│ │
└─────────────────────────────────────────────────────────────┘
安装依赖
> 安装 requirements.txt 里的依赖
Claude Code 会执行 pip install -r requirements.txt。
格式化代码
> 格式化当前目录下所有的 Python 文件
4.4 Git 命令
查看状态
> 查看 git 状态
提交代码
> 提交当前修改，提交信息是 "修复登录 bug"
查看历史
> 显示最近 10 次提交记录
4.5 搜索命令
搜索文件
> 找到所有 .py 文件
搜索内容
> 在所有文件中搜索 "TODO"
4.6 系统命令
执行 shell 命令
┌─────────────────────────────────────────────────────────────┐
│ │
│ 执行 shell 命令 │
│ │
│ 方法 1：直接描述 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ > 执行 ls -la │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 方法 2：使用 ! 前缀 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ > ! ls -la │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 两种方法效果相同 │
│ │
└─────────────────────────────────────────────────────────────┘
4.7 对话管理命令
清空对话
> /clear
压缩对话
当对话太长时，可以压缩历史：
> /compact
查看费用
> /cost
会显示当前会话消耗的 token 数量和费用。
4.8 配置命令
查看配置
> /config
切换模型
> /model opus
设置主题
> /theme dark
4.9 本章小结
┌─────────────────────────────────────────────────────────────┐
│ │
│ 本章要点 │
│ │
│ • Claude Code 支持自然语言操作文件和目录 │
│ • Git 操作可以通过自然语言完成 │
│ • 搜索功能可以查找文件和内容 │
│ • 使用 `/` 前缀可以执行内置命令 │
│ • `!` 前缀可以直接执行 shell 命令 │
│ │
└─────────────────────────────────────────────────────────────┘
第二部分：编程实战
第5章：代码生成与编辑
5.1 生成新代码
基本代码生成
最简单的代码生成方式是直接描述你想要什么：
┌─────────────────────────────────────────────────────────────┐
│ │
│ 代码生成流程 │
│ │
│ 你输入： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ > 帮我写一个 Python 函数，计算两个数的和 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ ↓ │
│ │
│ Claude Code 生成： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ def add(a, b): │ │
│ │ return a + b │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
生成完整文件
> 创建一个 calculator.py 文件，实现一个简单的计算器，支持加减乘除
Claude Code 会创建完整的文件：
# calculator.py
def add(a, b):
return a + b
def subtract(a, b):
return a - b
def multiply(a, b):
return a * b
def divide(a, b):
if b == 0:
raise ValueError("除数不能为零")
return a / b
def main():
print("简单计算器")
print("1. 加法")
print("2. 减法")
print("3. 乘法")
print("4. 除法")
choice = input("请选择操作 (1-4): ")
num1 = float(input("输入第一个数: "))
num2 = float(input("输入第二个数: "))
if choice == '1':
result = add(num1, num2)
elif choice == '2':
result = subtract(num1, num2)
elif choice == '3':
result = multiply(num1, num2)
elif choice == '4':
result = divide(num1, num2)
else:
print("无效选择")
return
print(f"结果是: {result}")
if __name__ == "__main__":
main()
生成特定功能的代码
> 写一个函数，从 CSV 文件读取数据并返回字典列表
> 创建一个 Flask API，有 GET 和 POST 接口
> 写一个 React 组件，显示一个可点击的按钮
5.2 编辑现有代码
修改特定代码
> 把 main.py 里的 print("Hello") 改成 print("Hello, World!")
添加新功能
> 在 calculator.py 里添加一个求幂的函数
修改函数签名
┌─────────────────────────────────────────────────────────────┐
│ │
│ 修改函数示例 │
│ │
│ 你输入： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ > 把 add 函数改成支持任意数量参数 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 修改前： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ def add(a, b): │ │
│ │ return a + b │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 修改后： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ def add(*args): │ │
│ │ return sum(args) │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
5.3 代码补全
当你开始写代码但不确定怎么完成时：
> 我正在写一个排序函数，帮我完成：
def bubble_sort(arr):
n = len(arr)
for i in range(n):
# TODO: 完成排序逻辑
Claude Code 会补全剩余的代码。
5.4 代码转换
转换编程语言
> 把这个 Python 函数转换成 JavaScript：
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n-1) + fibonacci(n-2)
转换代码风格
> 把这段代码改成函数式编程风格
> 把这段同步代码改成异步的
5.5 批量操作
批量修改
> 把项目里所有的 console.log 改成 logger.info
批量生成
> 为 models 目录下的每个模型文件生成对应的测试文件
5.6 代码生成最佳实践
┌─────────────────────────────────────────────────────────────┐
│ │
│ 代码生成最佳实践 │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ❌ 不好的描述： │ │
│ │ > 写个函数 │ │
│ │ │ │
│ │ ✅ 好的描述： │ │
│ │ > 写一个 Python 函数，接收一个字符串列表， │ │
│ │ 返回其中长度大于 5 的字符串 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 技巧： │
│ • 描述要具体 │
│ • 提供上下文 │
│ • 指定代码风格 │
│ • 复杂功能分步骤生成 │
│ │
└─────────────────────────────────────────────────────────────┘
5.7 常见问题
Q: 生成的代码有错误怎么办？
> 这段代码有错误，请帮我修复：
def divide(a, b):
return a / b
Q: 生成的代码不符合我的要求？
> 这段代码不对，我需要的是支持负数的情况，请修改
Q: 想要更高效的实现？
> 这段代码效率太低，请用更高效的算法重写
5.8 本章小结
- 用自然语言描述需求，Claude Code 会生成代码
- 可以编辑、修改、重构现有代码
- 支持代码补全和转换
- 描述越具体，生成的代码越准确
- 复杂功能可以分步骤生成
第6章：代码调试
6.1 基本调试方法
运行代码查看错误
> 运行 main.py，看看有没有错误
Claude Code 会执行代码并显示错误信息。
分析错误信息
当代码报错时，把错误信息发给 Claude：
┌─────────────────────────────────────────────────────────────┐
│ │
│ 调试示例：分析错误信息 │
│ │
│ 你输入： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ > 我运行代码时报了这个错误，请帮我分析： │ │
│ │ │ │
│ │ Traceback (most recent call last): │ │
│ │ File "main.py", line 5, in <module> │ │
│ │ result = divide(10, 0) │ │
│ │ File "main.py", line 2, in divide │ │
│ │ return a / b │ │
│ │ ZeroDivisionError: division by zero │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ Claude Code 会： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 1. 分析错误原因 │ │
│ │ 2. 指出问题所在 │ │
│ │ 3. 提供修复建议 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
6.2 常见错误类型
┌─────────────────────────────────────────────────────────────┐
│ │
│ 常见错误类型 │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 语法错误（SyntaxError） │ │
│ │ └── 代码不符合 Python 语法规则 │ │
│ │ └── 例如：缺少冒号、括号不匹配 │ │
│ │ │ │
│ │ 类型错误（TypeError） │ │
│ │ └── 数据类型不匹配 │ │
│ │ └── 例如：字符串和数字相加 │ │
│ │ │ │
│ │ 索引错误（IndexError） │ │
│ │ └── 访问不存在的索引 │ │
│ │ └── 例如：列表只有3个元素，访问第10个 │ │
│ │ │ │
│ │ 属性错误（AttributeError） │ │
│ │ └── 调用不存在的方法或属性 │ │
│ │ └── 例如：对字符串使用 append 方法 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
语法错误（SyntaxError）
> 这段代码报语法错误，请帮我找出问题：
def hello()
print("Hello")
Claude Code 会指出缺少冒号。
类型错误（TypeError）
> 这段代码报类型错误：
x = "5"
y = 10
print(x + y)
Claude Code 会建议类型转换。
索引错误（IndexError）
> 这段代码报索引错误：
arr = [1, 2, 3]
print(arr[5])
属性错误（AttributeError）
> 这段代码报属性错误：
text = "hello"
text.append(" world")
6.3 调试技巧
┌─────────────────────────────────────────────────────────────┐
│ │
│ 调试技巧 │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 1. 添加打印语句 │ │
│ │ > 在 main.py 的第 10 行添加一个 print 语句， │ │
│ │ 打印变量 x 的值 │ │
│ │ │ │
│ │ 2. 使用断点 │ │
│ │ > 在 divide 函数里添加断点，我想看看参数值 │ │
│ │ │ │
│ │ 3. 逐步调试 │ │
│ │ > 帮我一步步调试这个函数，找出问题所在 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
6.4 逻辑错误调试
逻辑错误不会报错，但结果不正确：
> 这个函数应该返回最大值，但结果不对，请帮我找出问题：
def find_max(arr):
max_val = 0
for num in arr:
if num > max_val:
max_val = num
return max_val
Claude Code 会指出：如果数组全是负数，初始值 0 会导致错误结果。
6.5 性能问题调试
> 这段代码运行很慢，请帮我找出性能问题：
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n-1) + fibonacci(n-2)
Claude Code 会建议使用记忆化或迭代方法。
6.6 调试工作流
┌─────────────────────────────────────────────────────────────┐
│ │
│ 调试工作流 │
│ │
│ ┌─────────────┐ │
│ │ 1. 复现问题 │ ──→ 运行代码，确认问题存在 │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 2. 分析错误 │ ──→ 查看错误信息，理解问题 │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 3. 定位代码 │ ──→ 找到导致错误的代码位置 │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 4. 修复问题 │ ──→ 修改代码，解决错误 │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 5. 验证修复 │ ──→ 再次运行，确认问题已解决 │
│ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
6.7 调试示例
示例 1：修复除零错误
问题代码：
def calculate_average(numbers):
total = sum(numbers)
count = len(numbers)
return total / count
调试过程：
> 这个函数在空列表时会报错，请帮我修复
修复后：
def calculate_average(numbers):
if not numbers:
return 0
total = sum(numbers)
count = len(numbers)
return total / count
示例 2：修复无限循环
问题代码：
def countdown(n):
while n > 0:
print(n)
# 忘记递减 n
调试过程：
> 这个倒计时函数会无限循环，请帮我修复
修复后：
def countdown(n):
while n > 0:
print(n)
n -= 1
6.8 本章小结
┌─────────────────────────────────────────────────────────────┐
│ │
│ 本章要点 │
│ │
│ • 把错误信息发给 Claude Code 分析 │
│ • 常见错误类型：语法、类型、索引、属性错误 │
│ • 逻辑错误需要分析代码行为 │
│ • 性能问题需要优化算法 │
│ • 调试工作流：复现 → 分析 → 定位 → 修复 → 验证 │
│ │
└─────────────────────────────────────────────────────────────┘
第7章：代码重构
7.1 什么是代码重构？
代码重构是在不改变代码外部行为的前提下，改善代码内部结构的过程。
┌─────────────────────────────────────────────────────────────┐
│ │
│ 代码重构的目标 │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ 提高可读性 │ │ 减少重复 │ │ 提高可维护性 │ │
│ │ │ │ │ │ │ │
│ │ 让代码更容易 │ │ 避免复制粘贴 │ │ 方便后续修改 │ │
│ │ 理解 │ │ │ │ │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
7.2 基本重构操作
重命名变量
> 把 main.py 里的变量 x 改成 user_name
提取函数
> 把这段代码提取成一个独立的函数：
# 处理用户输入
name = input("请输入名字: ")
if not name:
print("名字不能为空")
name = "默认用户"
name = name.strip()
内联函数
> 把这个简单的函数内联回调用处：
def get_name():
return "Claude"
name = get_name()
7.3 代码风格重构
简化条件表达式
┌─────────────────────────────────────────────────────────────┐
│ │
│ 简化条件表达式示例 │
│ │
│ 重构前： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ if x > 0: │ │
│ │ result = "正数" │ │
│ │ else: │ │
│ │ if x < 0: │ │
│ │ result = "负数" │ │
│ │ else: │ │
│ │ result = "零" │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 重构后： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ if x > 0: │ │
│ │ result = "正数" │ │
│ │ elif x < 0: │ │
│ │ result = "负数" │ │
│ │ else: │ │
│ │ result = "零" │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
使用列表推导式
重构前：
squares = []
for x in range(10):
squares.append(x ** 2)
重构后：
squares = [x ** 2 for x in range(10)]
使用上下文管理器
重构前：
f = open("file.txt", "r")
content = f.read()
f.close()
重构后：
with open("file.txt", "r") as f:
content = f.read()
7.4 架构重构
从单文件到模块化
> 把 main.py 里的功能拆分成多个模块
Claude Code 会：
- 分析代码功能
- 创建多个模块文件
- 设置正确的导入关系
从面向过程到面向对象
┌─────────────────────────────────────────────────────────────┐
│ │
│ 面向对象重构示例 │
│ │
│ 重构前（面向过程）： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ def create_user(name, age): │ │
│ │ return {"name": name, "age": age} │ │
│ │ │ │
│ │ def get_user_name(user): │ │
│ │ return user["name"] │ │
│ │ │ │
│ │ def set_user_age(user, age): │ │
│ │ user["age"] = age │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 重构后（面向对象）： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ class User: │ │
│ │ def __init__(self, name, age): │ │
│ │ self.name = name │ │
│ │ self.age = age │ │
│ │ │ │
│ │ def get_name(self): │ │
│ │ return self.name │ │
│ │ │ │
│ │ def set_age(self, age): │ │
│ │ self.age = age │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
7.5 重构工作流
┌─────────────────────────────────────────────────────────────┐
│ │
│ 重构工作流 │
│ │
│ ┌─────────────┐ │
│ │ 1. 理解代码 │ ──→ 先读懂现有代码的功能 │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 2. 识别机会 │ ──→ 找出可以改进的地方 │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 3. 制定计划 │ ──→ 确定重构的优先级 │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 4. 逐步重构 │ ──→ 一次只改一小部分 │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 5. 测试验证 │ ──→ 确保功能没有变化 │
│ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
7.6 本章小结
- 重构是改善代码结构而不改变行为
- 基本操作：重命名、提取函数、内联函数
- 架构重构：模块化、面向对象、设计模式
- 重构要逐步进行，每步都要测试验证
第8章：测试编写
8.1 为什么要写测试？
┌─────────────────────────────────────────────────────────────┐
│ │
│ 测试的作用 │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 确保代码按预期工作 ──── 测试通过 = 代码正确 │ │
│ │ │ │
│ │ 防止引入新 bug ──────── 修改代码后跑测试 │ │
│ │ │ │
│ │ 提高代码质量 ────────── 测试是代码的文档 │ │
│ │ │ │
│ │ 方便重构 ───────────── 有测试就不怕改代码 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
8.2 测试类型
┌─────────────────────────────────────────────────────────────┐
│ │
│ 测试类型金字塔 │
│ │
│ /\ │
│ / \ │
│ / E2E \ ← 端到端测试 │
│ /________\ 测试完整用户流程 │
│ / \ │
│ / Integration \ ← 集成测试 │
│ /______________\ 测试多个组件协作 │
│ / \ │
│ / Unit Tests \ ← 单元测试 │
│ /____________________\ 测试单个函数或类 │
│ │
│ 建议：多写单元测试，适当写集成测试，少写端到端测试 │
│ │
└─────────────────────────────────────────────────────────────┘
8.3 生成单元测试
> 为 calculator.py 里的 add 函数写单元测试
Claude Code 会生成：
import pytest
from calculator import add
def test_add_positive_numbers():
assert add(2, 3) == 5
def test_add_negative_numbers():
assert add(-1, -1) == -2
def test_add_zero():
assert add(0, 0) == 0
def test_add_mixed():
assert add(-1, 1) == 0
8.4 测试框架
pytest（Python）
> 用 pytest 写测试
生成的测试：
import pytest
from calculator import divide
def test_divide_normal():
assert divide(10, 2) == 5
def test_divide_by_zero():
with pytest.raises(ValueError):
divide(10, 0)
Jest（JavaScript）
> 用 Jest 写测试
生成的测试：
const { add } = require('./calculator');
test('adds 2 + 3 to equal 5', () => {
expect(add(2, 3)).toBe(5);
});
8.5 测试驱动开发（TDD）
┌─────────────────────────────────────────────────────────────┐
│ │
│ TDD 流程（红-绿-重构） │
│ │
│ ┌─────────────┐ │
│ │ 1. 写测试 │ ──→ 先写会失败的测试（红色） │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 2. 写代码 │ ──→ 写最少的代码让测试通过（绿色） │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 3. 重构 │ ──→ 优化代码，保持测试通过 │
│ └──────┬──────┘ │
│ │ │
│ └──→ 回到步骤 1，重复循环 │
│ │
└─────────────────────────────────────────────────────────────┘
8.6 本章小结
- 测试确保代码按预期工作
- 常见类型：单元测试、集成测试、端到端测试
- 支持 pytest、unittest、Jest 等框架
- TDD：先写测试，再写实现
第9章：Git 操作
9.1 Git 基础
Claude Code 可以帮你完成各种 Git 操作。
┌─────────────────────────────────────────────────────────────┐
│ │
│ Git 基本操作 │
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 查看状态 │ │ 添加文件 │ │ 提交代码 │ │
│ │ │ │ │ │ │ │
│ │ > 查看 git │ │ > 把 main.py │ │ > 提交当前 │ │
│ │ 状态 │ │ 添加到 │ │ 修改 │ │
│ │ │ │ 暂存区 │ │ │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
9.2 分支操作
> 显示所有分支
> 创建一个新分支 feature/login
> 切换到 main 分支
> 把 feature/login 合并到 main
9.3 查看历史
> 显示最近 10 次提交记录
> 显示 main.py 的修改历史
9.4 撤销操作
┌─────────────────────────────────────────────────────────────┐
│ │
│ Git 撤销操作 │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 撤销工作区修改 │ │
│ │ > 撤销 main.py 的修改 │ │
│ │ │ │
│ │ 撤销暂存 │ │
│ │ > 把 main.py 从暂存区移除 │ │
│ │ │ │
│ │ 撤销提交 │ │
│ │ > 撤销最后一次提交，保留修改 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
9.5 远程操作
> 显示远程仓库信息
> 推送 main 分支到远程
> 从远程拉取最新代码
9.6 解决冲突
当合并分支出现冲突时：
> 我合并分支时出现了冲突，请帮我解决
Claude Code 会：
- 找到冲突文件
- 分析冲突内容
- 提出解决方案
- 帮你解决冲突
9.7 Git 工作流
┌─────────────────────────────────────────────────────────────┐
│ │
│ 功能分支工作流 │
│ │
│ main ─────●──────────────●──────────────●────────→ │
│ │ ↑ ↑ │
│ │ │ │ │
│ └──→ feature ──┘ │ │
│ 分支开发 │ │
│ │ │
│ ┌──→ feature ─────────────────┘ │
│ │ 分支开发 │
│ │ │
│ 步骤： │
│ 1. 从 main 创建 feature 分支 │
│ 2. 在 feature 分支开发 │
│ 3. 完成后合并回 main │
│ │
└─────────────────────────────────────────────────────────────┘
9.8 本章小结
- Claude Code 可以执行所有 Git 操作
- 支持分支管理、提交、推送、拉取
- 可以帮助解决合并冲突
- 建议使用规范的提交信息
第三部分：高级配置
第10章：MCP 服务器配置
10.1 什么是 MCP？
MCP（Model Context Protocol）是一个协议，允许 Claude Code 连接到外部工具和服务。
┌─────────────────────────────────────────────────────────────┐
│ │
│ MCP 的作用 │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Claude Code │ │
│ │ │ │ │
│ │ │ MCP 协议 │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ MCP 服务器 │ │ │
│ │ │ │ │ │
│ │ │ • 文件系统 ──── 读写文件 │ │ │
│ │ │ • GitHub ────── 操作仓库 │ │ │
│ │ │ • 数据库 ────── 查询数据 │ │ │
│ │ │ • API ───────── 调用接口 │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 简单来说：MCP 就像给 Claude Code 装插件 │
│ │
└─────────────────────────────────────────────────────────────┘
10.2 配置 MCP 服务器
配置文件位置
┌─────────────────────────────────────────────────────────────┐
│ │
│ MCP 配置文件位置 │
│ │
│ 全局配置：~/.claude/settings.json │
│ 项目配置：.claude/settings.json │
│ │
└─────────────────────────────────────────────────────────────┘
配置格式
{
"mcpServers": {
"server-name": {
"command": "node",
"args": ["path/to/server.js"],
"env": {
"API_KEY": "your-api-key"
}
}
}
}
10.3 常用 MCP 服务器
文件系统服务器
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/directory"]
}
}
}
GitHub 服务器
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "your-token"
}
}
}
}
数据库服务器
{
"mcpServers": {
"postgres": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres"],
"env": {
"DATABASE_URL": "postgresql://user:pass@localhost/db"
}
}
}
}
10.4 本章小结
- MCP 让 Claude Code 连接外部工具和服务
- 配置文件在
~/.claude/settings.json - 可以使用现成的 MCP 服务器
- 也可以创建自定义 MCP 服务器
第11章：钩子系统
11.1 什么是钩子？
钩子（Hooks）是在特定事件发生时自动执行的命令。
┌─────────────────────────────────────────────────────────────┐
│ │
│ 钩子工作原理 │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 事件发生 │ │
│ │ │ │ │
│ │ │ 触发 │ │
│ │ ▼ │ │
│ │ ┌─────────────┐ │ │
│ │ │ 钩子 │ ──→ 自动执行你设定的命令 │ │
│ │ └─────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 例如：每次写入文件后，自动运行格式化工具 │
│ │
└─────────────────────────────────────────────────────────────┘
11.2 钩子类型
┌─────────────────────────────────────────────────────────────┐
│ │
│ 钩子类型 │
│ │
│ ┌──────────────┬─────────────────┬─────────────────────┐ │
│ │ 钩子类型 │ 触发时机 │ 用途 │ │
│ ├──────────────┼─────────────────┼─────────────────────┤ │
│ │ PreToolUse │ 工具执行前 │ 检查、验证 │ │
│ │ PostToolUse │ 工具执行后 │ 清理、通知 │ │
│ │ Notification │ 通知时 │ 自定义通知 │ │
│ │ Stop │ 对话结束时 │ 清理资源 │ │
│ └──────────────┴─────────────────┴─────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
11.3 钩子示例
示例 1：自动格式化代码
在文件写入后自动格式化：
{
"hooks": {
"PostToolUse": [
{
"matcher": "Write",
"command": "prettier --write $CLAUDE_FILE_PATH"
}
]
}
}
示例 2：自动运行测试
在代码修改后自动运行测试：
{
"hooks": {
"PostToolUse": [
{
"matcher": "Write",
"command": "npm test"
}
]
}
}
11.4 本章小结
- 钩子是事件触发的自动命令
- 支持 PreToolUse、PostToolUse 等类型
- 可以用于自动格式化、测试、安全检查等
第12章：自定义技能
12.1 什么是技能？
技能（Skills）是可重用的提示词模板，可以让 Claude Code 执行特定任务。
┌─────────────────────────────────────────────────────────────┐
│ │
│ 技能的作用 │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 你定义技能 ──→ 保存为模板 ──→ 随时调用 │ │
│ │ │ │
│ │ 例如： │ │
│ │ • 代码审查技能 │ │
│ │ • 生成测试技能 │ │
│ │ • 部署应用技能 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 简单来说：技能就像快捷方式 │
│ │
└─────────────────────────────────────────────────────────────┘
12.2 创建技能
技能是 Markdown 文件，包含 frontmatter 和内容：
---
name: code-review
description: 代码审查技能
---
# 代码审查
请按以下步骤审查代码：
1. 检查代码风格
2. 查找潜在 bug
3. 评估性能
4. 提供改进建议
12.3 使用技能
使用斜杠命令调用技能：
> /code-review
或者：
> 使用 code-review 技能审查 main.py
12.4 本章小结
- 技能是可重用的提示词模板
- 存放在
~/.claude/skills/目录 - 使用 Markdown 格式编写
- 可以通过斜杠命令调用
第13章：多模型配置
13.1 为什么使用多模型？
不同模型有不同的特点：
┌─────────────────────────────────────────────────────────────┐
│ │
│ 模型对比 │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Claude Opus ────── 最强大，速度较慢 │ │
│ │ └── 适合：复杂任务、架构设计 │ │
│ │ │ │
│ │ Claude Sonnet ──── 平衡速度和能力 │ │
│ │ └── 适合：日常开发、代码生成 │ │
│ │ │ │
│ │ Claude Haiku ───── 最快，能力稍弱 │ │
│ │ └── 适合：简单任务、快速查询 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
13.2 切换模型
> /model opus
> /model sonnet
> /model haiku
13.3 模型性能对比
┌─────────────────────────────────────────────────────────────┐
│ │
│ 模型性能对比 │
│ │
│ ┌──────────────┬────────┬────────┬────────┐ │
│ │ 任务 │ Opus │ Sonnet │ Haiku │ │
│ ├──────────────┼────────┼────────┼────────┤ │
│ │ 代码生成 │ ★★★★★ │ ★★★★ │ ★★★ │ │
│ │ 代码理解 │ ★★★★★ │ ★★★★ │ ★★★ │ │
│ │ 响应速度 │ ★★ │ ★★★★ │ ★★★★★ │ │
│ │ 复杂推理 │ ★★★★★ │ ★★★★ │ ★★★ │ │
│ │ 价格 │ 高 │ 中 │ 低 │ │
│ └──────────────┴────────┴────────┴────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
13.4 本章小结
- 不同模型有不同特点和适用场景
- Opus 最强大但最慢
- Sonnet 平衡速度和能力
- Haiku 最快但能力稍弱
第四部分：故障排除与优化
第14章：常见问题解决
14.1 安装问题
问题：npm 命令找不到
错误信息：
'npm' is not recognized as an internal or external command
解决方案：
- 确认 Node.js 已安装
- 重启终端
- 检查环境变量 PATH
问题：权限错误
错误信息：
EACCES: permission denied
解决方案（macOS/Linux）：
sudo npm install -g @anthropic-ai/claude-code
解决方案（Windows）：
以管理员身份运行命令提示符。
14.2 登录问题
┌─────────────────────────────────────────────────────────────┐
│ │
│ 登录问题排查 │
│ │
│ 问题：登录失败 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 1. 检查 Anthropic 账号是否正常 │ │
│ │ 2. 清除浏览器缓存 │ │
│ │ 3. 重新启动 Claude Code │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 问题：API 密钥无效 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 1. 检查 API 密钥是否正确 │ │
│ │ 2. 确认密钥没有过期 │ │
│ │ 3. 重新生成密钥 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
14.3 运行时问题
问题：响应很慢
可能原因：
- 网络延迟
- 模型负载高
- 任务太复杂
解决方案：
- 切换到更快的模型（Haiku）
- 简化任务描述
- 检查网络连接
问题：内存不足
错误信息：
JavaScript heap out of memory
解决方案：
export NODE_OPTIONS="--max-old-space-size=4096"
14.4 本章小结
- 常见问题包括安装、登录、运行时、配置问题
- 大多数问题都有明确的解决方案
- 查看错误日志有助于定位问题
第15章：性能优化
15.1 响应速度优化
┌─────────────────────────────────────────────────────────────┐
│ │
│ 性能优化技巧 │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 1. 选择合适的模型 │ │
│ │ └── 简单任务用 Haiku（最快） │ │
│ │ └── 复杂任务用 Opus（最准） │ │
│ │ │ │
│ │ 2. 简化任务描述 │ │
│ │ └── ❌ 帮我写一个非常复杂的系统 │ │
│ │ └── ✅ 创建一个用户注册和登录的 API │ │
│ │ │ │
│ │ 3. 分步骤执行 │ │
│ │ └── 先创建数据库模型 │ │
│ │ └── 然后创建 API 路由 │ │
│ │ └── 最后创建前端页面 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
15.2 Token 使用优化
> /compact # 压缩对话历史
> /cost # 查看当前费用
15.3 本章小结
- 选择合适的模型可以平衡速度和质量
- 简化任务描述可以提高响应速度
- 压缩对话历史可以减少 token 使用
第16章：最佳实践
16.1 与 Claude Code 交流
┌─────────────────────────────────────────────────────────────┐
│ │
│ 交流最佳实践 │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ❌ 模糊的描述： │ │
│ │ > 帮我写代码 │ │
│ │ │ │
│ │ ✅ 清晰的描述： │ │
│ │ > 用 Python 写一个函数，接收用户列表， │ │
│ │ 返回年龄大于 18 的用户 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 技巧： │
│ • 描述要具体 │
│ • 提供上下文 │
│ • 分步骤说明 │
│ │
└─────────────────────────────────────────────────────────────┘
16.2 效率技巧
┌─────────────────────────────────────────────────────────────┐
│ │
│ 快捷键速查 │
│ │
│ ┌──────────────┬─────────────────────────────────────┐ │
│ │ 快捷键 │ 功能 │ │
│ ├──────────────┼─────────────────────────────────────┤ │
│ │ Ctrl+C │ 取消当前操作 │ │
│ │ Ctrl+L │ 清屏 │ │
│ │ Tab │ 自动补全 │ │
│ │ 上下箭头 │ 浏览历史命令 │ │
│ │ Shift+Enter │ 换行（不发送） │ │
│ └──────────────┴─────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
16.3 本章小结
- 清晰描述需求可以提高效率
- 遵循编码规范和最佳实践
- 使用版本控制管理代码
- 理解生成的代码，不要盲目使用
第五部分：实战案例
第17章：完整项目案例
17.1 案例：创建一个待办事项应用
┌─────────────────────────────────────────────────────────────┐
│ │
│ 项目开发流程 │
│ │
│ ┌─────────────┐ │
│ │ 1. 初始化 │ ──→ 创建项目结构 │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 2. 数据模型 │ ──→ 创建数据库表 │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 3. API 路由 │ ──→ 创建接口 │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 4. 前端页面 │ ──→ 创建界面 │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ 5. 测试运行 │ ──→ 验证功能 │
│ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
第一步：项目初始化
> 创建一个 Python Flask 待办事项应用
Claude Code 会创建项目结构：
todo-app/
├── app.py
├── requirements.txt
├── templates/
│ └── index.html
└── static/
└── style.css
第二步：创建数据库模型
> 创建 Todo 模型，包含 id, title, completed 字段
第三步：创建 API 路由
> 创建 CRUD API：获取所有待办、创建待办、更新待办、删除待办
第四步：创建前端页面
> 创建一个简单的 HTML 页面，显示待办列表，可以添加和删除
第五步：运行和测试
> 安装依赖并运行应用
> 测试所有 API 端点
17.2 本章小结
- 通过实际案例学习完整开发流程
- 从项目初始化到部署的全过程
- 每个案例都包含详细步骤
第18章：工作流示例
18.1 日常开发工作流
┌─────────────────────────────────────────────────────────────┐
│ │
│ 日常开发工作流 │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 早晨 │ │
│ │ ├── 查看 git 状态 │ │
│ │ ├── 拉取最新代码 │ │
│ │ └── 查看今天的任务 │ │
│ │ │ │
│ │ 开发 │ │
│ │ ├── 创建功能分支 │ │
│ │ ├── 实现功能 │ │
│ │ ├── 编写测试 │ │
│ │ └── 提交代码 │ │
│ │ │ │
│ │ 下午 │ │
│ │ ├── 代码审查 │ │
│ │ ├── 修复 bug │ │
│ │ └── 推送代码 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
18.2 本章小结
- 工作流是日常开发的标准化流程
- 包括开发、调试、部署等环节
- 使用 Claude Code 可以自动化很多步骤
附录
A. 常用命令速查表
┌─────────────────────────────────────────────────────────────┐
│ │
│ 常用命令速查表 │
│ │
│ ┌──────────────┬─────────────────────────────────────┐ │
│ │ 命令 │ 功能 │ │
│ ├──────────────┼─────────────────────────────────────┤ │
│ │ /help │ 显示帮助 │ │
│ │ /quit │ 退出程序 │ │
│ │ /clear │ 清空对话 │ │
│ │ /model │ 切换模型 │ │
│ │ /cost │ 查看费用 │ │
│ │ /compact │ 压缩历史 │ │
│ │ /config │ 打开配置 │ │
│ │ /memory │ 管理记忆 │ │
│ └──────────────┴─────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
B. 常见问题快速解决
┌─────────────────────────────────────────────────────────────┐
│ │
│ 常见问题快速解决 │
│ │
│ ┌──────────────────┬─────────────────────────────────┐ │
│ │ 问题 │ 解决方案 │ │
│ ├──────────────────┼─────────────────────────────────┤ │
│ │ 安装失败 │ 检查 Node.js 版本 │ │
│ │ 登录失败 │ 清除浏览器缓存 │ │
│ │ 响应慢 │ 切换到 Haiku 模型 │ │
│ │ 内存不足 │ 增加 Node.js 内存限制 │ │
│ └──────────────────┴─────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
C. 学习资源
- Anthropic 官方文档
- Claude Code GitHub 仓库
- 社区论坛
- 在线教程
总结
┌─────────────────────────────────────────────────────────────┐
│ │
│ 恭喜你完成了 Claude Code 从入门到精通的学习！ │
│ │
│ 你学到了： │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 1. 基础入门 ──── 安装、配置、基本操作 │ │
│ │ │ │
│ │ 2. 编程实战 ──── 代码生成、调试、重构、测试 │ │
│ │ │ │
│ │ 3. 高级配置 ──── MCP、钩子、技能、多模型 │ │
│ │ │ │
│ │ 4. 故障排除 ──── 常见问题、性能优化 │ │
│ │ │ │
│ │ 5. 实战案例 ──── 完整项目、工作流 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 下一步： │
│ │
│ • 多练习，熟悉各种命令 │
│ • 尝试用 Claude Code 完成实际项目 │
│ • 探索更多高级功能 │
│ • 与团队分享你的经验 │
│ │
│ 记住：Claude Code 是你的编程助手， │
│ 用自然语言告诉它你想做什么，它会帮你完成。 │
│ │
│ 祝你编程愉快！ │
│ │
└─────────────────────────────────────────────────────────────┘
中国智能体开发者社区，聚焦智能体与大模型开发，提供前沿资讯、实用工具链、开源项目及行业案例。通过技术沙龙、开发者大赛等活动，促进经验交流与协作，助力开发者快速构建创新智能应用。
更多推荐
8
0- 0
已为社区贡献3条内容
所有评论(0)