副标题：适配 Bun 运行时，万级数据映射性能提升 200%，前后端解耦的终极方案。
很多前端同学在处理接口时，业务代码里塞满了这种逻辑：
登录
const name = res.data.u_info_v2_name || "未知";
const status = res.data.state === 1;
const tags = res.data.raw_str ? res.data.raw_str.split(",") : [];
这种硬编码的后果：
这不是简单“封装几个工具函数”，而是一层可维护、可演进的数据契约层：
toClient 负责展示态，toAPI 负责提交态。flowchart LR
A[后端原始 JSON] --> B[BFFDataAdapter]
B --> C[Schema 映射]
C --> D[Transformer 转换]
D --> E[Validator 校验]
E --> F[前端干净对象]
F -->|提交| B
B --> G[API 请求体]
我们把后端杂乱字段映射为前端可读结构，同时做金额格式化和手机号校验。
1-bff/BFFDataAdapter.js 提供适配器能力：
registerSchema(name, schema)：注册数据契约。registerTransformer(name, fn)：注册转换器。registerValidator(name, fn)：注册校验器。toClient(schema, payload)：后端 -> 前端。toAPI(schema, payload)：前端 -> 后端。同时提供 TypeScript 类型定义文件：1-bff/BFFDataAdapter.d.ts。
1-bff/example-order.js 是完整示例，直接运行可看到双向转换效果。
为了减少手写映射成本，提供了 CLI：1-bff/generate-schema.js。
# 方式 1：直接传 JSON 字符串
bun 1-bff/generate-schema.js '{"order_id_long":"123","amount_fen":19900,"user":{"profile":{"nickname":"iDao"}}}' --name orderDetail
# 方式 2：从文件读取 JSON
bun 1-bff/generate-schema.js --file ./payload.json --name orderDetail
输出是可直接复制的 schema JSON（包含 schemaName 和 schema.fields）。
# 运行业务示例
bun 1-bff/example-order.js
# JSON 自动生成 Schema
bun 1-bff/generate-schema.js '{"foo_bar":1,"user":{"name":"A"}}' --name demoSchema
# 跑万级数据压测（默认 10000 条）
bun 1-bff/benchmark.js
# 自定义条数
bun 1-bff/benchmark.js 50000
如果你想和 Node.js 对比：
node 1-bff/benchmark.js 10000
bun 1-bff/benchmark.js 10000
在 BFF 层做大批量数据映射时，性能瓶颈通常来自两块：
在这类场景里，Bun 在 JSON 处理和整体运行时开销上通常更有优势。你可以直接用 1-bff/benchmark.js 在本机得到真实数字，避免“玄学优化”。
提示：真实性能和机器配置、数据形态、转换逻辑复杂度相关。建议在你的真实数据样本上测。
import { createBFFAdapter } from "./BFFDataAdapter.js";
const adapter = createBFFAdapter();
adapter.registerTransformer("money", (val) => `￥${(val / 100).toFixed(2)}`);
adapter.registerSchema("orderDetail", {
fields: {
id: { source: "order_id_long", required: true },
price: { source: "amount_fen", transform: "money" },
customerName: { source: "user.profile.nickname", default: "匿名用户" },
contact: { source: "service_phone", validate: "phone" },
statusText: {
source: "state_code",
transform: (val) => (val === 1 ? "待发货" : "已完成"),
},
},
});
我已经把这套适配器整理成支持 TypeScript 自动推导的进阶版（告别 any）。
资料包内含：
BFFDataAdapter 完整源码及 TS 类型定义。关注我的掘金/公众号 [iDao技术魔方]，后台私信回复关键字 "BFF"，立刻获取隐藏仓库地址。
出品|虎嗅汽车组
作者|王亚骏
头图|视觉中国
“我想，没有人，比我们比亚迪更懂电池。”在3月5日举办的比亚迪技术发布会上，一向低调的王传福并未掩锋芒。
当晚，比亚迪发布了第二代刀片电池、新的闪充技术，并展示了仰望U7、大唐和宋Ultra等10款车型。
图源：发布会
在发布会上，第二代刀片电池是首个被介绍的产品，王传福并没有过多解释其技术原理，而是重点介绍了这款产品会如何提升补能效率：
从10%到70%，充电时间5分钟；
从10%到97%，充电时间9分钟；
在零下30摄氏度的气温下，只会多出3分钟。
对比市面上的其他车型来看，新电池的充电速度的确快了约30%～50%。行业中有观点认为，比亚迪第二代刀片电池甚至已经撼动了蔚来的换电优势。与之对比，蔚来第四代换电站换电的最快速度为2分24秒。
对于比亚迪而言，刀片电池的确有着特殊的意义。
6年前，比亚迪发布了第一代刀片电池，这款产品一定程度上帮助公司进入了一轮高增长周期。
2020年，比亚迪年销量为42.7万辆，在行业内只能算“有力竞争者之一”；而到了2025年，公司年销量达到了460.2万辆，不仅连续四年成为全球新能源汽车销冠，甚至净利润也超越了特斯拉（2025年前三季度）。
“福将”刀片电池能否为比亚迪再带来一次狂飙？在此次发布会的背后，又隐藏着什么暗线？本期《车圈脉动》VOL.19，来解码一下。
逆境中的发布会，背后有何暗线？
“以前大家都说‘电车不过山海关’...从今天开始，我们的第二代刀片电池要让这句话永远成为历史！”王传福在发布会上如是说道。
可是在豪言壮语的背后，比亚迪正面临着一场逆风局。从去年12月开始，比亚迪销量已连续3个月出现下滑。
在高端化方面，比亚迪虽有一定突破，但也有未能按时完成的目标。
腾势是比亚迪三大高端品牌之一（其他两个是方程豹和仰望）。3年前，前腾势销售事业部总经理赵长江在采访中表示，到2025年，腾势品牌月销量要达到5万至6万辆的水平。
去年全年，腾势的销量为15.7万辆，同比增长24.7%，平均下来每个月销量仅为1.3万辆。赵长江也在10月被爆出离职，并在今年1月宣布加入智界。
造成当下逆风局的原因，既有比亚迪的技术壁垒不如以往坚固的原因，也有公司自身调整的因素。
去年12月5日，比亚迪召开了临时股东大会。王传福在会上表示，比亚迪国内市场销量出现下滑，一方面由于比亚迪当前技术领先度不及前几年，叠加行业同质化现象加剧；另一方面则是低温充电速度慢等用户需求痛点尚未完全解决。同时，他也坦承，过去几年市场处于顺风期，比亚迪在营销上存在“惰性”。
“我们可能会丢掉一两个月甚至一两个季度的业绩增长。”
面对销量下滑的局面，比亚迪开始有意收缩自己的战线，为下一轮进攻蓄力。在今年1月，比亚迪销售了21万辆汽车，被吉利反超（27万辆），2月销量继续下滑到19万辆。
中泰证券2月发布的一份研报中表示，比亚迪在当时采取了降低批发出货的方式，以控制终端库存与生产节奏，这是为了降低渠道库位压力，来匹配技术发布会以及之后的新品周期上量节奏。
目前来看，中泰证券的判断基本正确。在发布会的后半段所展示的10款车型，均搭载了第二代刀片电池和新的闪充技术，这些车型将成为比亚迪接下来反攻的关键。
王传福能否如愿？
新能源汽车的上半场是电动化，下半场是智能化。这是王传福本人在2021年年度股东大会上公开提出的观点。在3月5日，他又为“上半场”画上了句号，“今天，我们发布了第二代刀片电池及闪充技术...让电动化上半场完美收官。”
不过在这次发布会上，并没有太多有关智能化的内容。
目前，比亚迪在智能化方面仍处于补课阶段。去年2月，公司发布“全民智驾”战略，将天神之眼方案全系标配。但东吴证券在近期发布的一份研报中表示，由于库存处理节奏存在一定问题，以及中低价格带消费者对智驾功能需求有限且价格敏感，比亚迪的智驾版终端反馈一般。
未来，智能化表现将很大程度上决定比亚迪在国内的销量能否回到增长态势。不过，虎嗅汽车认为，比亚迪已经在国内拿下了可观的规模，同时，整个汽车行业也已经步入微增长阶段。在这两个因素叠加影响下，比亚迪能继续在国内获取的增量是有限的。
换句话说，国内的市场份额当然要守、要争。但更广阔的天地，在海外。
目前，比亚迪的出海布局在国内处于领先地位。公司在泰国、柬埔寨、乌兹别克斯坦和巴西工厂已经投产，正在规划投产的国家有匈牙利、马来西亚。
王传福与巴西总统卢拉出席比亚迪巴西工厂落成典礼；图源：视觉中国
在出海目标方面，据比亚迪集团及公关处总经理李云飞透露，公司 2026 年海外销量目标为130万辆，同时，腾势品牌以及在发布会上亮相的闪充站也计划在今年出海。
接下来，除非智能驾驶技术迎来超预期的突破，否则比亚迪的最大看点便是在海外的产能扩张，以及已经在海外落地的产能，能否顺利兑现成海外销量。
毕竟王传福的目标是将比亚迪打造成丰田那样的国际巨头，而非仅仅是在国内称王。
下载虎嗅APP，第一时间获取深度独到的商业科技资讯，连接更多创新人群与线下活动
GetX 是 Flutter 生态中的一个 全家桶式框架，它不只是一个状态管理方案，而是把状态管理、路由导航、依赖注入三件事打包在了一起。
很多人第一次接触 GetX 的感受是："怎么什么都能做？" —— 这既是它的优势，也是它的争议所在。
GetX
├── 状态管理（State Management） ── 替代 setState / Provider / Bloc
├── 路由管理（Route Management） ── 替代 Navigator 系列 API
└── 依赖注入（Dependency Injection）── 替代 Provider / get_it
一个字：简单。
用 Bloc 写一个计数器功能，你需要：Event 类 + State 类 + Bloc 类 + BlocProvider + BlocBuilder，至少 4~5 个文件。
用 GetX 写同样的功能：一个 Controller 类 + Obx(() => Text())，两行搞定。
GetX 提供了两种状态管理方式，理解它们的区别是用好 GetX 的第一步。
update() 通知刷新setState()，但作用域更小工作原理很朴素：Controller 内部维护一个监听者列表，调用 update() 时遍历通知所有 GetBuilder Widget 重建。本质就是一个 手动版的观察者模式。
.obs 标记，变化时自动触发 UI 刷新update()
// 声明
var count = 0.obs;
// 修改（自动触发 UI 刷新）
count.value++;
// UI 监听
Obx(() => Text('${controller.count}'))
.obs 的底层原理.obs 是 GetX 最核心的魔法。要理解它，需要拆解三个问题：
问题一：.obs 做了什么？
当你写 var count = 0.obs，实际上是把一个普通的 int 包装成了一个 RxInt 对象。这个 Rx 对象内部持有：
_value）Stream）它本质上就是一个 带通知能力的值容器。
问题二：修改值时发生了什么？
当你写 count.value++，Rx 对象的 set value 被触发。在 setter 内部：
_value
Stream 广播一个"值变了"的事件问题三：Obx 怎么知道要监听哪些变量？
这是 GetX 最巧妙的设计。Obx 并不需要你手动告诉它"我依赖了哪些变量"，它是 自动收集依赖 的。
原理分三步：
Obx 在首次 build 时，先打开一个"全局监听开关"() => Text('${count.value}')）count.value 的 getter 被调用时，Rx 对象检测到"监听开关"是打开的，就把自己注册到 Obx 的依赖列表中之后任何被收集到的 Rx 变量发生变化，Obx 就会自动重建。
Obx 首次 build
→ 开启"依赖收集模式"
→ 执行 builder: () => Text('${count.value}')
→ count.value 的 getter 被调用
→ count（Rx 对象）发现正在收集依赖，把自己注册进去
→ 关闭"依赖收集模式"
→ 依赖收集完成：[count]
之后 count.value++ 触发
→ Rx 广播变化
→ Obx 收到通知，重新执行 builder
这个机制和 Vue 3 的
watchEffect、MobX 的autorun原理几乎一模一样 —— 基于 getter 劫持的自动依赖收集。
相比之下，GetBuilder 的原理简单得多：
GetBuilder 在 initState 时，把自己注册到 Controller 的监听者列表update()，遍历列表，调用每个 GetBuilder 的 setState
GetBuilder 在 dispose 时，从列表中移除自己没有 Stream、没有依赖收集，就是最朴素的 观察者模式 + setState。
| 场景 | 推荐 | 原因 |
|---|---|---|
| 表单页面、简单列表 | GetBuilder | 手动控制，性能开销最小 |
| 数据频繁联动、多变量交叉依赖 | Obx + .obs | 自动依赖收集，代码更简洁 |
| 超大列表、高性能场景 | GetBuilder + update([id])
|
可以精确控制刷新范围 |
GetX 内置了一套依赖注入系统，核心 API 就两个：
Get.put(Controller()) —— 注册Get.find<Controller>() —— 获取你可以把它理解成一个 全局的"服务柜台"：先把东西放进去，需要的时候按类型取出来。
GetX 内部维护了一个 全局的 Map<String, Object>，key 是类型名（或类型名 + tag），value 是实例。
全局容器（简化理解）：
{
"HomeController": HomeController 实例,
"UserService": UserService 实例,
"ApiClient_v2": ApiClient 实例（带 tag）
}
Get.put() 就是往 Map 里写，Get.find() 就是从 Map 里读。
| 方式 | 何时创建 | 何时销毁 | 适用场景 |
|---|---|---|---|
Get.put() |
立即创建 | 手动或路由关闭时 | 页面 Controller |
Get.lazyPut() |
首次 find 时 |
同上 | 可能用不到的依赖 |
Get.putAsync() |
立即创建（支持异步） | 同上 | 需要异步初始化的服务 |
Get.create() |
每次 find 都新建 |
不自动销毁 | 每次需要新实例的场景 |
GetX 最被低估的能力之一。它有一套 智能内存管理机制，可以在路由关闭时自动销毁关联的 Controller。
三种模式：
GetBuilder / GetX 使用的 Controller 才自动管理find 时重新创建这解决了 Flutter 状态管理中一个常见的痛点：谁来负责销毁 Controller？ 在 Provider/Bloc 中你需要手动处理，GetX 帮你自动化了。
Flutter 原生路由的痛点：
context，在非 Widget 层（Service、Controller）中很难拿到GetX 的路由通过全局 NavigatorKey 持有 Navigator 的引用，所以 不需要 context 就能跳转。
GetX 路由的核心做了两件事：
第一：全局 NavigatorKey
GetX 在 GetMaterialApp 初始化时，创建了一个全局的 GlobalKey<NavigatorState>，保存在静态变量中。之后所有路由操作都通过这个 key 拿到 Navigator，不再依赖 context。
第二：路由与依赖注入联动
这是 GetX 路由最独特的地方。当你用 Get.to(HomePage()) 跳转时：
GetBuilder 或 Bindings），自动 put 进依赖容器pop 时，自动 delete 关联的 ControllerGet.to(HomePage())
→ 创建路由
→ 自动注册 HomeController（如果有 Binding）
→ 用户在 HomePage 操作...
→ Get.back()
→ 路由 pop
→ 自动销毁 HomeController
→ 内存释放
这就形成了一个 路由驱动的生命周期管理：Controller 的生死和页面的进出自动绑定。
Bindings 是连接路由和依赖注入的纽带。它定义了"进入某个页面时需要准备哪些依赖"。
你可以把它类比为 iOS 的 viewDidLoad —— 页面加载时做初始化工作，页面销毁时自动清理。
GetX 路由支持中间件，可以在路由跳转前/后插入逻辑：
中间件按优先级执行，可以中断跳转（返回 null 表示拦截），和 Web 框架的中间件概念一致。
GetX 是个全家桶，除了三大核心模块，还打包了很多实用工具：
| 能力 | 说明 |
|---|---|
| 国际化（i18n） |
'hello'.tr 即可翻译，动态切换语言 |
| 主题切换 |
Get.changeTheme() 一行切换深色/浅色 |
| 网络请求 |
GetConnect 封装了 HTTP 客户端 |
| 本地存储 |
GetStorage 类似 SharedPreferences 但更快 |
| 响应式表单验证 | 配合 .obs 做实时校验 |
| Snackbar / Dialog / BottomSheet | 不需要 context 的全局弹窗 |
| Worker |
ever / debounce / interval 等响应式工具 |
Worker 是 GetX 响应式系统中很实用的工具，用于对 .obs 变量的变化做 节流、防抖、一次性监听 等处理：
| Worker | 行为 |
|---|---|
ever(count, callback) |
每次变化都执行 |
once(count, callback) |
只在第一次变化时执行 |
debounce(count, callback) |
停止变化后一段时间才执行（搜索场景） |
interval(count, callback) |
变化期间按固定间隔执行（节流） |
底层实现就是对 Rx 的 Stream 做了 listen / first / debounceTime / throttle 等 Dart Stream 操作的封装。
把所有模块串起来，GetX 的底层可以概括为三个核心机制：
.obs 变量（Rx 对象）
└── 内部持有 Stream
└── Obx / Worker 订阅 Stream
└── 变量变化 → Stream 广播 → 订阅者响应
这是 Dart 语言自带的 Stream 机制，GetX 没有发明新东西，只是在 Stream 之上做了 语法糖封装（.obs、Obx、ever 等），降低了使用门槛。
静态 Map<String, InstanceInfo>
└── Get.put() 写入
└── Get.find() 读取
└── Get.delete() 删除
└── SmartManagement 自动清理
没有复杂的 IoC 容器，就是一个 Map。简单直接。
GetMaterialApp 初始化 → 持有全局 NavigatorKey
└── Get.to() / Get.back() → 通过 Key 拿到 Navigator → 执行路由操作
└── 路由变化 → 触发 Bindings → 联动依赖注入的创建/销毁
| 项目类型 | 推荐度 | 建议 |
|---|---|---|
| 个人项目 / Demo | 强烈推荐 | 快速出活 |
| 中小型商业项目 | 推荐 | 配合良好的分层架构使用 |
| 大型团队协作项目 | 谨慎 | 建议考虑 Riverpod / Bloc，或严格约束 GetX 的使用范围 |
| 学习 Flutter 阶段 | 不推荐先学 | 先理解 Flutter 原生机制，再用 GetX 提效 |
| 维度 | GetX | Provider | Riverpod | Bloc |
|---|---|---|---|---|
| 学习成本 | 低 | 低 | 中 | 高 |
| 模板代码量 | 极少 | 少 | 中 | 多 |
| 依赖 context | 不需要 | 需要 | 不需要 | 需要 |
| 内置路由 | 有 | 无 | 无 | 无 |
| 内置依赖注入 | 有 | 自身就是 DI | 自身就是 DI | 无（需配合） |
| 可测试性 | 中 | 高 | 高 | 高 |
| 官方推荐 | 否 | 是（早期） | 是（现在） | 社区主流 |
| 适合规模 | 小中型 | 中型 | 中大型 | 大型 |
GetX 的哲学是 "约定优于配置，简单优于正确"。它牺牲了一些架构上的严谨性，换来了极致的开发效率。理解它的底层原理（Rx Stream + 全局 Map + 全局 NavigatorKey），你就能用好它，也知道它的边界在哪里。
最早大家都是 手动写代码埋点：在每个按钮点击、页面出现的地方，手动调用 track("事件名")。这种方式最精确，但有两个痛点：
于是业界开始思考：能不能让机器自动采集？能不能让运营自己配置？
这就催生了三种埋点方式的演进：
手动代码埋点 → 无痕埋点（全自动） → 可视化埋点（半自动）
| 维度 | 代码埋点 | 无痕埋点 | 可视化埋点 |
|---|---|---|---|
| 谁来埋 | 开发 | 机器自动 | 运营圈选 |
| 需要发版吗 | 需要 | 不需要 | 不需要 |
| 能带业务参数吗 | 能（商品ID、金额等） | 不能 | 有限支持 |
| 数据量 | 按需 | 巨大 | 按需 |
| 精确度 | 最高 | 最低 | 中等 |
不写任何埋点代码，SDK 自动采集用户的所有操作。
iOS 有个强大的 Runtime 机制叫 Method Swizzling —— 可以在运行时把系统方法的实现"偷偷换掉"。
举个例子，iOS 中所有按钮点击最终都会走 UIControl 的 sendAction:to:forEvent: 方法。SDK 做的事情就是：
原本的调用链：
用户点击按钮 → sendAction → 执行业务逻辑
Swizzle 之后：
用户点击按钮 → SDK 拦截，记录"谁在哪个页面点了什么" → 再调用原始 sendAction → 执行业务逻辑
业务方完全无感知，SDK 悄悄在中间插了一层数据采集。
| 拦截点 | 能采集到什么 |
|---|---|
UIControl 的点击事件 |
按钮、开关、滑块等操作 |
UITableView 的 Cell 点击 |
列表项点击 |
UIViewController 的页面出现 |
页面浏览量（PV） |
UIGestureRecognizer |
手势操作 |
SDK 需要给每个 UI 元素生成一个 唯一标识（ViewPath），方式是沿着 View 层级往上爬，记录每一层的类名和位置：
UIWindow / UINavigationController / 首页VC / UIView / UITableView / 第3个Cell / 购买按钮
转化成路径就是：
UIWindow[0]/UINavigationController[0]/HomeVC[0]/UIView[0]/UITableView[0]/Cell[3]/UIButton[0]
这就像是给每个按钮一个"门牌号"。
门牌号不稳定：UI 稍微改一下层级（比如在按钮外面多套一层 View），路径就变了，之前的数据就对不上了
只知道行为，不知道内容：SDK 能告诉你"用户点了第3个 Cell 里的按钮"，但不知道那个 Cell 显示的是什么商品、多少钱
数据量爆炸：用户每一次点击、每一次滑动都会上报，90% 的数据可能没人看
在无痕埋点的基础上，加了一个"后台圈选"的功能。运营在后台看到 App 截图，用鼠标点选要追踪的元素，SDK 只上报被选中的事件。
第一步：App 和后台建立 WebSocket 连接
第二步：App 截图 + View 树结构 → 发给后台
（后台能看到 App 当前界面的"透视图"）
第三步：运营在后台的截图上点击"立即购买"按钮
→ 后台自动识别出这个按钮的 ViewPath
→ 运营给它命名为 "click_buy_button"
第四步：后台把配置下发给 SDK
{ viewPath: "xxx", eventName: "click_buy_button" }
第五步：SDK 在 Hook 点拦截事件时，拿当前元素的 ViewPath 去配置表里匹配
→ 匹配到了才上报，匹配不到就忽略
无痕埋点：先采集所有数据 → 后期在数据平台筛选（先采后筛）
可视化埋点：先配置要采什么 → 只采集配置过的（先筛后采）
这就像是：
成熟的 App 不会只用一种，而是 混合使用：
| 场景 | 推荐方式 | 原因 |
|---|---|---|
| 页面 PV、App 启动/退出 | 无痕埋点 | 标准化行为，不需要业务参数 |
| 运营活动按钮、Tab 切换 | 可视化埋点 | 需求变化快，运营自助配置 |
| 支付、注册、加购、分享 | 代码埋点 | 需要精确的业务参数（金额、商品ID） |
一个简单的原则：
数据越重要、越需要业务参数的事件，越应该用代码埋点；越通用、越标准化的行为，越适合自动采集。
ViewPath 不稳定是无痕埋点和可视化埋点最大的技术挑战。业界的应对思路：
传统方案依赖 UIKit 的 View 层级树，但 SwiftUI 的渲染机制完全不同 —— 开发者写的 Button 和实际渲染出来的 View 层级之间没有稳定的对应关系。
目前的解决方向：
.tracked("buy_button") 的声明式埋点这个领域还在发展中，还没有像 UIKit 时代那样成熟的方案。
| 平台 | 特点 |
|---|---|
| GrowingIO | 国内可视化埋点先驱，圈选体验好 |
| 神策 Sensors Analytics | 全埋点 + 可视化 + 代码埋点全覆盖，iOS SDK 开源 |
| Mixpanel | 可视化埋点 + 代码埋点，国际主流 |
| Heap | 全埋点理念的代表，"Capture Everything" |
| Firebase Analytics | Google 出品，自动事件 + 自定义事件 |
Vue 3的Composition API是Vue框架最重大的更新之一，它提供了一种全新的组件逻辑组织方式。与传统的Options API相比，Composition API让我们能够更灵活地组织和复用代码逻辑。本文将深入探讨Vue 3 Composition API的8大核心特性，帮助你掌握这个构建可复用逻辑的终极方案。
setup函数是Composition API的入口点，它在组件创建之前执行。
import { ref, reactive } from 'vue';
export default {
setup() {
// 定义响应式数据
const count = ref(0);
const user = reactive({
name: 'Vue 3',
version: '3.0'
});
// 定义方法
const increment = () => {
count.value++;
};
// 返回给模板使用
return {
count,
user,
increment
};
}
};
setup函数接收两个参数：props和context。
export default {
props: {
title: String,
initialCount: {
type: Number,
default: 0
}
},
setup(props, context) {
// props是响应式的，不能解构
console.log(props.title);
// context包含attrs、slots、emit等
const { attrs, slots, emit } = context;
// 触发事件
const handleClick = () => {
emit('update', props.initialCount + 1);
};
return { handleClick };
}
};
ref和reactive是创建响应式数据的两种方式，各有适用场景。
import { ref, reactive, toRefs } from 'vue';
// ref - 适合基本类型和单一对象
const count = ref(0);
const message = ref('Hello');
// 访问ref的值需要.value
console.log(count.value);
count.value++;
// reactive - 适合复杂对象
const state = reactive({
count: 0,
user: {
name: 'Vue',
age: 3
}
});
// 访问reactive的值不需要.value
console.log(state.count);
state.count++;
// 在模板中自动解包，不需要.value
// <template>
// <div>{{ count }}</div>
// <div>{{ state.count }}</div>
// </template>
当需要从reactive对象中解构属性时，使用toRefs保持响应性。
import { reactive, toRefs } from 'vue';
export default {
setup() {
const state = reactive({
count: 0,
name: 'Vue 3',
isActive: true
});
// 不推荐 - 失去响应性
// const { count, name } = state;
// 推荐 - 使用toRefs保持响应性
const { count, name, isActive } = toRefs(state);
const increment = () => {
count.value++;
};
return {
count,
name,
isActive,
increment
};
}
};
computed用于创建计算属性，支持getter和setter。
import { ref, computed } from 'vue';
export default {
setup() {
const firstName = ref('John');
const lastName = ref('Doe');
// 只读计算属性
const fullName = computed(() => {
return firstName.value + ' ' + lastName.value;
});
// 可写计算属性
const writableFullName = computed({
get() {
return firstName.value + ' ' + lastName.value;
},
set(value) {
const [first, last] = value.split(' ');
firstName.value = first;
lastName.value = last;
}
});
return {
firstName,
lastName,
fullName,
writableFullName
};
}
};
watch和watchEffect用于侦听数据变化。
import { ref, reactive, watch, watchEffect } from 'vue';
export default {
setup() {
const count = ref(0);
const user = reactive({
name: 'Vue',
age: 3
});
// watchEffect - 自动追踪依赖
watchEffect(() => {
console.log(`Count is: ${count.value}`);
console.log(`User is: ${user.name}`);
});
// watch - 显式指定侦听源
watch(count, (newValue, oldValue) => {
console.log(`Count changed from ${oldValue} to ${newValue}`);
});
// 侦听多个源
watch([count, () => user.name], ([newCount, newName], [oldCount, oldName]) => {
console.log(`Count: ${oldCount} -> ${newCount}, Name: ${oldName} -> ${newName}`);
});
// watch的配置选项
watch(
() => user.name,
(newValue) => {
console.log(`Name changed to: ${newValue}`);
},
{
immediate: true, // 立即执行
deep: true // 深度侦听
}
);
return { count, user };
}
};
Composition API中的生命周期钩子以on开头。
import {
onMounted,
onUpdated,
onUnmounted,
onBeforeMount,
onBeforeUpdate,
onBeforeUnmount
} from 'vue';
export default {
setup() {
onBeforeMount(() => {
console.log('组件挂载前');
});
onMounted(() => {
console.log('组件已挂载');
// 可以在这里访问DOM
});
onBeforeUpdate(() => {
console.log('组件更新前');
});
onUpdated(() => {
console.log('组件已更新');
});
onBeforeUnmount(() => {
console.log('组件卸载前');
});
onUnmounted(() => {
console.log('组件已卸载');
// 清理工作
});
return {};
}
};
自定义组合函数是Composition API的核心优势，让我们能够提取和复用逻辑。
// useCounter.js - 计数器逻辑
import { ref, computed } from 'vue';
export function useCounter(initialValue = 0) {
const count = ref(initialValue);
const increment = () => {
count.value++;
};
const decrement = () => {
count.value--;
};
const reset = () => {
count.value = initialValue;
};
const double = computed(() => count.value * 2);
return {
count,
increment,
decrement,
reset,
double
};
}
// useMouse.js - 鼠标位置追踪
import { ref, onMounted, onUnmounted } from 'vue';
export function useMouse() {
const x = ref(0);
const y = ref(0);
const update = (event) => {
x.value = event.pageX;
y.value = event.pageY;
};
onMounted(() => {
window.addEventListener('mousemove', update);
});
onUnmounted(() => {
window.removeEventListener('mousemove', update);
});
return { x, y };
}
// 在组件中使用
import { useCounter, useMouse } from './composables';
export default {
setup() {
const { count, increment, decrement, double } = useCounter(10);
const { x, y } = useMouse();
return {
count,
increment,
decrement,
double,
x,
y
};
}
};
provide和inject用于跨组件层级传递数据。
// 父组件
import { provide, ref } from 'vue';
export default {
setup() {
const theme = ref('dark');
const user = ref({
name: 'Vue User',
role: 'admin'
});
// 提供数据
provide('theme', theme);
);
provide('user', user);
return { theme };
}
};
// 子组件
import { inject } from 'vue';
export default {
setup() {
// 注入数据
const theme = inject('theme');
const user = inject('user');
// 提供默认值
const config = inject('config', {
debug: false,
version: '1.0'
});
return { theme, user, config };
}
};
在Composition API中使用ref获取模板引用。
import { ref, onMounted } from 'vue';
export default {
setup() {
// 创建模板引用
const inputRef = ref(null);
const listRef = ref(null);
onMounted(() => {
// 访问DOM元素
inputRef.value.focus();
// 访问组件实例
console.log(listRef.value.items);
});
const focusInput = () => {
inputRef.value.focus();
};
return {
inputRef,
listRef,
focusInput
};
}
};
// 模板中使用
// <template>
// <input ref="inputRef" />
// <MyList ref="listRef" />
// </template>
// useForm.js
import { ref, reactive } from 'vue';
export function useForm(initialValues, validationRules) {
const values = reactive({ ...initialValues });
const errors = reactive({});
const touched = reactive({});
const validate = () => {
let isValid = true;
for (const field in validationRules) {
const rules = validationRules[field];
const value = values[field];
for (const rule of rules) {
if (rule.required && !value) {
errors[field] = rule.message || '此字段必填';
isValid = false;
break;
}
if (rule.pattern && !rule.pattern.test(value)) {
errors[field] = rule.message || '格式不正确';
isValid = false;
break;
}
if (rule.validator && !rule.validator(value)) {
errors[field] = rule.message || '验证失败';
isValid = false;
break;
}
}
}
return isValid;
};
const handleChange = (field) => (event) => {
values[field] = event.target.value;
touched[field] = true;
if (errors[field]) {
validate();
}
};
const handleBlur = (field) => () => {
touched[field] = true;
validate();
};
const reset = () => {
Object.assign(values, initialValues);
Object.keys(errors).forEach(key => {
errors[key] = '';
});
Object.keys(touched).forEach(key => {
touched[key] = false;
});
};
const submit = (callback) => () => {
if (validate()) {
callback(values);
}
};
return {
values,
errors,
touched,
handleChange,
handleBlur,
validate,
reset,
submit
};
}
// 使用示例
export default {
setup() {
const { values, errors, handleChange, handleBlur, submit } = useForm(
{
username: '',
email: '',
password: ''
},
{
username: [
{ required: true, message: '用户名必填' },
{ pattern: /^[a-zA-Z0-9_]{3,20}$/, message: '用户名格式不正确' }
],
email: [
{ required: true, message: '邮箱必填' },
{ pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/, message: '邮箱格式不正确' }
],
password: [
{ required: true, message: '密码必填' },
{ validator: (value) => value.length >= 6, message: '密码至少6位' }
]
}
);
const handleSubmit = submit((formData) => {
console.log('表单提交:', formData);
// 发送API请求
});
return {
values,
errors,
handleChange,
handleBlur,
handleSubmit
};
}
};
// useAsyncData.js
import { ref, onMounted } from 'vue';
export function useAsyncData(fetchFn, options = {}) {
const {
immediate = true,
initialData = null,
onSuccess,
onError
} = options;
const data = ref(initialData);
const loading = ref(false);
const error = ref(null);
const execute = async (...args) => {
loading.value = true;
error.value = null;
try {
const result = await fetchFn(...args);
data.value = result;
if (onSuccess) {
onSuccess(result);
}
return result;
} catch (err) {
error.value = err;
if (onError) {
onError(err);
}
throw err;
} finally {
loading.value = false;
}
};
if (immediate) {
onMounted(execute);
}
return {
data: data,
loading: loading,
error: error,
execute: execute,
refresh: execute
};
}
// 使用示例
export default {
setup() {
const { data, loading, error, refresh } = useAsyncData(
async (userId) => {
const response = await fetch(`/api/users/${userId}`);
return response.json();
},
{
immediate: true,
onSuccess: (data) => {
console.log('数据加载成功:', data);
},
onError: (error) => {
console.error('数据加载失败:', error);
}
}
);
return {
data,
loading,
error,
refresh
};
}
};
Vue 3 Composition API为我们提供了更强大、更灵活的代码组织方式：
Composition API不仅是一种新的API，更是一种新的思维方式。它让我们能够以更函数式、更模块化的方式组织代码，提高了代码的可维护性和可测试性。开始在你的项目中使用Composition API吧，体验Vue 3带来的全新开发体验！
本文首发于掘金，欢迎关注我的专栏获取更多前端技术干货！
