Compose 中函数引用 vs Lambda：到底该用哪个？

深入理解 viewModel::func 和 { fun() } 的区别及其在 Jetpack Compose 中的影响

前言

在开始阅读之前有一个问题想问问大家是否都了然于胸。请问 viewModel::func 和 { fun() } 这两种写法，除了长得不一样，在 Jetpack Compose 里到底有什么本质区别？

如果上面的问题你都如数家珍，那么你可以跳过本章节。但如果你跟我一样曾经有过这样的困惑：明明两种写法都能跑通，为什么代码审查时总有人说"这里应该用函数引用"呢？那么接下来的内容可能会帮你解开这个疑问。

正篇

第一问：函数引用和 Lambda 到底是什么？

我们先来从最基本的层面认识这两位主角。

函数引用 viewModel::func，通俗意义上的话来说，就是指向一个已经存在的函数的"指针"。它不会创建新的东西，只是说"嘿，我需要用到这个函数"。而 Lambda { fun() } 则是每次都会创建一个新的匿名函数对象。

是不是听起来有点抽象？换种方式来理解：

函数引用就像你家房子的地址 ------ 地址本身不会变
Lambda 就像每次去你家都画一张新的地图 ------ 每次画的都是新的，虽然指向的地方一样

来个简单的例子感受一下：

kotlin 复制代码

@Composable
fun UserScreen(viewModel: UserViewModel) {
    // Lambda 写法
    Button(onClick = { viewModel.onButtonClick() }) {
        Text("Click Me")
    }

    // 函数引用写法
    Button(onClick = viewModel::onButtonClick) {
        Text("Click Me")
    }
}

这时候你可能会想：就这？这不就是语法糖吗？

别急，我们继续往下看。

第二问：在 Compose 中，稳定性的差异有多大？

这个问题很关键，因为 Compose 的重组机制对"稳定性"非常敏感。如果一个参数每次重组都是新对象，Compose 就会认为它不稳定，可能触发额外的重组。

我们来看一段代码：

kotlin 复制代码

@Composable
fun ExampleScreen(viewModel: MyViewModel) {
    var clickCount by remember { mutableStateOf(0) }

    Column {
        // ❌ Lambda 写法
        Button(onClick = { viewModel.handleClick() }) {
            Text("Click Count: $clickCount")
        }

        // ✅ 函数引用写法
        Button(onClick = viewModel::handleClick) {
            Text("Click Count: $clickCount")
        }
    }
}

当 clickCount 变化时，ExampleScreen 会重组。此时：

Lambda 写法 ：每次都会创建一个新的 { viewModel.handleClick() } 对象
函数引用写法 ：viewModel::handleClick 始终指向同一个函数，是稳定的

这有什么影响呢？如果你的 Button 内部还依赖了这个 onClick 参数来做某些判断，Lambda 写法可能导致 Button 内部也跟着不必要的重组。

官方对 stability 的定义非常抽象，换成通俗意义上的话来说：如果一个对象在重组过程中"equals 比较结果不变"，那它就是稳定的。函数引用天然符合这个条件，因为指向的是同一个函数；而 Lambda 每次都是新对象，除非你用 remember 把它缓存起来。

第三问：什么时候必须用 Lambda？

虽然函数引用性能更好，但它有一个致命的弱点：不能灵活传递参数。

举个例子：

kotlin 复制代码

@Composable
fun ItemList(items: List<Item>, viewModel: ItemViewModel) {
    LazyColumn {
        items(items) { item ->
            // ❌ 参数不匹配，编译报错
            Item(item = item, onClick = viewModel::onItemClick)
        }
    }
}

// ViewModel
class ItemViewModel : ViewModel() {
    fun onItemClick(itemId: String) { }
}

为什么不行？因为 viewModel::onItemClick 需要一个 itemId 参数，但 Composable 的 onClick 是一个无参的函数类型 () -> Unit。

这时候只能用 Lambda：

kotlin 复制代码

// ✅ Lambda 可以灵活传递参数
Item(item = item, onClick = { viewModel.onItemClick(item.id) })

不过这里有个小技巧：如果你能调整函数签名，让它直接接收 Item 对象，那就可以用函数引用了：

kotlin 复制代码

class ItemViewModel : ViewModel() {
    // ✅ 改成接收 Item 对象
    fun onItemClick(item: Item) { }
}

// 这样就可以用函数引用了
Item(item = item, onClick = viewModel::onItemClick)

第四问：在 Now In Android 里是怎么做的？

我们来看看 Google 官方的 Now In Android 项目是怎么处理这个问题的。

在 forYouScreen 中，你会发现很多地方都用了函数引用：

kotlin 复制代码

// Now In Android 的实际代码
@Composable
fun TopicCard(
    topic: FollowableTopic,
    onTopicClick: (String) -> Unit,
) {
    Card(
        onClick = { onTopicClick(topic.topic.id) },
    ) {
        // ...
    }
}

这里用的是 Lambda，因为需要传递 topic.topic.id。但在调用 TopicCard 的地方：

kotlin 复制代码

TopicCard(
    topic = topic,
    // ViewModel 里的函数签名正好匹配
    onTopicClick = viewModel::followTopic,
)

因为 viewModel::followTopic 的签名是 (String) -> Unit，和 onTopicClick 的类型定义完全一致，所以这里用了函数引用。

总的来说，Now In Android 的原则很简单：能匹配就用函数引用，不能匹配就用 Lambda。

第五问：如何平衡性能和灵活性？

看到这里你会不会发出感叹：函数引用性能好但用起来麻烦，Lambda 灵活但有性能问题，这怎么选？

一般来说我们遵循一个简单原则：

参数能匹配 → 优先用函数引用
需要传参数 → 用 Lambda
Lambda 有复杂逻辑 → 考虑 remember 缓存

对于第三点，举个例子：

kotlin 复制代码

@Composable
fun ComplexScreen(viewModel: ComplexViewModel) {
    // 如果 Lambda 有复杂逻辑或依赖其他状态，用 remember 缓存
    val handler = remember(viewModel) {
        {
            viewModel.handleAction()
            analytics.logEvent("button_clicked")
            // 其他逻辑...
        }
    }

    Button(onClick = handler) {
        Text("Click Me")
    }
}

这样既保持了 Lambda 的灵活性，又避免了每次重组都创建新对象。

Now In Android 中的实践

最后我们再看一个 Now In Android 的真实案例。在 interestsScreen 中，有一个处理兴趣选择的功能：

kotlin 复制代码

@Composable
private fun InterestsTabContent(
    selectedTab: InterestTab,
    selectedTopics: Set<String>,
    onTopicSelect: (String, Boolean) -> Unit,
) {
    LazyColumn {
        items(selectedTab.topics, key = { it.id }) { topic ->
            InterestItem(
                name = topic.name,
                selected = selectedTopics.contains(topic.id),
                onClick = { onTopicSelect(topic.id, !selectedTopics.contains(topic.id)) },
            )
        }
    }
}

这里 Lambda 的作用是捕获当前的 topic.id，然后传递给 onTopicSelect。而在调用这个 Composable 的地方：

kotlin 复制代码

InterestsTabContent(
    selectedTab = selectedTab,
    selectedTopics = selectedTopics,
    // 函数引用，签名匹配
    onTopicSelect = viewModel::updateTopicSelection,
)

这种组合很常见：UI 层用 Lambda 处理参数传递，ViewModel 层用函数引用提升性能。

结尾

这篇文章我们探讨了函数引用和 Lambda 在 Compose 中的本质区别。简单总结一下：函数引用就像稳重的老朋友，虽然不灵活但可靠；Lambda 就像机灵的新同事，啥都能干但有时候会手忙脚乱。

实际项目中，能匹配就函数引用，不能匹配就 Lambda，复杂场景用 remember 缓存，基本就够用了。

The end，本章完 😄