¥
立即购买

多维代码审查

480 浏览
46 试用
13 购买
Nov 24, 2025更新

对指定编程语言代码进行多维度审查,包括安全性、性能、错误处理和风格一致性,并提供具体改进建议,帮助开发者提升代码质量、可维护性和运行效率,适用于代码审核和优化场景。

以下从安全性、性能、错误处理、风格一致性与可维护性五个维度给出审查意见与可落地的改进建议。优先级标注为[高]、[中]、[低]。

安全性

  • [高] 彻底移除对用户输入的 eval。当前对 fields 的 eval 允许任意代码执行。改为仅支持受限字段白名单的解析(JSON 数组或逗号分隔),对每个字段做 allowlist 校验。
  • [高] 消除 SQL 注入风险。绝不要用 f-string 拼接 WHERE 条件;改用参数化查询。注意:列名不能参数化,必须先通过白名单校验再拼接。
  • [高] 不要用 GET 传递凭据。将登录改为 POST 且使用 JSON 请求体;禁止在日志、URL、响应中记录/回显密码。
  • [高] 密码存储与校验。数据库不应存明文 pwd,应存哈希(bcrypt/argon2),登录时对用户输入做同算法校验。
  • [高] token 生成。不要用 random.random()(非加密安全)。改用 secrets.token_urlsafe() 或 JWT(并妥善保存秘钥)。
  • [高] 不要把 config.json 内容返回给客户端,避免泄漏配置/密钥。仅在服务端加载配置并按需使用。
  • [高] 生产环境关闭 debug=True,并使用 gunicorn/uwsgi 等 WSGI 服务器;开启 HTTPS;设置常见安全头(可用 Flask-Talisman)。
  • [中] 敏感信息审计。日志中避免输出用户名、IP、鉴权失败具体原因等敏感字段,或进行脱敏/哈希化。
  • [中] 限流与爆破防护。对登录接口添加速率限制(Flask-Limiter),并考虑失败次数锁定策略。
  • [中] 结果字段最小化。即使通过 fields 请求,也应对敏感字段(pwd/pwd_hash、tokens 等)强制过滤;默认不要使用 *。
  • [中] 返回行数与查询限制。为查询添加 LIMIT(例如 1),避免不必要的数据泄露与 DoS 面。

性能

  • [高] 避免每次请求重复读文件。config.json 在启动时加载到 app.config 或使用带 TTL/mtime 检测的缓存;需要动态热加载再做专门实现。
  • [中] 数据库连接管理。为每个请求在 Flask g 上缓存一个 sqlite3 连接,并在 teardown 时关闭;或迁移至 SQLAlchemy 与连接池(更推荐换用生产级数据库)。
  • [中] 日志写入。不要手动每次 open('access.log') 写文件,使用 logging 模块和 RotatingFileHandler/WatchedFileHandler 或输出到 stdout 交给进程管理器/容器收集。
  • [中] 移除未用的全局 cache 或替换为有 TTL 与线程安全的缓存(cachetools.TTLCache 或 Flask-Caching);明确缓存策略与失效。
  • [低] 只获取必要字段与行,避免 SELECT *;加索引(name 唯一索引)提升查询效率。

错误处理

  • [高] 删除裸 except 和静默失败。统一用 logging.exception 记录异常并返回规范化错误响应;不要在异常情况下仍返回 ok=True。
  • [高] 输入校验失败返回 400,数据库错误返回 500。通过 Flask 的 abort 或自定义错误处理器 @app.errorhandler 统一返回 JSON 错误格式。
  • [中] 对 fields 的格式做严格校验(必须是 JSON 数组或逗号分隔的字符串,且均在白名单内),否则返回 400。
  • [中] 对 name/pwd 长度、字符集、空值做校验;限制请求体大小(MAX_CONTENT_LENGTH)。

风格一致性

  • [中] 遵循 PEP 8:独立分组 imports,常量大写,函数/变量命名一致;移除未使用导入(os、time 可能无需显式使用)。
  • [中] 使用 context manager 与 Flask g:数据库连接、文件读取、光标均用 with;减少手动 try/finally。
  • [中] 使用 jsonify 返回 JSON,设置 Content-Type;返回结构统一(含 code、message、data)。
  • [低] 统一日志入口(logging.getLogger),统一格式(JSON 日志更利于采集与检索)。

可维护性

  • [中] 分层与抽象。将数据访问封装到 dao/repository,业务逻辑与 HTTP 层分离;将配置加载、日志配置独立成模块。
  • [中] 常量与配置集中管理(app.config 或环境变量);字段白名单、表名等集中定义。
  • [中] 添加类型注解与文档字符串,配合 mypy/ruff/flake8/black/pre-commit 保持质量。
  • [中] 引入迁移与模式管理(即使是 SQLite,也建议使用 Alembic 管理结构演进)。
  • [低] 增加单元测试/集成测试,覆盖输入校验、错误路径与安全边界。

关键改动示例(节选,展示做法)

  • 安全字段解析与参数化查询

    • 定义白名单:
      • ALLOWED_FIELDS = {'id','name','email','created_at'}
    • 解析:
      • raw_fields = request.args.get('fields', None)
      • if not raw_fields: cols = ['id','name'] # 默认字段
      • elif raw_fields == '*': cols = ['id','name'] # 禁用真正的 *
      • else:
        • try:
          • candidates = json.loads(raw_fields) if raw_fields.strip().startswith('[') else [s.strip() for s in raw_fields.split(',')]
          • except: abort(400, 'invalid fields')
        • cols = [c for c in candidates if c in ALLOWED_FIELDS]
        • if not cols: abort(400, 'no valid fields')
      • fields_sql = ', '.join(cols)
    • 参数化查询(注意列名已白名单过滤,条件使用参数):
      • sql = f"SELECT {fields_sql} FROM users WHERE name = ? LIMIT 1"
      • cur.execute(sql, (name,))
  • 使用 POST + JSON、密码哈希、加密安全 token

    • data = request.get_json(force=True, silent=False)
    • name = data.get('name'); pwd = data.get('pwd')
    • if not name or not pwd: abort(400, 'missing credentials')
    • 从库取出 pwd_hash 与 salt,使用 bcrypt.checkpw 比对
    • token = secrets.token_urlsafe(32)
  • 数据库连接与清理(Flask 推荐模式)

    • from flask import g
    • def get_db():
      • if 'db' not in g:
        • g.db = sqlite3.connect(DB, detect_types=sqlite3.PARSE_DECLTYPES)
        • g.db.row_factory = sqlite3.Row
      • return g.db
    • @app.teardown_appcontext
      • def close_db(exc):
        • db = g.pop('db', None)
        • if db is not None: db.close()
  • 统一响应与日志

    • 使用 jsonify({'ok': True, 'data': rows}),错误场景返回 jsonify({'ok': False, 'code': 'VALIDATION_ERROR', 'message': '...'}), 400
    • logging.basicConfig(...); logger = logging.getLogger(name)
    • logger.info('login_attempt', extra={'user': hash_or_redact(name), 'success': True})

其他注意点

  • SQLite 并发写入能力有限,生产建议迁移到 PostgreSQL/MySQL,并配合 SQLAlchemy + 连接池。
  • 如果必须保留访问日志,交由 logging 框架处理,避免自行写文件(并发安全、轮转、权限更可靠)。
  • 配置文件路径应使用绝对路径或基于实例路径,避免因工作目录变化导致读取失败;敏感配置放环境变量或密钥管理系统。
  • 为接口增加统一速率限制、中间件级别的异常捕获与标准化返回。

以上调整能在不大幅改动业务逻辑的情况下显著提升安全性、稳健性与可维护性。建议先落地高优先级项(移除 eval、参数化查询、POST+JSON、密码哈希、关闭 debug、配置不回传、加密安全 token、统一错误码与日志),再逐步推进结构化与工程化优化。

以下为按维度划分的审查与改进建议,并附一段更安全/可维护的示例重构代码(选取关键点演示)。

一、安全性

  • 身份认证与加密
    • 不要使用 MD5 存储/计算密码。改用 bcrypt 或 argon2(推荐 argon2id)。密码校验用安全的哈希验证,不在日志中打印明文或哈希。
    • token 不要用 Math.random。改用 crypto.randomBytes 生成随机令牌或使用 JWT(签名密钥从环境变量读取)。
  • SQL 安全
    • 严禁字符串拼接构造 SQL。使用参数化查询/预编译(如 node-postgres、mysql2 或使用 ORM)。
  • 命令执行
    • 禁止 exec 拼接用户输入(命令注入)。若只想做目录列举,直接使用 fs.readdir;确实要调用外部命令时使用 execFile,并对参数做白名单/路径校验。
  • SSRF 与外部请求
    • 对 /fetch 的 url 做严格校验:限定协议为 http/https;使用域名白名单或仅允许访问特定上游;解析后阻断内网/环回/链路本地地址;限制重定向次数;设置请求超时与最大响应体大小。
  • 输入验证与最小化暴露
    • 使用校验库(Joi/Zod/express-validator)验证 body/query/path 的类型、长度、格式。
    • 不在日志中输出敏感字段或内部配置。如需日志,做字段脱敏。
  • HTTP 层安全
    • 使用 helmet 设置安全头,禁用 x-powered-by。
    • 配置严格的 CORS(若无需跨域则关闭),生产环境启用 HTTPS。
    • 对登录接口加限流/验证码/延迟响应,防止暴力破解与枚举。
  • 配置与密钥管理
    • 配置文件与密钥通过环境变量或密钥管理服务注入;不在请求期间重复读取配置文件,也不回显任何内部配置细节。

二、性能

  • I/O 与资源
    • 取消每次请求的 fs.readFileSync;应用启动时加载配置并缓存;需要热更新用 watch 或定时刷新。
    • 为 axios 配置合理 timeout、maxContentLength、maxBodyLength;设置 keep-alive 的 httpAgent/httpsAgent 以减少连接开销。
  • 负载与内存
    • 限制请求体大小(express.json({ limit: '32kb' }))。
    • 对 /fetch 的外部响应进行大小限制,必要时采用流式转发而非一次性载入内存。
  • 日志与调试
    • 减少每次请求的 console.log;使用高性能日志库(如 pino),异步写日志,避免阻塞事件循环。

三、错误处理

  • 路由内加 try/catch 或使用 async 包装器,统一的错误处理中间件返回结构化错误(包含 code、message),避免未捕获异常导致进程崩溃。
  • 对外部请求/文件系统操作的失败进行分类返回(如 4xx 参数错误、5xx 上游失败),并设置兜底错误处理。
  • 为 axios 设置取消/超时;在客户端断开时中止下游请求(可使用 AbortController)。

四、风格一致性

  • 使用 ESLint + Prettier 统一代码风格(分号、引号、缩进、严格等号、命名规范)。
  • 统一响应结构与状态码(如 { ok: false, error: '...' })。
  • 避免魔法数字,定义常量,如超时时间、速率限制、大小上限。
  • 统一异步风格(全部使用 async/await),避免回调与 promise 混用。

五、可维护性

  • 分层与模块化:将路由、控制器、服务、配置、日志分别拆分文件;把外部请求封装为服务模块。
  • 配置集中管理:用 dotenv + envalid/zod 校验环境变量;在 app 启动时载入一次。
  • 类型与文档:考虑迁移 TypeScript 或在 JS 中使用 JSDoc 注解;维护 OpenAPI/Swagger 文档与单元测试。
  • 安全与依赖:定期 npm audit;锁版本;在 CI 中加入 ESLint、测试与安全扫描。

示例重构(节选,展示关键修复思路) 说明:演示安全校验、参数化、防注入、取消 exec、SSRF 防护、超时与限流等。依赖:helmet、express-rate-limit、bcrypt、axios、zod。

const express = require('express'); const helmet = require('helmet'); const rateLimit = require('express-rate-limit'); const bcrypt = require('bcrypt'); const crypto = require('crypto'); const axios = require('axios'); const http = require('http'); const https = require('https'); const path = require('path'); const fs = require('fs/promises'); const { z } = require('zod'); const { URL } = require('url');

const app = express(); app.disable('x-powered-by'); app.use(helmet()); app.use(express.json({ limit: '32kb' })); app.use(rateLimit({ windowMs: 15 * 60 * 1000, max: 100 }));

// 配置加载一次 const config = { allowedFetchHosts: ['example.com'], baseDir: path.resolve('/var/app/data') };

// 统一错误处理中间件 function errorHandler(err, req, res, next) { console.error(err); const status = err.statusCode || 500; res.status(status).json({ ok: false, error: err.publicMessage || 'internal_error' }); } function badRequest(msg) { const e = new Error(msg); e.statusCode = 400; e.publicMessage = msg; return e; }

// 登录:示例(伪数据库) const loginSchema = z.object({ user: z.string().min(1).max(64), pwd: z.string().min(8).max(256) }); app.post('/login', async (req, res, next) => { try { const { user, pwd } = loginSchema.parse(req.body || {}); // TODO: 从数据库按用户名查询(使用参数化查询) const dbUser = await fakeGetUser(user); // 返回 { passwordHash: '...' } if (!dbUser) throw badRequest('invalid_credentials'); const ok = await bcrypt.compare(pwd, dbUser.passwordHash); if (!ok) throw badRequest('invalid_credentials'); const token = crypto.randomBytes(32).toString('hex'); // 或签发 JWT res.json({ ok: true, token }); } catch (e) { next(e); } });

// fetch:SSRF 防护、超时、大小限制;目录列举使用 fs.readdir 替代 exec const fetchSchema = z.object({ url: z.string().url(), path: z.string().optional().default('') }); const axiosClient = axios.create({ timeout: 8000, maxRedirects: 3, maxContentLength: 1024 * 1024, httpAgent: new http.Agent({ keepAlive: true }), httpsAgent: new https.Agent({ keepAlive: true }) }); app.get('/fetch', async (req, res, next) => { try { const { url, path: reqPath } = fetchSchema.parse(req.query); const u = new URL(url); if (!['http:', 'https:'].includes(u.protocol)) throw badRequest('unsupported_protocol'); if (!config.allowedFetchHosts.includes(u.hostname)) throw badRequest('host_not_allowed'); // 可选:解析 IP 并阻止内网/环回地址 const resp = await axiosClient.get(u.toString(), { responseType: 'text', validateStatus: s => s >= 200 && s < 400 });

const base = config.baseDir;
const resolved = path.resolve(base, '.' + path.sep + reqPath);
if (resolved !== base && !resolved.startsWith(base + path.sep)) throw badRequest('invalid_path');
const list = await fs.readdir(resolved);

res.json({ ok: true, data: resp.data, list });

} catch (e) { next(e); } });

app.use(errorHandler); app.listen(process.env.PORT || 3000, () => console.log('server on', process.env.PORT || 3000));

// 伪函数:演示 async function fakeGetUser(user) { // 实际应使用参数化查询从数据库读取 const passwordHash = await bcrypt.hash('P@ssw0rd!', 12); return { passwordHash }; }

若不便引入过多依赖,可先落地的最小改动

  • 用 bcrypt 替换 MD5,并用 crypto.randomBytes 生成 token。
  • 去除 exec;用 fs.readdir 严格路径校验。
  • 为 axios 设置 timeout、maxContentLength、maxRedirects,并做 URL 白名单校验。
  • 用 express.json({ limit }) 限制请求体,增加 helmet 与 express-rate-limit。
  • 使用 try/catch 与统一错误处理,规范状态码与响应结构。
  • 配置文件在启动时读一次,不在日志中打印内部信息。

下面按维度给出问题点与改进建议,并附可参考的代码片段,优先解决数据竞争、SSRF、超时与资源泄漏等高危问题。

一、安全性

  • SSRF 风险:直接对用户提供的 url 执行 cl.Get。应解析并校验 scheme(仅 http/https)、域名/网段(白名单或阻止内网/元数据地址等),限制重定向与请求超时。
  • 资源泄漏:fire-and-forget 的 cl.Get 未关闭 resp.Body,可能耗尽连接与文件描述符。
  • DoS 风险:
    • 未设任何 server/client 超时,容易被慢速连接耗尽资源。
    • 每请求创建新 http.Client,且无限制地启动 goroutine,可能触发 goroutine 风暴。
    • key 未校验长度与字符集,攻击者可创建海量 key 占满内存。
  • 类型与并发安全:
    • hits 写使用 atomic.AddInt64,但读未使用原子读;在 32 位平台可能存在数据竞争。
  • 输出信息泄露:返回 data.txt 长度可能暴露内部信息,考虑去敏或不返回具体大小。
  • 响应头缺失:未设置 Content-Type 为 application/json。

二、性能

  • map 并发读写:background 和 handler 并发操作全局 map,存在严重竞争和崩溃风险(concurrent map iteration and map write)。需加锁、使用 sync.Map 或专用 goroutine+channel。
  • 重复 IO:每个请求都 ioutil.ReadFile("data.txt")(且仅用长度),应在启动时缓存长度,或用 os.Stat 一次,必要时设轻量缓存刷新。
  • 字符串构建低效:用 s = s + ... O(n^2)。使用 strings.Builder 并预分配容量。
  • http.Client 重建:每请求创建新 client 且默认 Transport,无法复用连接,性能差。应复用全局 client,并设置 Transport 连接池参数。
  • 随机数:若仅演示无妨;如要高性能且可并发,建议为每个 handler 使用 rand.Rand(rand.New)避免全局锁,或使用 strings.Builder+byte。

三、错误处理

  • 大量忽略错误:ioutil.ReadFile/json.Marshal/w.Write/cl.Get 全部忽略。应检查并返回合适的 HTTP 状态码,日志记录上下文信息。
  • 外部请求:需要上下文超时、error 处理、关闭 body,考虑失败重试或直接取消异步调用。
  • 使用 http.Error 输出错误,并提前 return,避免继续写响应。

四、风格一致性

  • 避免使用已废弃的 ioutil 包(用 os.ReadFile 或 os.Stat,io、os)。
  • 使用 json.NewEncoder 直接写入响应;统一设置 Content-Type。
  • 使用常量替代魔数(payload 长度、tick 周期、超时值)。
  • 命名与作用域:避免全局可变状态,封装为结构体字段。

五、可维护性

  • 封装状态:定义 Server 结构体封装 hits、store、client 等,提供方法操作,减少全局变量。
  • 优雅关闭:background 循环应支持 context 取消;main 使用 http.Server 并设置 ReadTimeout/WriteTimeout/IdleTimeout/ReadHeaderTimeout,支持 Shutdown。
  • 并发模型:为 store 明确一种并发策略(锁/通道/sync.Map),集中管理。
  • 质量保障:本地启用竞态检测 go run/test -race,静态分析 go vet、staticcheck;添加单元测试与基准测试。

六、其他

  • 观察性:为关键路径加结构化日志;必要时添加基本指标(请求计数、外呼成功率、处理耗时)。
  • 限流/并发控制:对外部请求使用信号量或 worker pool 控制并发。

参考实现片段(展示关键修复思路,非完整程序):

  • 并发安全的 store 与后台任务 type Server struct { hits atomic.Int64 mu sync.RWMutex store map[string]int client *http.Client fileLen atomic.Int64 }

    func NewServer() *Server { s := &Server{ store: make(map[string]int), client: &http.Client{ Timeout: 5 * time.Second, Transport: &http.Transport{ MaxIdleConns: 100, MaxIdleConnsPerHost: 10, IdleConnTimeout: 90 * time.Second, }, }, } if fi, err := os.Stat("data.txt"); err == nil { s.fileLen.Store(fi.Size()) } return s; }

    func (s *Server) background(ctx context.Context, tick time.Duration) { t := time.NewTicker(tick) defer t.Stop() for { select { case <-ctx.Done(): return case <-t.C: s.mu.Lock() for k := range s.store { s.store[k]++ } s.mu.Unlock() } } }

  • 安全的 handler(校验、超时、builder、原子读、错误处理) var keyRe = regexp.MustCompile(^[a-zA-Z0-9_-]{1,64}$)

    func (s *Server) handler(w http.ResponseWriter, r *http.Request) { s.hits.Add(1)

    key := r.URL.Query().Get("key")
    if !keyRe.MatchString(key) {
        http.Error(w, "invalid key", http.StatusBadRequest)
        return
    }
    
    s.mu.Lock()
    s.store[key]++
    s.mu.Unlock()
    
    dest := r.URL.Query().Get("url")
    if dest != "" {
        // SSRF 防护示意:只允许 https 且在白名单域名
        u, err := url.Parse(dest)
        if err == nil && (u.Scheme == "https" || u.Scheme == "http") && inAllowlist(u.Hostname()) {
            ctx, cancel := context.WithTimeout(r.Context(), 3*time.Second)
            defer cancel()
            req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
            if err == nil {
                if resp, err := s.client.Do(req); err == nil {
                    io.Copy(io.Discard, resp.Body)
                    resp.Body.Close()
                }
            }
        }
    }
    
    var b strings.Builder
    b.Grow(1000)
    // 可用每请求私有 rand.Rand 提升并发性能
    rnd := rand.New(rand.NewSource(time.Now().UnixNano()))
    for i := 0; i < 1000; i++ {
        b.WriteByte('a' + byte(rnd.Intn(26)))
    }
    
    w.Header().Set("Content-Type", "application/json")
    resp := map[string]interface{}{
        "ok":      true,
        "hits":    s.hits.Load(),
        "file":    s.fileLen.Load(), // 如需去敏可省略或模糊处理
        "key":     key,
        "payload": b.String(),
    }
    if err := json.NewEncoder(w).Encode(resp); err != nil {
        // 客户端断开等情况
        log.Printf("write response error: %v", err)
    }
    

    }

  • 带超时的 http.Server 与优雅关闭 func main() { srv := NewServer() mux := http.NewServeMux() mux.HandleFunc("/m", srv.handler)

    httpSrv := &http.Server{
        Addr:              ":8080",
        Handler:           mux,
        ReadTimeout:       5 * time.Second,
        ReadHeaderTimeout: 3 * time.Second,
        WriteTimeout:      10 * time.Second,
        IdleTimeout:       60 * time.Second,
        MaxHeaderBytes:    1 << 20,
    }
    
    ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
    defer stop()
    
    go srv.background(ctx, 500*time.Millisecond)
    
    go func() {
        <-ctx.Done()
        shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
        defer cancel()
        _ = httpSrv.Shutdown(shutdownCtx)
    }()
    
    log.Println("serving on :8080")
    if err := httpSrv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
        log.Fatalf("server error: %v", err)
    }
    

    }

快速整改优先级(从高到低):

  1. 修复数据竞争:用互斥锁或 sync.Map 包装 store;background 使用 context 取消。读取 hits 使用 atomic.LoadInt64。
  2. 设置 server/client 超时;复用全局 http.Client,并在外呼时关闭 resp.Body。
  3. 防 SSRF:解析并校验 url,仅允许白名单域名/网段;限制重定向;加超时。
  4. 移除每请求文件读取:启动时 os.Stat 缓存长度或按需低频刷新。
  5. 使用 strings.Builder 生成 payload;设置 Content-Type;统一错误处理与日志。
  6. 封装为 Server 结构体,添加优雅关闭、lint/测试与竞态检测。

示例详情

解决的问题

通过采用角色扮演的方式,让AI模拟成为资深代码审查专家,从安全性、错误处理、风格一致性与性能等多维度对代码进行全面评估,帮助开发者快速发现潜在问题并得到明确的优化建议,从而提升代码质量和开发效率。

适用用户

软件工程师

需要快速检查并优化代码质量的开发者,他们能够借助此工具发现潜在问题、提升开发效率。

团队技术负责人

需保证团队输出代码高质量与一致性,实现更规范、高效的协作开发流程。

运维与安全专家

关注代码中的安全漏洞,通过提示词能更方便地从代码层面排除潜在风险。

特征总结

从安全性角度深度剖析代码,迅速发现潜在漏洞,为项目提供高水准的保护。
针对错误处理机制的审查,一键识别不足并提出实用改进建议,避免运行时问题。
轻松检测代码风格一致性,确保团队协作代码更加统一、专业。
深入切片代码性能表现,从逻辑到实现全方位优化,助力提升执行效率。
支持多编程语言场景,无论前端、后端还是脚本都可一站式覆盖。
自动化代码分析流程,减少人工复核时间,快速获得结构完善的代码建议。
定制化审查方面支持,可按需求重点关注特定问题,灵活满足项目需求。
即使是复杂代码片段,也能细致分解并提供易操作的优化指导。
从开发者角度直观呈现优化结果,减少理解和沟通成本,加速改进实施。

如何使用购买的提示词模板

1. 直接在外部 Chat 应用中使用

将模板生成的提示词复制粘贴到您常用的 Chat 应用(如 ChatGPT、Claude 等),即可直接对话使用,无需额外开发。适合个人快速体验和轻量使用场景。

2. 发布为 API 接口调用

把提示词模板转化为 API,您的程序可任意修改模板参数,通过接口直接调用,轻松实现自动化与批量处理。适合开发者集成与业务系统嵌入。

3. 在 MCP Client 中配置使用

在 MCP client 中配置对应的 server 地址,让您的 AI 应用自动调用提示词模板。适合高级用户和团队协作,让提示词在不同 AI 工具间无缝衔接。

AI 提示词价格
¥20.00元
先用后买,用好了再付款,超安全!

您购买后可以获得什么

获得完整提示词模板
- 共 77 tokens
- 3 个可调节参数
{ 编程语言 } { 审查维度 } { 代码片段 }
获得社区贡献内容的使用权
- 精选社区优质案例,助您快速上手提示词
使用提示词兑换券,低至 ¥ 9.9
了解兑换券 →
限时半价

不要错过!

半价获取高级提示词-优惠即将到期

17
:
23
小时
:
59
分钟
:
59