文章目录

写移动开发这些年,我被问过最多的问题不是某个 API 怎么用,而是“我现在要做个 App,到底该用哪套技术栈”。提问的人里有刚学完 Kotlin 语法的学生,有带着一个完整产品需求来找外包的创业者,也有已经用 React 写了一年前端、想顺手把移动端也做了的工程师。他们的共同点是:把选型当成了一道单选题,希望有人直接给出“A 还是 B”的答案。

但真实情况是,这个问题的答案取决于约束条件。同样一个“做个电商 App”的需求,一个人做、三个人做、三十个人做,最优解完全不同;只在国内分发和要上 Google Play,选择也不同。所以这篇文章不打算给你一个“最强框架”的排名,而是想把六套主流技术栈拆到渲染管线这一层,让你看清楚每一套方案到底在哪里做了妥协,然后在自己的约束条件下求解。

文章分三部分:第一部分讲清 Android、iOS、鸿蒙三条原生路线和 Flutter、React Native、Kotlin Multiplatform 三条跨平台路线各自的技术底座;第二部分用公开的实测数据把“性能好”这种模糊说法变成可计算的指标;第三部分给出一个可以自己改权重的选型模型,并用一段在虚拟机上跑通的 Python 代码演示“同一份评分、三种最优解”是怎么发生的。

写在前面:本文的资料来源与口径

文中涉及框架机理的部分,全部来自官方文档,包括 Android Developers 的 Compose 指南、Apple 的 SwiftUI 文档、华为的 ArkTS/ArkUI 文档、Flutter 与 React Native 官方站点、JetBrains 的 KMP 文档;涉及市场份额的部分来自 StatCounter 与 Counterpoint Research 的统计;涉及跨平台与原生性能对比的部分,引用了一篇 2026 年的 arXiv 实证研究和一篇 2025 年的横向测试报告。凡是直接使用了某份资料的知识点,我在句末用方括号标注了序号,序号与文末“参考资料”一一对应。市场份额与版本信息都具有时效性,文中数据统一标注了统计期,阅读时请注意时间。

1 选型的本质:你选的不是语言,是一条渲染管线

1.1 一个 App 的四层结构

把任何一个手机应用拆开,从下往上大致是四层:最底下是操作系统层,负责进程调度、内存管理、图形驱动和权限控制;往上是运行时层,负责把开发者写的代码解释或编译成机器能执行的指令,并提供垃圾回收、线程模型这些基础设施;再往上是 UI 框架层,负责把“界面应该长什么样”翻译成测量、布局、绘制指令,最终交给 GPU;最上面是业务层,放状态管理、网络请求、数据持久化这些和界面无关的东西。

技术栈之间的差异,绝大部分集中在中间两层。操作系统层你改不了,业务层大家都用相似的架构模式,真正决定开发体验和运行表现的,是运行时怎么编译你的代码,以及 UI 框架怎么把状态变成像素。所以判断一套技术栈适不适合你,最有效的问法是:它的运行时是什么,它的 UI 框架走哪条渲染路径。

输入事件与 vsync 回流

业务层:状态管理 · 领域逻辑 · 数据访问

UI 框架层:Compose · SwiftUI · ArkUI · Flutter Engine · Fabric

运行时层:ART · Swift Runtime · ArkCompiler · Dart VM · Hermes

操作系统层:内核 · 驱动 · 系统服务 · 权限

这张图想说明的一件事是:跨平台框架并没有绕过操作系统层,它只是选择了在运行时层和 UI 框架层之间插入自己的实现。Flutter 把 UI 框架层整个换成了自己的 Engine,所以它的界面在两端长得一模一样;React Native 保留了原生 UI 框架,只把“谁来驱动这棵原生视图树”交给了 JavaScript;Kotlin Multiplatform 干脆只共享业务层,UI 层仍然交给各平台原生框架。

1.2 从命令式到声明式:一次不可逆的范式迁移

十年前写 Android,代码是这样的:找到控件、调用 setText、调用 addView、手动改可见性。这套模式叫命令式,开发者需要精确地告诉系统“从当前状态变到目标状态要执行哪几步”。问题在于,界面状态一旦多起来,你需要维护的就不是一份状态,而是“状态与视图之间的同步关系”。同一份数据渲染在两个地方,你很容易漏掉其中一处;两次更新冲突时,还可能把值写到一个已经被移除的节点上。用官方文档的话说,软件维护的复杂度会随着需要更新的视图数量一起增长[1]。

声明式把这件事反了过来:你只描述“给定这份状态,界面应该长什么样”,框架负责计算出最小的变更集合并应用。Compose 的做法是在概念上从头重新生成整个屏幕,然后只执行必要的改动,从而避免手动维护有状态视图树的复杂性[1]。代价是“重新生成整个屏幕”听起来很贵,所以框架必须足够聪明地跳过不需要重算的部分——这正是后面要讲的重组机制存在的原因。

这条迁移线在六套技术栈上都能看到:Android 从 View 走到 Compose,iOS 从 UIKit 走到 SwiftUI,鸿蒙一开始就只提供 ArkUI 声明式范式,Flutter 和 React Native 从诞生起就是声明式的。也就是说,2026 年你无论选哪条路线,学的都是同一套心智模型:状态驱动视图。这个共性非常重要,它意味着你在一个框架里练出来的状态设计能力,换栈之后大部分可以迁移。

1.3 三条实现路径:原生、自绘、桥接、共享逻辑

严格来说跨平台方案有四种,常被混为三种。

第一种是自绘,代表是 Flutter。它自带渲染引擎,把 Dart 代码编译成原生机器码,UI 不走系统控件,而是自己画。好处是两端像素级一致,坏处是包体大、首次加载要初始化引擎、系统级控件(比如输入框的文本选择菜单)需要额外适配。

第二种是桥接,代表是 React Native。它把 React 的组件树映射成真实原生控件,JavaScript 层负责逻辑与布局描述。旧架构下 JS 和原生之间靠异步 JSON 序列化通信,这是它历史上卡顿的主要来源;新架构用 JSI 把这层通信换成了直接调用,这是后文要展开的重点。

第三种是共享逻辑、不共享 UI,代表是 Kotlin Multiplatform。业务代码写一份,界面各写各的。它的哲学是“UI 是最不该统一的部分”,因为两端用户的交互习惯本来就不同。

第四种其实是“混合”,即上面几种的组合,比如 Flutter 里嵌原生页面、RN 里嵌原生模块、KMP 共享层配 Compose Multiplatform 做 UI。真实项目里第四种用得最多,后文会专门讲。

2 2026 年的市场基本盘:三个数字决定你的优先级

2.1 全球:七三格局没有变,但 iOS 的商业价值被低估了

StatCounter 的统计显示,2026 年 10 月全球移动操作系统的存量份额为 Android 72.36%、iOS 27.61%[11]。这个比例近几年相当稳定,Android 靠中低端机型和新兴市场维持大盘,iOS 靠高价位机型和生态粘性维持利润盘。

很多团队看到 72% 对 27% 就决定“先做 Android”,这个判断在流量层面是对的,在收入层面经常是错的。iOS 用户的应用内付费意愿、订阅转化率普遍高于 Android,尤其在工具类、内容订阅类产品上差距明显。所以更合理的做法不是按份额排序,而是按“你的变现模型在哪一端成立”排序。如果你的产品靠广告曝光,Android 优先;靠订阅和虚拟商品,两端都得做,且 iOS 的支付链路要提前设计。

2.2 中国:鸿蒙跨过 19%,格局从“双雄”变成“三足”

国内的情况变化更快。Counterpoint Research 的数据显示,2026 年第一季度鸿蒙在中国智能手机操作系统市场的份额达到 19%,Android 为 63%,iOS 为 18%;到第二季度,鸿蒙进一步升至 24%,Android 回落至 58%,iOS 为 18%[12]。这意味着鸿蒙已经连续多个季度稳居国内第二,把 iOS 压到了第三。

装机侧的数字同样关键:截至 2026 年 10 月,鸿蒙终端设备装机量突破 1 亿台,原生应用数量超过 10 万个,而通过 HarmonyOS 手机可获取的应用超过 40 万个[12]。1 亿台放在全球 Android 几十亿的盘子里不算大,但放在国内市场,它已经是一个任何面向国内用户的 App 都不能忽略的渠道。

58% 24% 18% 2026 Q2 中国手机 OS 份额(Counterpoint) Android [58] HarmonyOS [24] iOS [18]

这里要提醒一个容易被混淆的口径问题:StatCounter 统计的是存量设备(有多少台手机在用),Counterpoint 的手机 OS 份额统计的是当期销量(这个季度卖出去的手机里各系统占多少)。存量份额变化慢,销量份额变化快。所以你会看到 Android 在 StatCounter 上是 72%,在某季度销量口径上却是 58% 甚至更低。写选型报告时把两个口径混用,是常见但不该犯的错误。

2.3 别被“开发者数量”误导

鸿蒙生态的注册开发者已经达到 1100 万量级[12],这个数字听起来很吓人,但它的统计口径包含所有注册过账号的人,不等于活跃开发者,更不等于你能招到的候选人。判断一个生态是否值得投入,看三个更硬的指标:原生应用的数量级、头部应用是否完成适配、以及围绕它的第三方库和服务是否齐全。

目前原生鸿蒙应用在 10 万量级,Android 与 iOS 则是百万量级,差距仍然是一个数量级。这个差距决定了什么?决定了你做鸿蒙版时,某些垂直领域(比如特定行业的 SDK、某些小众支付通道、部分统计分析工具)可能找不到现成方案,需要自己写或等厂商适配。这不是说不能做,而是说排期时要留出这部分额外工作量。

3 Android:Kotlin + Jetpack Compose 的成熟范式

3.1 平台底座与运行时

Android 的底座是 Linux 内核加一层用户空间的系统服务,应用进程跑在独立的沙箱里,每个应用有自己的 UID,跨进程通信走 Binder。应用代码经编译后由 ART 运行时执行,ART 支持 AOT 与 JIT 混合编译,垃圾回收是分代式的,主线程负责处理输入事件和绘制,超过 16.6 毫秒的工作会直接体现为掉帧。

这套底座带来的一个现实约束是设备碎片化。同一个 API 在不同厂商的 ROM、不同年代的机型上表现可能不同,尤其是后台保活、推送通道、权限弹窗这些和系统深度交互的部分。选 Android 原生,你买到的是最完整的系统能力,同时也要承担最复杂的兼容性测试成本。

3.2 为什么 Kotlin 是默认选择

Kotlin 在 2019 年被宣布为 Android 首选语言,现在新项目基本不会再用 Java 起。它真正解决问题的不是语法糖,而是三件事:空安全把大量运行时的 NullPointerException 提前到了编译期;协程把异步代码写成了同步的顺序结构,配合结构化并发可以自动处理取消和异常传播;扩展函数让工具类那种“静态方法堆”消失了。

对 Compose 来说,Kotlin 还有一层更硬的关系:Compose 编译器插件依赖 Kotlin 编译器的能力,把 @Composable 函数改写成带状态参数的形式。这也是为什么 Compose 的采用和 Kotlin 的采用是同一件事——你不用 Kotlin,就用不了 Compose。

3.3 Compose 的三阶段

官方文档把 Compose 的一帧拆成三个阶段:组合(Composition)决定“要显示什么界面”,运行可组合函数并生成界面说明;布局(Layout)决定“界面放在哪”,包含测量和放置两步;绘制(Drawing)决定“怎么渲染”,把界面元素画到画布上[2]。三个阶段通常按顺序单向执行,数据从组合流向布局再流向绘制,这就是所谓单向数据流。

GPU 绘制 Draw 布局 Layout 组合 Composition 状态 State GPU 绘制 Draw 布局 Layout 组合 Composition 状态 State 状态变化,标记需要重组 1 执行可组合函数,生成界面树 2 提交测量请求 3 测量 Measure 4 放置 Place 5 生成绘制指令 6 提交图层与纹理 7 等待下一帧 vsync 8

这个模型有一个值得记住的例外:BoxWithConstraints、LazyColumn、LazyRow 这类组件的子项组合依赖父级的布局阶段,所以它们不是严格的“组合→布局”顺序[2]。理解这一点,你就明白为什么在 LazyColumn 里做嵌套滚动会遇到那些奇怪的测量问题——子项的可见性本身是布局算出来的结果。

3.4 重组的四个事实与性能边界

官方文档对重组给了四条性质,我觉得每一条都对应一个实践中的坑[1]。第一,重组会跳过尽可能多的内容:如果某个可组合项的输入没有变化,Compose 会跳过它的执行,所以“哪些参数是稳定的”直接决定性能。第二,重组是乐观的操作:Compose 假定重组会成功,如果中途状态又变了,它会取消并重来,所以不要在组合过程中做有副作用的操作。第三,可组合函数可能非常频繁地执行,因此函数体里不能放耗时逻辑。第四,可组合函数可以并行执行、可以按任意顺序执行,这意味着它们之间不能有隐式的先后依赖。

把这四条翻译成一句工程结论:组合阶段必须是纯函数。所有副作用(网络请求、日志、动画启动)都要放进 LaunchedEffect、DisposableEffect 或者事件回调里,状态要用 remember 保存。我见过太多“Compose 很卡”的案例,最后查出来是在 @Composable 里直接读数据库或者创建对象。

重组的成本可以用一个粗略的模型描述。设界面树的节点总数为 N N N,一次状态变更影响的子树规模为 N d i r t y N_{dirty} Ndirty​,则单帧的组合开销近似为:

T r e c o m p o s e ≈ c 0 + c 1 ⋅ N d i r t y , N d i r t y ≤ N T_{recompose} \approx c_0 + c_1 \cdot N_{dirty}, \qquad N_{dirty} \le N Trecompose​≈c0​+c1​⋅Ndirty​,Ndirty​≤N

其中 c 0 c_0 c0​ 是固定的调度开销, c 1 c_1 c1​ 是单节点重组成本。这个式子说明优化的方向不是“减少节点总数”,而是“缩小每次变更的脏区”——把状态下沉到最小作用域、用 derivedStateOf 收敛高频变化的读、把大列表交给 LazyColumn 而不是 Column。

3.5 Android 栈的收益与代价

选择 Android 原生,你得到的是最完整的系统能力、最全的第三方生态、最快的审核链路(国内应用商店基本是小时级到天级),以及最大的开发者人才池。代价是:设备碎片化让兼容性测试成为固定成本;国内没有 GMS,推送、地图、支付都要接厂商或第三方方案;如果你还要做 iOS,等于要维护第二套代码。

一段最简单的 Compose 计数器长这样,它把“状态驱动”讲得很清楚:count 是唯一的状态源,点击事件只负责改状态,界面自动跟着变。

@Composable
fun Counter() {
    var count by remember { mutableStateOf(0) }

    Column(
        modifier = Modifier.fillMaxSize(),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center
    ) {
        Text(text = "点击次数:$count", style = MaterialTheme.typography.headlineSmall)
        Spacer(Modifier.height(16.dp))
        Button(onClick = { count++ }) {
            Text("点我 +1")
        }
    }
}

4 iOS:Swift + SwiftUI 的闭环生态

4.1 平台底座与内存模型

iOS 的底座是 Darwin/XNU,应用同样跑在沙箱里,但权限模型比 Android 更收紧:后台执行受限、跨应用数据共享要走特定的容器与授权、所有分发必须经过 App Store(企业分发和 TestFlight 是有限例外)。内存管理用 ARC,引用计数在编译期插入,没有垃圾回收器,所以循环引用会直接变成内存泄漏,weak 和 unowned 是必须掌握的语法。

这套模型的优点是确定性高:没有 GC 停顿,帧时间更可预测,这也是 iOS 上动画普遍更“跟手”的原因之一。缺点是开发者要自己承担引用环的责任,闭包里捕获 self 这件事在 Swift 里是高频考点。

4.2 SwiftUI 的数据流设计

SwiftUI 的核心承诺是“单一数据源”:你把视图层次组合起来的同时,也声明了视图对数据的依赖;数据变化时,框架自动更新受影响的界面部分,传统上由视图控制器承担的大部分工作被框架接管[15]。

它把状态按生命周期和所有权分成了几种工具:@State 用于视图内局部的、短暂的值类型状态;@Binding 用于把某个状态的引用传给子视图,让子视图能读写但所有权还在父视图[16];@Observable 宏用于引用类型的模型对象,配合 @State 在视图内实例化,或用 @Environment 在层级间共享而不必逐层传参[15];@Bindable 则用于从可观察对象上取某个属性的绑定,比如把 TextField 直接绑到 book.title 上。

这套设计的意图很明确:让“谁拥有数据”和“谁能修改数据”在类型系统里显式表达出来。对比 Android 的 ViewModel + StateFlow,思路一致,但 SwiftUI 把它下沉到了属性包装器这一层,写起来更短,也更容易在团队里形成统一约定。

struct CounterView: View {
    @State private var count = 0

    var body: some View {
        VStack(spacing: 16) {
            Text("点击次数:\(count)")
                .font(.title2)
            Button("点我 +1") {
                count += 1
            }
            .buttonStyle(.borderedProminent)
        }
        .padding()
    }
}

4.3 从 ObservableObject 到 @Observable

早期 SwiftUI 用 ObservableObject 配合 @Published,问题是观察粒度是“整个对象”:对象里任何一个 @Published 属性变化,所有观察它的视图都会重新计算 body。@Observable 宏改成了属性级追踪,视图只在自己真正读取过的属性变化时才失效。这个改进的意义和 Compose 的“跳过未变化的可组合项”是同一件事——都在缩小失效范围。

这也是我判断一套声明式框架是否成熟的标准:它有没有能力做细粒度的依赖追踪。粗粒度失效在小页面上看不出问题,一旦页面有几十个状态、上百个组件,就会变成肉眼可见的卡顿。

4.4 iOS 栈的隐性成本

iOS 原生的能力上限最高,动画和手势的跟手程度是其他方案难以完全复刻的,这在内容型、工具型产品上是真实的体验差异。但它有几项绕不开的成本:构建必须用 macOS + Xcode,CI 也要 macOS 机器;证书与描述文件体系复杂,多人协作时容易出错;App Store 审核存在不确定性,一个版本被拒可能耽误一周;如果做虚拟商品,还要处理平台抽成与合规。

还有一个常被忽略的点:iOS 的 UI 规范演进会直接影响你的设计资产。SwiftUI 每次大版本都会带来新的控件风格和交互约定,如果你的产品主打“原生质感”,就得跟着迭代;如果你的产品有强品牌视觉,反而要考虑自绘方案来保证一致性。

5 鸿蒙:ArkTS + ArkUI 的第三条原生路线

5.1 鸿蒙不是“另一个 Android”

把鸿蒙理解成“套壳 Android”是 2021 年的认知,到 HarmonyOS NEXT 这一代已经不成立了。它不再兼容 AOSP,应用以原生方式运行在 ArkCompiler 之上,UI 用 ArkUI 构建,语言是 ArkTS。它的差异化定位不是“再做一遍手机系统”,而是多设备协同:手机、平板、PC、车机、穿戴设备用一套分布式能力打通,这也是华为反复强调“1+8”终端矩阵的原因。

对开发者的直接含义是:鸿蒙不是一个“顺手适配”的目标,而是一套需要重新学习的原生栈。你有 Android 经验,Kotlin 的语法直觉能帮你快速上手 ArkTS,但组件体系、状态管理装饰器、分布式 API 都是新的。

5.2 ArkTS 的约束换来了什么

ArkTS 是在 TypeScript 生态基础上做的扩展,保留了 TS 的基本风格,同时通过规范强化开发期的静态检查与分析,以提升代码健壮性和运行稳定性[3]。它对标准 TS 做了一些限制,比如不允许运行期修改对象布局、限制某些运算符的语义——这些限制看起来是“倒退”,实质是给编译器提供更强的静态信息,让它能做更激进的内联与优化。

并发能力是它相对 TS 的明显增强:提供 TaskPool 和 Worker 两种并发 API,并引入 Sendable 概念支持对象在并发实例之间引用传递,以提升跨实例通信性能[3]。编译侧由 ArkCompiler 统一承担 ArkTS/TS/JS 的编译运行,支持 AOT。ArkUI 官方对性能的描述还包括统一字节码、高效 FFI、引擎极小化、类型优化这几项[4]。

用一句话概括这套设计哲学:用语言层面的约束,换取编译器和运行时的确定性。这和 Rust 的所有权、Kotlin 的空安全是同一种思路,只是约束的落点不同。

@Entry
@Component
struct CounterPage {
  @State count: number = 0

  build() {
    Column({ space: 16 }) {
      Text(`点击次数:${this.count}`)
        .fontSize(24)
        .fontWeight(FontWeight.Medium)
      Button('点我 +1')
        .onClick(() => {
          this.count += 1
        })
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
  }
}

5.3 ArkUI 的声明式与状态管理 V2

ArkUI 是方舟开发框架的声明式 UI 体系,提供“组件—状态—渲染”的全链路能力[4]。它的状态管理经过了一轮重要升级:V2 在 V1 的基础上引入了深度观察和属性级更新[5]。

V2 的装饰器是一套完整的语义分工:@ComponentV2 标记可使用新装饰器的组件;@Local 表示组件内部状态,不能被外部初始化;@Param 表示组件输入,可由外部初始化并同步;@Once 与 @Param 搭配,表示只在初始化时同步一次;@Event 表示组件向外输出;@Monitor 用于对状态变量做深度监听;@Provider/@Consumer 用于跨层级双向同步;@Computed 声明计算属性,只在依赖变化时计算一次,用来解决同一属性被 UI 多次读取导致的重复计算[5]。配合 @ObservedV2 与 @Trace,可以对类的属性做深度观测[5]。实际迁移中最容易踩坑的是 @Param 与 @Local 的配合:@Param 在子组件内不可写,若要让子组件本地可写、同时保留父组件后续更新的通知能力,需要借助 @Monitor 把新值覆写给本地变量[19]。

这套体系和 Compose、SwiftUI 的演进方向高度一致:从“组件级失效”走向“属性级失效”,从“手动通知”走向“依赖追踪”。区别在于 ArkUI 用装饰器把输入、输出、监听、跨层同步都显式命名了,约定更硬,学习成本也更高。

5.4 生态窗口期与真实风险

鸿蒙现在的状态很像 2012 年的 Android:系统层已经跑通,头部应用基本到位,但细分赛道的供给还远远不够。对中小开发者来说,这意味着竞争密度低、获客成本低、平台还有流量扶持;对工具型产品来说,这意味着“在鸿蒙上做第一个”的红利仍然存在。

风险同样明确。第一是生态规模,10 万量级的原生应用对比百万量级,长尾场景的 SDK 覆盖不全。第二是 API 迭代速度,系统版本节奏快,部分能力仍在演进,做长期项目要预留适配时间。第三是人才供给,会 ArkTS 的工程师在招聘市场上仍然是少数,团队要准备好内部培养。第四是全球化,鸿蒙目前的主战场在国内,如果你的产品要主打海外,它撑不起主力栈的位置。

6 跨平台:三条技术路线,三种妥协

6.1 Flutter:把渲染权收归自己

Flutter 的架构分三层:Embedder 负责对接平台(窗口、输入、线程),Engine 主要是 C++ 实现,负责光栅化合成场景,并通过 dart:ui 把底层能力暴露给 Dart 层,Framework 层则是 Dart 写的响应式框架,包含渲染、Widgets、Material/Cupertino 等库[7]。

它的渲染模型有一个关键设计:三棵树。Widget 是不可变的配置描述,Element 是 Widget 与渲染对象之间的胶水、承载生命周期,RenderObject 负责真正的布局、绘制和命中测试。官方文档特别解释了为什么要把 Element 树和 RenderObject 树分开:布局变化时只需要遍历相关的布局子树,而由于组合的存在,Element 树通常有大量额外节点需要跳过[8]。这个设计让 Flutter 在“高度组合”的 Widget 体系下仍然能保持布局效率。

渲染后端是 Flutter 近两年最大的变化。Impeller 的核心思路是把 shader 编译从运行时搬到构建时:它在引擎构建阶段就预编译了一小组更简单的 shader,并预先构建所有 pipeline state object,由引擎自己显式管理缓存[6]。这样做的直接收益是消除了首帧的 shader 编译卡顿——那种“第一次播放某个动画时突然掉帧”的现象。Impeller 使用 Metal(iOS/macOS)和 Vulkan(Android)这类现代图形 API,但不强绑定某一个后端[6]。从 3.27 版本起,Impeller 已经是 iOS 和 Android API 29+ 的默认渲染引擎,Web 端目前仍在使用 Skia[6][17]。

有一个第三方测试的对比数据值得一提:在重负载场景下,Impeller 的帧光栅化时间比 Skia 低约 50%[6]。这个数字来自独立测试而非官方承诺,引用时最好标明口径,但方向上可以确认——预编译管线确实把不确定性换成了确定性。

6.2 React Native:新架构把“桥”拆了

React Native 的旧架构有一个著名的瓶颈:JavaScript 线程和原生线程之间通过 bridge 通信,消息要序列化成 JSON 异步传递。这意味着高频交互(比如手势跟随、滚动同步)会被通信延迟拖慢,复杂动画容易掉帧。

新架构从两个方向拆掉了这个瓶颈。渲染侧是 Fabric,它把布局计算放到 C++ 层统一处理,支持 React 18/19 的并发渲染能力,并通过同步的 mount 路径与原生手势系统更紧密地集成。模块侧是 TurboModules,基于 JSI 直接调用原生代码,取代了 bridge 的 JSON 序列化;同时要求用 Flow 或 TypeScript 写 spec,由 codegen 生成两端一致的类型化接口,模块支持懒加载以加快启动[9]。

把这些拼起来看,新架构的本质是把“跨语言调用的成本”从序列化降到了函数调用级别,并在编译期就把类型对齐了。2026 年 10 月发布的 0.88 版本已经在新架构上继续迭代,包括为 Java TurboModules 增加 ArrayBuffer 直传、Web 端事件分发等改进[18]。这也说明一个事实:RN 的“新架构”已经不是实验特性,而是默认路径。

RN 的优势随之变成了生态和人力:npm 生态的体量摆在那里,前端工程师转移动端的门槛是所有方案里最低的,热更新与灰度能力成熟。它的短板是极端场景——重度自定义绘制、复杂手势与动画、对帧时间极其敏感的场景,仍然需要写原生模块兜底。

6.3 Kotlin Multiplatform:共享逻辑,不共享审美

KMP 的定位和前面两个都不同。它不试图统一 UI,而是让你按需共享:可以只共享一个孤立模块(比如网络层或校验规则),也可以共享全部业务逻辑而保留原生 UI,还可以用 Compose Multiplatform 共享到 100% 的代码[10]。官方把这个梯度讲得很清楚,并且明确说明 Compose Multiplatform 在 Android、iOS、桌面端已经 Stable,Web(Wasm)还在 Beta[10]。

它的说服力主要来自两处。一是真实的生产采用:Google、Duolingo、Forbes、Philips、McDonald’s、Bolt、H&M、百度、快手、B 站都在用 KMP[10]。二是可量化的组织收益:在 2024 年第二季度的 KMP 调查中,55% 的用户报告协作改善,65% 的团队报告性能与质量提升[10]。这两个数字对技术选型的意义在于,KMP 的价值不只是“少写代码”,而是“让两端的行为保持一致”,减少的是沟通成本和线上不一致的 bug。

代价也很清楚:KMP 的共享层需要处理两端差异(比如线程模型、内存模型、平台 API 差异),Gradle 配置的学习曲线不低,而且它天然要求团队里有人同时懂 Kotlin 和 iOS 侧的集成。它不是“零成本跨平台”,而是“把成本从重复编码转移到了架构设计”。

6.4 三者的关键差异

维度FlutterReact NativeKotlin Multiplatform
共享范围UI + 逻辑UI 描述 + 逻辑逻辑(UI 可选)
渲染方式自绘引擎(Impeller)映射原生控件各端原生渲染
语言DartTypeScript / JSKotlin
与原生一致性高(两端一致,非系统控件)中(控件原生,行为受 JS 层影响)最高(UI 完全原生)
首帧与包体需初始化引擎,包体偏大中等接近原生
上手门槛中(需学 Dart 与 Widget 体系)低(前端背景可直接上手)高(需懂 Gradle 与双端集成)
最适合视觉一致性优先、多端同构Web 资产复用、快速迭代长期维护、双端体验都要原生
主要风险系统级控件适配、包体极端性能场景需原生兜底配置复杂度、人才稀缺

7 定量对比:把“性能好”变成可计算的东西

7.1 帧预算与丢帧率

讨论移动端性能,第一件事是把“流畅”换算成时间。屏幕刷新率决定每帧的时间预算:

T f r a m e = 1000 f r e f r e s h  ms T_{frame} = \frac{1000}{f_{refresh}}\ \text{ms} Tframe​=frefresh​1000​ ms

60Hz 时是 16.67 毫秒,90Hz 是 11.11 毫秒,120Hz 只有 8.33 毫秒。所有渲染工作——包括 JS 逻辑、布局、绘制、GPU 提交——都必须在这个预算内完成,超出就会错过一次 vsync,用户看到的就是一次掉帧。

丢帧率可以定义为:

J = N m i s s N t o t a l × 100 % J = \frac{N_{miss}}{N_{total}} \times 100\% J=Ntotal​Nmiss​​×100%

其中 N t o t a l N_{total} Ntotal​ 是统计窗口内的总帧数, N m i s s N_{miss} Nmiss​ 是渲染时间超过 T f r a m e T_{frame} Tframe​ 的帧数。这个指标比平均帧率更有意义:平均 58fps 听起来不错,但如果它是“大部分帧 60fps、每隔几秒卡一下”造成的,主观体验会明显差于“稳定 55fps”。所以真实项目里我会同时看 p95 帧时间和 J,而不是只看平均数。

对 120Hz 设备,这个约束会陡然收紧:原本在 60Hz 下“刚好够用”的 15 毫秒逻辑,在 120Hz 下直接超预算一倍。这就是为什么高端机上跨平台框架的差异更容易被感知——预算越小,容错空间越小。

7.2 实证研究给出的数字

2026 年的一篇 arXiv 实证研究用同一套功能在原生、KMP、Flutter、React Native 上各实现一遍,每套方案跑 2000 次、共 16000 次包装层运行,得到了相对可比的结果:以原生为基准,KMP 的七操作客户端小计在 iOS 上高出 6.1%、Android 上高出 11.4%;Flutter 高出 46.9% 与 241.7%;React Native 高出 92.4% 与 169.0%[13]。

这组数字里最值得注意的不是绝对值,而是两个结构性事实。第一,KMP 与原生几乎同级,因为它共享的是逻辑,渲染仍然走原生。第二,Flutter 在 Android 上的相对差距远大于 iOS,这与 Impeller 的后端差异、设备 GPU 能力分布都有关系——同一个框架在不同平台上的表现并不对称。

方案iOS 相对原生Android 相对原生差异来源
KMP(共享逻辑 + 原生 UI)+6.1%+11.4%跨语言调用与共享层封装
Flutter+46.9%+241.7%自绘引擎与平台后端差异
React Native+92.4%+169.0%JS 层调度与原生模块往返

需要说明的是,这类基准测试用的是“七操作客户端小计”,属于特定工作负载下的合成指标,不能直接等同于真实 App 的体验。它的价值在于给出量级判断:如果你做的是重计算、重列表、重动画的产品,KMP 与原生更稳;如果你做的是表单、内容浏览、运营页,跨平台方案的差距在日常使用中往往感知不到。

7.3 包体与冷启动

2025 年的一份横向测试报告给出了更贴近用户感知的数据:在简单/中等/复杂三档应用上,原生 iOS 的包体分别是 8.2MB、15.7MB、28.3MB,原生 Android 是 7.9MB、16.2MB、27.1MB,React Native 是 12.3MB、22.8MB、38.5MB;冷启动时间上,原生 iOS 为 520 毫秒、原生 Android 为 650 毫秒、React Native 为 920 毫秒;复杂界面下的帧率,原生 iOS 55fps、原生 Android 53fps、React Native 42fps、Flutter 48fps[14]。

指标原生 iOS原生 AndroidReact NativeFlutter
简单应用包体8.2 MB7.9 MB12.3 MB—
复杂应用包体28.3 MB27.1 MB38.5 MB—
冷启动520 ms650 ms920 ms—
复杂界面帧率55 fps53 fps42 fps48 fps

表中 Flutter 一列除帧率外留空,是因为该报告没有给出 Flutter 的包体与冷启动实测值,为避免混用不同来源的数据,这里不做填补。对这几个数字,我的解读是:包体和冷启动的差距主要来自“运行时初始化”,跨平台框架都需要先把自己的引擎或 JS 运行时拉起来,这部分是固定成本,不随业务复杂度线性增长。所以小应用用跨平台方案,包体劣势最明显;大应用反而摊薄了。这也是为什么很多团队的做法是“主工程用跨平台,启动页和首屏用原生”。

7.4 开发成本与复用率模型

跨平台方案的经济性可以用一个很朴素的模型描述。假设一个功能双端各写一遍的成本是 E f u l l E_{full} Efull​,双原生总成本为:

E n a t i v e = 2 E f u l l E_{native} = 2E_{full} Enative​=2Efull​

采用跨平台方案后,成本变为共享部分加两端适配:

E c r o s s = E s h a r e d + E a n d r o i d + E i o s E_{cross} = E_{shared} + E_{android} + E_{ios} Ecross​=Eshared​+Eandroid​+Eios​

节省率为:

R = 1 − E c r o s s E n a t i v e = 1 − E s h a r e d + E a n d r o i d + E i o s 2 E f u l l R = 1 - \frac{E_{cross}}{E_{native}} = 1 - \frac{E_{shared} + E_{android} + E_{ios}}{2E_{full}} R=1−Enative​Ecross​​=1−2Efull​Eshared​+Eandroid​+Eios​​

这个式子的关键在于 E a n d r o i d E_{android} Eandroid​ 与 E i o s E_{ios} Eios​ 不会归零。平台适配、原生能力接入、双端 UI 差异、审核合规,这些成本永远存在。真实项目里 R R R 通常落在 20% 到 40% 之间,而不是宣传里的 70%。当你看到“一套代码跑五端,人力省一半”的说法时,可以用这个模型自己估一遍:如果你的产品有大量平台特有能力(推送、支付、地图、相机、蓝牙), E a n d r o i d + E i o s E_{android}+E_{ios} Eandroid​+Eios​ 会显著上升,节省率随之下降。

把端数也纳入考虑会更清楚。设支持的端数为 n n n,纯原生的总成本随端数线性增长:

C n a t i v e ( n ) = n ⋅ c p C_{native}(n) = n \cdot c_p Cnative​(n)=n⋅cp​

跨平台方案是“一份共享加 n n n 份适配”:

C c r o s s ( n ) = c s + n ⋅ c p ′ C_{cross}(n) = c_s + n \cdot c_p' Ccross​(n)=cs​+n⋅cp′​

其中 c s c_s cs​ 是共享层建设成本, c p ′ c_p' cp′​ 是单端适配成本且 c p ′ < c p c_p' < c_p cp′​<cp​。两者的交点出现在:

n ∗ = c s c p − c p ′ n^{*} = \frac{c_s}{c_p - c_p'} n∗=cp​−cp′​cs​​

当端数超过 n ∗ n^{*} n∗ 时,跨平台方案才开始划算。对多数团队来说,这个 n ∗ n^{*} n∗ 大约在 2 到 3 之间——也就是说,只做双端时跨平台的收益并不夸张,做到三端(加 Web、桌面或鸿蒙)时优势才明显。这个结论和很多人的直觉相反,但它解释了为什么“跨平台”在大厂的多端战略里更受欢迎,而在小团队的双端项目里经常被吐槽“还不如各写各的”。

8 选型模型:同一份评分,三种最优解

8.1 六维评分的设计

前面讲的都是定性判断,落到具体决策时还是需要一个可比较的量化框架。我设计了一个六维评分模型,维度分别是原生性能、跨端复用、生态成熟度、包体与启动、上手与招聘、合规可控。每个维度 1 到 10 分,分值基于各家官方文档与前面引用的实测数据做相对标定,不是精确测量。

选这六个维度,是因为它们对应六类真实约束:性能决定你能不能做重交互产品;复用决定你的人力和迭代速度;生态决定你遇到问题有没有现成答案;包体与启动决定获客成本(尤其在新兴市场);上手与招聘决定团队组建周期;合规可控决定你能不能长期稳定分发,这一维对国内政企类项目权重极高。模型里 iOS 该项给 4 分,衡量的是数据跨境与审核政策的不确定性对项目的约束强度,不代表 iOS 本身的合规质量有问题——对纯海外产品,这一维的权重可以调到很低。

权重则按业务场景给。初创小工具团队最缺的是时间和人手,所以“上手与招聘”“生态成熟度”权重最高;内容电商类产品对流畅度和生态完整度敏感,性能与生态权重上调;政企与国产化项目把“合规可控”放到接近一半的权重。同一份能力评分,权重一变,最优解就会移动——这正是选型不是单选题的数学表达。

8.2 Python 实现与运行结果

下面这段代码在云主机上跑通,环境是 Python 3.12.11 加 matplotlib 3.11.0,中文字体用 Noto Sans CJK。它会打印两张表,并输出一张热力图和一张三场景排名图。文中展示的配图用的是同一份数据、同一套计算逻辑,只在配色、标题、色标等视觉细节上做了加强,你跑上面这段代码得到的是结构一致的简版图。

# -*- coding: utf-8 -*-
"""移动端技术栈选型:可加权评分模型(完整可运行版)"""
import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
from matplotlib.colors import LinearSegmentedColormap

CJK = "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc"
CJKB = "/usr/share/fonts/opentype/noto/NotoSansCJK-Bold.ttc"
F, FB = FontProperties(fname=CJK), FontProperties(fname=CJKB)
plt.rcParams["axes.unicode_minus"] = False

stacks = ["Android 原生", "iOS 原生", "鸿蒙原生", "Flutter", "React Native", "KMP + 原生 UI"]
dims = ["原生性能", "跨端复用", "生态成熟度", "包体与启动", "上手与招聘", "合规可控"]

scores = np.array([
    [9, 3, 10, 8, 7, 6],
    [10, 2, 9, 9, 6, 4],
    [9, 4, 5, 8, 5, 9],
    [7, 9, 8, 5, 6, 6],
    [6, 8, 9, 6, 8, 6],
    [9, 6, 6, 8, 4, 6],
], dtype=float)

scenarios = {
    "A 初创小工具": np.array([0.10, 0.20, 0.25, 0.10, 0.25, 0.10]),
    "B 内容电商":   np.array([0.30, 0.15, 0.25, 0.10, 0.10, 0.10]),
    "C 政企国产化": np.array([0.15, 0.10, 0.10, 0.10, 0.10, 0.45]),
}
result = {k: (scores * w).sum(axis=1) / 10 * 100 for k, w in scenarios.items()}

def pad(s, width):
    """中英混排按显示宽度补空格:CJK 字符按 2 列计"""
    disp = sum(2 if ord(ch) > 0x2E80 else 1 for ch in s)
    return s + " " * max(0, width - disp)

print("=" * 84)
print("移动端技术栈选型评分  ·  六方案 / 六维度 / 三场景".center(76))
print("=" * 84)
print(pad("方案", 16) + "".join(pad(d, 12) for d in dims))
print("-" * 84)
for i, s in enumerate(stacks):
    print(pad(s, 16) + "".join(pad(f"{scores[i, j]:>3.0f}", 12) for j in range(6)))

print("\n【综合得分 · 百分制】同一份评分,权重不同则最优解不同")
print("-" * 84)
print(pad("方案", 16) + "".join(pad(k, 16) for k in scenarios))
print("-" * 84)
for i, s in enumerate(stacks):
    print(pad(s, 16) + "".join(pad(f"{result[k][i]:.1f}", 16) for k in result))
for k, v in result.items():
    print(f"▶ {k} 的最优方案:{stacks[int(np.argmax(v))]}({v.max():.1f} 分)")

# 热力图
cmap = LinearSegmentedColormap.from_list("score", ["#f6f9fc", "#cfe6f5", "#7ec8e3", "#2b90c8", "#0d4f7a"])
fig, ax = plt.subplots(figsize=(10.2, 5.2), dpi=200)
im = ax.imshow(scores, cmap=cmap, vmin=0, vmax=10, aspect="auto")
ax.set_xticks(range(6)); ax.set_xticklabels(dims, fontproperties=F)
ax.set_yticks(range(6)); ax.set_yticklabels(stacks, fontproperties=F)
ax.set_xticks(np.arange(-.5, 6, 1), minor=True)
ax.set_yticks(np.arange(-.5, 6, 1), minor=True)
ax.grid(which="minor", color="white", linewidth=2.4)
for i in range(6):
    for j in range(6):
        ax.text(j, i, f"{scores[i, j]:.0f}", ha="center", va="center",
                fontproperties=FB, color="white" if scores[i, j] >= 7 else "#123a52")
fig.savefig("stack_heatmap.png", bbox_inches="tight", facecolor="white")

# 三场景排名
order = np.argsort(result["A 初创小工具"])[::-1]
fig, axes = plt.subplots(1, 3, figsize=(13.6, 4.6), dpi=200, sharey=True)
for ax, (k, v) in zip(axes, result.items()):
    vals = v[order]
    ax.barh(np.arange(6)[::-1], vals, height=0.62)
    ax.set_yticks(np.arange(6)[::-1])
    ax.set_yticklabels([stacks[i] for i in order], fontproperties=F)
    ax.set_title(k, fontproperties=FB)
fig.savefig("stack_rank.png", bbox_inches="tight", facecolor="white")

运行输出如下:

在这里插入图片描述

把六个维度画成热力图,可以直观看出每套方案的能力形状:Android 是一条“生态极强、复用极弱”的曲线,iOS 是“性能拉满、复用和合规双低”,鸿蒙在“合规可控”上独高,Flutter 与 RN 在“跨端复用”上突出但“包体与启动”偏弱,KMP 则是一条相对均衡的曲线。

在这里插入图片描述

换三套权重,排名立刻重排:

在这里插入图片描述

8.3 结果解读

三个场景的最优解分别是 React Native(76.5 分)、Android 原生(77.5 分)、鸿蒙原生(76.0 分)。这个结果初看有点反直觉——Android 原生在“内容电商”场景赢了,而很多人会猜 Flutter。原因在权重:内容电商对流畅度、生态完整度、平台能力(支付、推送、分享、深链)要求都高,而 Flutter 在这三项上并不占优,它的强项“跨端复用”在这个场景里权重只有 0.15。

初创小工具场景里 RN 领先,胜在“上手与招聘”和“生态成熟度”两项权重合计 0.50。一个人的团队,能用熟悉的 TypeScript 快速上线、遇到问题能在 npm 里找到现成方案,比多省 20 兆包体重要得多。

政企国产化场景里鸿蒙赢,几乎完全由“合规可控”这一维的 0.45 权重决定。这也提示一个方法论的要点:当某个约束是一票否决型(比如必须支持国产化环境),不要试图用加权平均去平衡它,直接把它作为前置条件筛掉不满足的方案,再做加权。加权模型适合在“都满足硬约束”的候选集里排序,不适合用来掩盖硬约束。

9 决策:五类场景的落地路径

9.1 场景矩阵

把前面的分析收敛成一张可执行的表。这里的“推荐”是默认解,不是唯一解,具体项目还要考虑团队既有资产。

场景典型特征首选方案备选关键理由
单人开发的小工具周期短、预算低、功能单一React NativeFlutter上手快、生态全、可复用 Web 技能
内容/电商类 App重列表、重图片、要接支付推送Android 原生 + iOS 原生Flutter平台能力完整、生态方案成熟
重交互/游戏化应用复杂动画、自定义绘制、帧率敏感原生(或 Flutter 自绘)Unity 等引擎帧预算最紧,需要直接控制渲染
已有 Web/React 资产团队是前端背景、要快速多端React NativeFlutter组件与状态管理可直接迁移
政企/国产化项目要求国产系统适配、数据合规鸿蒙原生(+ Android)KMP合规可控是硬约束
大厂多端并行端数多、长期维护、双端体验都要原生KMP + 各端原生 UIFlutter共享逻辑、保留原生体验、边际成本低

9.2 决策流程图

如果只想要一个可以照着走的判断路径,下面这张图把它压缩成了五个问题。注意它的顺序:先问硬约束(合规、平台覆盖),再问团队资产,最后才问体验偏好。顺序错了,很容易被“我喜欢某个框架”带着走。

是

否

是

否

视觉一致性

原生控件

愿意

不愿意

是否存在硬约束:
必须覆盖鸿蒙原生 或 国产化合规

ArkTS + ArkUI 原生开发
必要时保留 Android 版本

团队是否已有
成熟的 Web 或 React 资产

React Native 新架构
Fabric + TurboModules

视觉一致性 与 原生控件
哪个优先

Flutter + Impeller

是否愿意长期维护
两套 UI 代码

Kotlin + Swift 双原生

KMP 共享逻辑
UI 各端原生

9.3 混合方案:别做二元选择

真实项目里最普遍的其实不是“选一个”,而是“选一个主栈 + 若干补丁”。这三种组合方式我都用过,效果稳定。

第一种是 Flutter 做主壳、原生做重能力。列表、详情、表单这些页面用 Flutter 写,相机、蓝牙、音视频处理、复杂地图这些模块写原生插件。好处是 80% 的页面享受跨平台效率,20% 的重模块享受原生性能。坏处是插件的版本维护成本,尤其是当 Flutter 大版本升级时。

第二种是 RN 增量接入。老项目不动,新页面用 RN 写,通过原生容器承载。这种做法在存量 App 上最实用,风险最低,缺点是包体增加、双栈并存期间团队要同时维护两套工具链。

第三种是 KMP 共享 + 各端原生 UI。这种组合的性价比在长期项目里最高:网络层、数据模型、校验规则、埋点协议这些“两端必须一致”的部分共享,UI 各写各的。代价是 Gradle 配置和团队协作流程要重新设计,前期投入不小。

9.4 团队与招聘的现实约束

技术选型报告里最容易漏掉的一节是“人从哪来”。Kotlin 和 Swift 的供给相对充足,校招和社招都能找到;Dart 的供给集中在有 Flutter 经验的团队,跨栈招聘时需要考察真实的工程能力而不是“用过多久”;ArkTS 的供给目前仍然稀缺,多数人是内部转岗培养出来的;React Native 的供给最宽,前端工程师经过几周就能上手,但“能写”和“能解决性能问题”之间有明显分层。

所以一个务实的判断是:选型的上限由技术决定,下限由人决定。一个三人团队选了一个需要五人才能维护好的架构,最后一定会在排期上还债。反过来,一个成熟团队用一套“不那么先进”的栈,往往能靠工程能力把体验做到很好。

10 学习路径与长期主义

10.1 12 周入门路线

不管你最终选哪条栈,前 12 周的知识结构其实高度相似:语言基础、声明式 UI 与状态管理、工程能力(网络/存储/架构)、完整项目与上架。差别只在具体的语法和组件名。下面这张甘特图是我给团队新人的默认节奏,每周投入 10 到 15 小时。

11-29 12-06 12-13 12-20 12-27 01-03 01-10 01-17 01-24 01-31 02-07 02-14 Kotlin 或 Dart 语法与工程搭建 声明式 UI 与状态管理 网络 存储 架构与性能基础 完整项目 打包 上架与复盘 语言与工具 UI 范式 工程能力 实战 移动开发 12 周入门路线

四周一个阶段,每个阶段都要有一个可运行的小产出:第一阶段产出一个能跑通导航和列表的空壳;第二阶段产出一个带表单校验、状态持久化的页面;第三阶段给这个应用接上真实接口、加上缓存和错误处理;第四阶段做打包、签名、上架材料,并写一份性能报告。没有产出的学习,三周之后基本会忘光。

10.2 技术栈的生命周期风险

技术栈是有生命周期的,这一点在选型时必须计入。判断一套栈的长期风险,我会看四个信号:官方是否还在投入(版本节奏、破坏性变更的频率)、社区是否还在产出(新库、新文章、新讨论)、企业是否还在招聘(JD 数量与薪资趋势)、以及它是否绑定了某个单一公司的战略。

按这四个信号看,Android 与 iOS 原生是低风险项,它们由平台方自己维护,生命周期与操作系统一致。Flutter 与 RN 属于中等风险,它们依赖 Google 与 Meta 的持续投入,历史上都经历过“战略调整”的传言,但目前的版本节奏仍然稳定。KMP 的风险略高一点,因为它依赖 JetBrains 的商业化,不过它有“渐进式采用”的优势——你可以只共享一小块,风险可控。鸿蒙的风险来自生态规模,但它的政策确定性很高,在国内市场的长期存在是确定的。

一个实用的对冲策略是:把业务逻辑与框架解耦。状态模型、校验规则、数据转换这些用纯语言写(Kotlin、Swift、TypeScript 都行),UI 和平台能力才依赖框架。这样即使将来换栈,迁移成本也集中在 UI 层,而不是整个项目重写。

10.3 可迁移的能力结构

最后想说一个反直觉的观点:技术栈的选择没有学习能力的选择重要。四套栈在架构层面高度同构——都是声明式 UI、单向数据流、状态提升、依赖注入、模块化。你在 Compose 里学会的“状态下沉、缩小重组范围”,在 SwiftUI 里就是“缩小观察范围”,在 ArkUI 里就是“用 @Computed 减少重复计算”,在 Flutter 里就是“用 const 与 Selector 控制重建”。同一套思维,换四个名字。

真正稀缺的能力是三样:把需求拆成状态模型的能力、用性能数据定位瓶颈的能力、以及在没有现成方案时自己写出来的能力。这三样东西不随框架更迭而贬值,反而会随着你换栈的次数增值。

11 结语:选型是约束求解,不是排行榜

回到开头那个问题。如果你现在要做一个 App,我给你一个可以直接执行的三步法。

第一步,列出硬约束:必须覆盖哪些平台?有没有国产化或合规要求?能不能接受包体增加 20 兆?能不能等一周的审核?这些问题的答案会直接筛掉一半候选。

第二步,估算你的成本结构:团队现有技能是什么?需要几端?平台特有能力用得多不多?把数字代进 R R R 和 n ∗ n^{*} n∗ 那两个公式,你会得到一个大概的节省率区间,而不是一句“跨平台省人力”。

第三步,在剩下的候选里做加权排序,并且明确每个维度的权重来自哪里——是产品要求、团队现状,还是你个人的偏好。把偏好诚实地写进权重,比假装客观更有用。

技术栈会继续变化。Compose 会成为唯一选择,SwiftUI 会继续吞掉 UIKit 的场景,ArkUI 的状态管理会补齐 V2 的 GAP,Impeller 会覆盖更多后端,RN 的新架构会彻底成为默认。但底层那套“状态如何变成像素”的逻辑不会变,理解了它,你就不需要每年重新学一遍移动开发。

参考资料

[1] Android Developers. Compose 编程思想(声明性编程范式、重组). https://developer.android.com/develop/ui/compose/mental-model?hl=zh-cn

[2] Android Developers. Jetpack Compose 的阶段(组合、布局、绘制). https://developer.android.com/develop/ui/compose/phases?hl=zh-cn

[3] 华为开发者联盟. ArkTS 简介(基于 TypeScript 的扩展、TaskPool/Worker/Sendable、ArkCompiler). https://developer.huawei.com/consumer/cn/doc/harmonyos-guides-V14/arkts-overview-V14

[4] 华为开发者联盟. UI 开发(ArkTS 声明式开发范式)概述(统一字节码、高效 FFI、AOT、引擎极小化). https://developer.huawei.com/consumer/cn/doc/harmonyos-guides-V5/arkts-ui-development-overview-V5

[5] 华为开发者联盟. 状态管理概述(V2 装饰器体系与属性级更新). https://developer.huawei.com/consumer/cn/doc/harmonyos-guides-V13/arkts-state-management-overview-V13

[6] Flutter. Impeller rendering engine(构建期预编译 shader、Metal/Vulkan、3.27 起默认、重载场景光栅化对比). https://docs.flutter.dev/perf/impeller

[7] Flutter. Architectural overview(Embedder / Engine / Framework 三层与 dart:ui). https://docs.flutter.dev/resources/architectural-overview

[8] Flutter. Inside Flutter(Widget / Element / RenderObject 三棵树与分离设计). https://docs.flutter.dev/resources/inside-flutter

[9] React Native. 新架构的原生模块(Turbo Module)(Fabric、JSI、codegen、懒加载). https://reactnative.cn/docs/new-architecture-turbo-modules

[10] JetBrains. What is Kotlin Multiplatform(共享梯度、Compose Multiplatform 稳定性、企业采用与调查数据). https://kotlinlang.org/docs/multiplatform/kmp-overview.html

[11] StatCounter. Mobile Operating System Market Share Worldwide(2026 年 10 月,Android 72.36%、iOS 27.61%). https://gs.statcounter.com/os-market-share/mobile/worldwide

[12] 财新周刊. 华为再攀顶(引用 Counterpoint Research:2026Q1 中国鸿蒙 19%、2026Q2 全球 5%/中国 24%;原生应用 10 万+、可获取应用 40 万+). https://weekly.caixin.com/2026-10-31/102499337.html

[13] arXiv:2609.21544. Cross-Platform vs Native Mobile Development: An Empirical Study of Software Quality Trade-offs(KMP +6.1%/+11.4%、Flutter +46.9%/+241.7%、RN +92.4%/+169.0%). https://arxiv.org/html/2609.21544

[14] IRJMETS. Cross-Platform Mobile Development: React Native vs. Flutter vs. Native Approaches(包体、冷启动、帧率实测表,2025). https://www.irjmets.com/uploadedfiles/paper/issue_3_march_2025/71321/final/fin_irjmets1743710232.pdf

[15] Apple Developer. 在 App 中管理模型数据(@State / @Binding / @Observable / @Environment 的职责划分). https://developer.apple.com/cn/documentation/swiftui/managing-model-data-in-your-app/

[16] Apple Developer. State()(状态所有权与 Binding 传递). https://developer.apple.com/cn/documentation/swiftui/state()

[17] Flutter. FAQ 与 Glossary(Impeller 的定位、后端与平台覆盖). https://docs.flutter.dev/resources/faq

[18] React Native. React Native 0.88 发布说明(ArrayBuffer 直传、Web 端事件分发、新架构默认). https://reactnative.dev/blog/2026/10/19/react-native-0.88

[19] 华为开发者联盟. 状态管理 V1 向 V2 迁移:组件内状态变量(@Param / @Local / @Monitor 的配合). https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-v1-v2-migration-inner-component

Logo

作为“人工智能6S店”的官方数字引擎,为AI开发者与企业提供一个覆盖软硬件全栈、一站式门户。

更多推荐