第79讲：输出净化——剔除AI废话，只保留纯净C代码
专栏地址：
前言：为什么需要净化AI输出？
为什么重要？
AI输出通常包含大量非代码内容：
- 解释说明：AI喜欢解释代码功能、原理、用法
- 示例代码：AI可能提供多个示例，只需要其中一个
- 注意事项：AI会列出使用注意事项、限制条件
- 对话填充：AI会说"好的"、"这是代码"等填充语
这些内容对理解有帮助，但对代码集成是干扰：
- 复制困难：需要手动从大量文本中提取代码
- 格式混乱：代码块、解释文本混在一起
- 容易遗漏：可能遗漏部分代码或包含多余内容
- 自动化困难：难以用脚本自动提取代码
输出净化的作用：从AI输出中自动提取纯净的C代码，剔除所有非代码内容，方便集成到工程。
新手常见困惑
困惑1：“AI输出这么多内容，如何快速提取代码？”
困惑2：“如何判断哪些是代码、哪些是解释？”
困惑3：“提取的代码格式不对怎么办？”
困惑4：“有没有自动化工具帮助净化输出？”
本文结构
第一部分：入门阶段——建立整体认知
1.1 AI输出的结构
典型AI输出结构
【典型AI输出结构】
一、开场白
"好的，我来帮你生成USART驱动代码。"
二、代码块
```c
/**
* @file usart_driver.c
* @brief USART驱动实现
*/
#include "usart_driver.h"
void usart_init(void)
{
// 初始化代码
}
三、解释说明
"这段代码实现了USART初始化功能，包括：
- 配置GPIO引脚
- 配置USART参数
- 使能USART
…"
四、使用示例
"使用示例：
usart_init();
usart_send("Hello", 5);
"
五、注意事项
"注意事项：
- 调用前需确保系统时钟已配置
- 波特率需根据实际需求修改
…"
六、结束语
“希望这段代码对你有帮助！”
#### 需要提取的内容
| 内容类型 | 是否需要 | 提取方法 |
|----------|----------|----------|
| 代码块（```c ... ```） | 是 | 提取代码块内容 |
| 代码中的注释 | 是 | 保留注释 |
| 解释说明文本 | 否 | 剔除 |
| 使用示例 | 视情况 | 可能需要 |
| 注意事项 | 否 | 剔除（或单独保存） |
| 开场白/结束语 | 否 | 剔除 |
### 1.2 代码识别方法
#### 方法一：代码块标记识别
AI通常使用Markdown代码块标记代码：
【代码块标记识别】
Markdown代码块格式：
[代码内容]
识别方法：
- 查找
c 或C 标记 - 提取标记后的内容
- 查找 ```结束标记
- 提取标记之间的内容
示例：
输入：
"这是USART驱动代码：
void usart_init(void)
{
// 初始化
}
希望对你有帮助。"
输出：
void usart_init(void)
{
// 初始化
}
#### 方法二：语法特征识别
通过C语言语法特征识别代码：
【语法特征识别】
C语言特征：
- 包含#include指令
- 包含函数定义（返回类型 函数名(参数)）
- 包含变量定义（类型 变量名;）
- 包含结构体定义（typedef struct）
- 包含宏定义（#define）
识别方法：
- 按行分析文本
- 检测C语言特征
- 标记代码行
- 提取连续代码行
示例：
输入：
“初始化函数如下：
void usart_init(void)
{
// 初始化
}
这个函数会初始化USART。”
输出：
void usart_init(void)
{
// 初始化
}
### 1.3 基础净化模板
#### 模板一：请求纯净输出Prompt
【请求纯净输出】
请在生成代码时遵循以下格式：
一、代码输出格式
只输出代码，不要包含解释、示例、注意事项。
二、代码块标记
使用Markdown代码块标记：
[完整代码]
三、禁止内容
- 禁止输出开场白、结束语
- 禁止输出代码解释
- 禁止输出使用示例（除非明确要求）
- 禁止输出注意事项（除非明确要求）
四、输出示例
正确：
void usart_init(void)
{
// 初始化代码
}
错误：
"好的，这是USART初始化代码：
void usart_init(void)
{
// 初始化代码
}
这个函数会初始化USART…"
#### 模板二：分文件输出Prompt
【分文件输出】
请按以下格式输出多个文件：
一、头文件
[头文件完整内容]
二、源文件
[源文件完整内容]
三、输出要求
- 每个文件单独一个代码块
- 代码块标记明确文件类型（
h或c） - 不包含任何解释文本
---
## 第二部分：进阶阶段——深入理解原理
### 2.1 手动净化技巧
#### 技巧一：快速定位代码块
【快速定位代码块】
步骤：
- 搜索
c 或C 标记 - 定位代码块起始位置
- 搜索 ```结束标记
- 定位代码块结束位置
- 复制中间内容
快捷键（大多数编辑器）：
- Ctrl+F：搜索 ```c
- Ctrl+C：复制选中内容
- Ctrl+V：粘贴到目标文件
注意：
- 可能有多个代码块，选择需要的
- 检查代码块是否完整（有开始和结束标记）
- 检查代码块类型（
c、h、```markdown等）
#### 技巧二：剔除行内解释
【剔除行内解释】
AI有时会在代码中插入解释：
示例：
void usart_init(void)
{
// 这里配置GPIO引脚
GPIO_InitTypeDef GPIO_InitStructure; // 定义GPIO配置结构体
// 这里配置USART参数
USART_InitTypeDef USART_InitStructure; // 定义USART配置结构体
}
净化方法：
- 保留功能性注释（说明代码作用）
- 剔除废话注释（如"这里配置…"）
- 剔除行尾注释（如果只是解释）
净化后：
void usart_init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
}
### 2.2 脚本净化工具
#### Python净化脚本
```python
# output_cleaner.py - AI输出净化脚本
import re
import sys
class OutputCleaner:
def __init__(self):
self.code_blocks = []
def extract_code_blocks(self, text):
"""提取Markdown代码块"""
# 匹配 ```c 或 ```h 或 ```C 或 ```H
pattern = r'```([chCH])\n(.*?)\n```'
matches = re.findall(pattern, text, re.DOTALL)
for lang, code in matches:
self.code_blocks.append({
'language': lang.lower(),
'code': code
})
return self.code_blocks
def remove_inline_comments(self, code):
"""剔除行内废话注释"""
lines = code.split('\n')
cleaned_lines = []
for line in lines:
# 保留功能性注释，剔除废话注释
# 简单规则：如果注释只是解释，剔除
if '//' in line:
code_part, comment_part = line.split('//', 1)
# 如果代码部分不为空，保留
if code_part.strip():
cleaned_lines.append(code_part.rstrip())
# 如果注释是功能性注释，保留
elif any(keyword in comment_part for keyword in ['TODO', 'FIXME', 'NOTE', '参数', '返回']):
cleaned_lines.append(line)
else:
cleaned_lines.append(line)
return '\n'.join(cleaned_lines)
def format_code(self, code):
"""格式化代码"""
# 简单格式化：统一缩进为4空格
lines = code.split('\n')
formatted_lines = []
for line in lines:
# 替换Tab为4空格
line = line.replace('\t', ' ')
formatted_lines.append(line)
return '\n'.join(formatted_lines)
def clean(self, text):
"""完整净化流程"""
# 提取代码块
code_blocks = self.extract_code_blocks(text)
# 净化每个代码块
cleaned_blocks = []
for block in code_blocks:
code = block['code']
# code = self.remove_inline_comments(code)
code = self.format_code(code)
cleaned_blocks.append({
'language': block['language'],
'code': code
})
return cleaned_blocks
def save_to_files(self, cleaned_blocks, output_dir):
"""保存到文件"""
import os
os.makedirs(output_dir, exist_ok=True)
for i, block in enumerate(cleaned_blocks):
if block['language'] == 'h':
filename = f"output_{i}.h"
else:
filename = f"output_{i}.c"
filepath = os.path.join(output_dir, filename)
with open(filepath, 'w') as f:
f.write(block['code'])
print(f"保存：{filepath}")
def main():
if len(sys.argv) < 2:
print("用法：python output_cleaner.py <输入文件> [输出目录]")
sys.exit(1)
input_file = sys.argv[1]
output_dir = sys.argv[2] if len(sys.argv) > 2 else "./output"
with open(input_file, 'r', encoding='utf-8') as f:
text = f.read()
cleaner = OutputCleaner()
cleaned_blocks = cleaner.clean(text)
print(f"提取到{len(cleaned_blocks)}个代码块")
cleaner.save_to_files(cleaned_blocks, output_dir)
if __name__ == "__main__":
main()
2.3 格式修正方法
常见格式问题
【常见格式问题】
问题一：缩进不一致
示例：
```c
void function(void)
{
if (condition)
{
// 缩进混乱
}
}
修正：统一缩进为4空格
问题二：大括号风格不一致
示例：
void function(void) {
if (condition) {
// K&R风格
}
}
修正：统一为Allman风格（大括号独占一行）
问题三：行宽超限
示例：
void function_with_very_long_name(int parameter1, int parameter2, int parameter3, int parameter4)
修正：换行，保持行宽在80字符以内
问题四：空行过多或过少
示例：
void function_a(void)
{
// 函数a
}
void function_b(void)
{
// 函数b
}
修正：函数间空一行，逻辑块间空一行
#### 格式修正脚本
```python
# format_fixer.py - 格式修正脚本
import re
def fix_indentation(code):
"""修正缩进"""
lines = code.split('\n')
fixed_lines = []
for line in lines:
# 替换Tab为4空格
line = line.replace('\t', ' ')
# 统一缩进为4空格的倍数
stripped = line.lstrip()
if stripped:
indent_level = (len(line) - len(stripped)) // 4
fixed_lines.append(' ' * indent_level + stripped)
else:
fixed_lines.append('')
return '\n'.join(fixed_lines)
def fix_brace_style(code):
"""修正大括号风格"""
# 将K&R风格转换为Allman风格
# 简单实现：在{前换行
code = re.sub(r'([^\n])\s*\{', r'\1\n{', code)
return code
def fix_line_width(code, max_width=80):
"""修正行宽"""
lines = code.split('\n')
fixed_lines = []
for line in lines:
if len(line) > max_width:
# 简单换行：在逗号后换行
parts = []
current = ""
for part in line.split(','):
if len(current + part) > max_width:
parts.append(current.rstrip())
current = ' ' + part + ','
else:
current += part + ','
parts.append(current.rstrip(','))
fixed_lines.extend(parts)
else:
fixed_lines.append(line)
return '\n'.join(fixed_lines)
def fix_blank_lines(code):
"""修正空行"""
# 删除多余空行
code = re.sub(r'\n{3,}', '\n\n', code)
# 确保函数间有空行
code = re.sub(r'\}\n([^\n])', r'}\n\n\1', code)
return code
def fix_all(code):
"""修正所有格式问题"""
code = fix_indentation(code)
code = fix_brace_style(code)
code = fix_line_width(code)
code = fix_blank_lines(code)
return code
第三部分：高级阶段——掌握复杂应用
3.1 批量净化工作流
工作流程
批量净化脚本
# batch_cleaner.py - 批量净化脚本
import os
import glob
from output_cleaner import OutputCleaner
from format_fixer import fix_all
class BatchCleaner:
def __init__(self, input_dir, output_dir):
self.input_dir = input_dir
self.output_dir = output_dir
self.cleaner = OutputCleaner()
def process_file(self, input_file):
"""处理单个文件"""
with open(input_file, 'r', encoding='utf-8') as f:
text = f.read()
# 净化
cleaned_blocks = self.cleaner.clean(text)
# 格式修正
for block in cleaned_blocks:
block['code'] = fix_all(block['code'])
return cleaned_blocks
def process_all(self):
"""批量处理所有文件"""
os.makedirs(self.output_dir, exist_ok=True)
# 查找所有输入文件
input_files = glob.glob(os.path.join(self.input_dir, "*.txt"))
for input_file in input_files:
print(f"处理：{input_file}")
# 净化
cleaned_blocks = self.process_file(input_file)
# 保存
base_name = os.path.splitext(os.path.basename(input_file))[0]
for i, block in enumerate(cleaned_blocks):
ext = '.h' if block['language'] == 'h' else '.c'
output_file = os.path.join(self.output_dir, f"{base_name}_{i}{ext}")
with open(output_file, 'w', encoding='utf-8') as f:
f.write(block['code'])
print(f" 保存：{output_file}")
print("批量净化完成")
def main():
input_dir = "./ai_output"
output_dir = "./cleaned_code"
cleaner = BatchCleaner(input_dir, output_dir)
cleaner.process_all()
if __name__ == "__main__":
main()
3.2 净化质量验证
验证清单
【净化质量验证清单】
一、完整性验证
- [ ] 所有代码块是否都提取
- [ ] 代码是否完整（没有截断）
- [ ] 注释是否保留
二、格式验证
- [ ] 缩进是否统一
- [ ] 大括号风格是否统一
- [ ] 行宽是否超限
- [ ] 空行是否合理
三、语法验证
- [ ] 是否能编译通过
- [ ] 是否有语法错误
- [ ] 是否有未闭合的大括号
四、内容验证
- [ ] 是否包含非代码内容
- [ ] 是否包含废话注释
- [ ] 是否包含解释文本
3.3 净化工具集成
集成到开发流程
【净化工具集成】
一、集成到AI调用流程
1. 调用AI生成代码
2. 自动净化输出
3. 保存净化后的代码
4. 编译验证
二、集成到CI/CD流程
1. 代码提交时自动净化
2. 净化后代码格式检查
3. 净化后代码编译检查
4. 净化报告生成
三、集成到编辑器
1. 粘贴AI输出时自动净化
2. 快捷键触发净化
3. 净化预览
4. 净化后自动格式化
总结
入门要点
- AI输出结构：开场白、代码块、解释、示例、注意事项、结束语
- 代码识别方法：代码块标记识别、语法特征识别
- 基础模板：请求纯净输出Prompt、分文件输出Prompt
进阶要点
- 手动净化：快速定位代码块、剔除行内解释
- 脚本净化：Python净化脚本、自动提取代码块
- 格式修正：缩进修正、大括号风格修正、行宽修正、空行修正
高级要点
- 批量净化：批量净化工作流、批量净化脚本
- 质量验证：完整性验证、格式验证、语法验证、内容验证
- 工具集成：集成到AI调用流程、CI/CD流程、编辑器
记住这些原则
- 净化即提纯：从AI输出中提取纯净代码，剔除干扰内容
- 自动化优先：使用脚本自动净化，提高效率
- 验证必须：净化后必须验证，确保代码正确
- 集成工作流：将净化工具集成到开发流程，无缝衔接
下一讲预告：第80讲将深入讲解"附赠：嵌入式双范式全套可复制Prompt库"，提供完整的Prompt模板库，方便直接使用。
扫一扫
1061
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
