Modifier 性能优化

发表于

在前两篇文章中，我们学习了 Modifier 的基础概念和自定义方法。Modifier 为我们提供了强大的定制能力，但是如果使用不当，也可能带来一些性能问题。合理使用 Modifier 对应的渲染性能至关重要。本文将分享一些 Modifier 优化的实践经验，帮助你更好地控制重组开销，避免不必要的绘制，从而提升应用的流畅度。

减少层级嵌套

在使用 Modifier 时，我们经常会遇到多次嵌套的情况，尤其是在自定义 Modifier 时。然而，过多的嵌套会增加布局开销，导致性能下降。因此，我们需要尽量避免不必要的 Modifier 层级。

例如，下面这段代码：

1
2
3
4
5
6
7
kotlin复制代码Box(
    modifier = Modifier
        .background(Color.Red)
        .padding(16.dp)
        .size(100.dp)
        .clip(RoundedCornerShape(8.dp))
)

可以优化为：

1
2
3
4
5
6
7
8
9
kotlin复制代码Box(
    modifier = Modifier
        .size(100.dp)
        .background(
            color = Color.Red,
            shape = RoundedCornerShape(8.dp)
        )
        .padding(16.dp)
)

在优化后的代码中，我们将background和clip合并为一个 Modifier，从而减少了一层嵌套。这种优化方式不仅可以提高性能，还能让代码更加简洁易读。

避免不必要的重组

另一个常见的性能问题是不必要的重组。当 Composable 函数重新计算时，Compose 会尝试复用之前的实例。但若实例被修改了，Compose 就需要重新创建该实例及其子实例，这个过程成为重组（recomposition）。重组开销可能很大，因此我们应该尽量避免不必要的重组。

例如，下面这段代码：

1
2
3
4
5
6
7
8
9
10
kotlin复制代码@Composable
fun MyComponent(text: String) {
    Box(
        modifier = Modifier
            .background(Color.Red)
            .padding(16.dp)
    ) {
        Text(text)
    }
}

在每次重组时，Modifier.background(Color.Red).padding(16.dp)都会被重新创建一次。为了避免这种情况，我们可以使用Modifier.composed来记住 Modifier 实例：

1
2
3
4
5
6
7
8
9
10
11
kotlin复制代码@Composable
fun MyComponent(text: String) {
    val modifier = remember {
        Modifier
            .background(Color.Red)
            .padding(16.dp)
    }
    Box(modifier = modifier) {
        Text(text)
    }
}

通过remember函数，我们可以确保 Modifier 实例只会在初始化时创建一次，后续的重组就可以直接复用该实例，从而避免了不必要的开销。

合理使用 Modifier.lazy

在某些情况下，我们需要根据条件来决定是否应用某个 Modifier。这种情况下，我们可以使用Modifier.lazy来进行条件判断，从而避免不必要的 Modifier 实例创建。

例如，下面这段代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
kotlin复制代码@Composable
fun MyComponent(showBorder: Boolean) {
    Box(
        modifier = Modifier
            .background(Color.Red)
            .padding(16.dp)
            .let {
                if (showBorder) {
                    it.border(
                        width = 2.dp,
                        color = Color.Black
                    )
                } else {
                    it
                }
            }
    ) {
        // ...
    }
}

在这个例子中，只有在showBoreder为 true 时，我们才需要应用borderModifier。如果直接使用上面代码，无论showBorder的值如何，borderModifier 都会被创建。为了优化这种情况，我们可以使用Modifier.lazy:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
kotlin复制代码@Composable
fun MyComponent(showBorder: Boolean) {
    Box(
        modifier = Modifier
            .background(Color.Red)
            .padding(16.dp)
            .lazy {
                if (showBorder) {
                    it.border(
                        width = 2.dp,
                        color = Color.Black
                    )
                } else {
                    it
                }
            }
    ) {
        // ...
    }
}

通过Modifier.lazy，我们将条件判断的代码包装在一个 Lambda 表达式。只有在需要时，这个 Lambda 表达式才会被执行，从而避免了不必要的 Modifier 实例创建。

总得来说，合理使用 Modifier 对于提升应用性能至关重要。通过减少层级嵌套、避免不必要的重组以及合理使用Modifier.lazy，我们可以有效地控制渲染开销，为用户带来流畅的体验。在编写 Compose UI 代码时，请务必牢记这些优化技巧，让你的应用拥有优秀的性能表现。

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%