2024年鸿蒙最新Jetpack Compose 入门难点解疑_compose附带效应(2)，头条面试一定会有作业吗

本文链接：https://blog.csdn.net/2401_84862348/article/details/138639104

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

使用同一参数多次调用此函数时，它的行为方式相同，并且它不使用其他值，如全局变量或对 random() 的调用。
此函数描述界面而没有任何副作用，如修改属性或全局变量。

这里出现了一个概念：幂等，也许有人第一次接触到这个词，我提供一下关于这个词的解释：

在编程中，"幂等"是指一个操作或函数，无论执行多少次，结果都是相同的。换句话说，对于给定的输入，多次执行相同的操作或函数不会产生额外的影响或副作用。

假设你的函数改变了外部的变量或者访问了外部的变量，那它就不是幂等的，例如下面的函数：

var a:Int=1

fun nonIdempotent(){
a++
}

很显然，每次调用nonIdempotent()方法的结果都是不一样的，这种就是"不幂等"的函数。

相同的，我们再来看看幂等的函数：

fun idempotent(a:Int):Int{
return a+1
}

如果我传入的a不一样，每次返回的结果都不一样，还算幂等吗？当然算，我们说幂等的前提是保持参数一致，如果参数一致的情况下，结果永远都是a+1，因此方法是幂等的。

下面再看一个函数，请问这是幂等的吗:

fun idempotentOrNonIdempotent(a:Int):Int{
print(“${a+1}”)
return a+1
}

也许你会觉得这是幂等的，因为结果是一致的，但是这个函数却是不幂等的，因为print会对控制台输出日志，这属于对函数外部产生了影响，而对外部产生影响属于附带效应，因此也是不幂等的。

附带效应是指发生在可组合函数作用域之外的应用状态的变化。由于可组合项的生命周期和属性（例如不可预测的重组、以不同顺序执行可组合项的重组或可以舍弃的重组），可组合项在理想情况下应该是无附带效应的。

回到Compose中来，为什么Compose的可组合函数要强调幂等且没有附带效应呢？因为Compose是没有对象这一个概念的，它是用纯粹的函数来表达UI，因此UI的刷新就是重新调用一次可组合函数，刷新过程由Compose的智能重组机制自动完成，关于这个机制我们接下来才会提到，你只需要了解一个概念：即Compose的UI刷新就是重新调用一次可组合函数，而且调用的次数和时机是不确定的即可。

基于这个因素，如果我们的可组合函数里面出现了附带效应的情况，就会导致附带效应在不恰当的时机出现，例如下面的代码：

@Composable
fun MyScreen(
title:String
){

Log.d(“UI日志”,“MyScreen”)
Column{
Text(title)
}

}

也许你的本意只是想输出一个日志，查看MyScreen的出现时机，但是这样在Compose中属于经典的错误。这样写的结果是每当MyScreen刷新的时候，都会输出一遍日志，如何解决附带效应的问题我们接下来再讲，现在只需要读者留一个概念：千万要注意附带效应！

二、重组与智能重组

在命令式界面模型中，如需更改某个 widget，您可以在该 widget 上调用 setter 以更改其内部状态。在 Compose 中，您可以使用新数据再次调用可组合函数。

这样做会导致函数进行重组，系统会根据需要使用新数据重新绘制函数发出的 widget。Compose 框架可以智能地仅重组已更改的组件。

例如，假设有以下可组合函数，它用于显示一个按钮：

@Composable
fun ClickCounter(clicks: Int, onClick: () -> Unit) {
Button(onClick = onClick) {
Text(“I’ve been clicked $clicks times”)
}
}

每次点击该按钮时，调用方都会更新 clicks 的值。Compose 会再次调用 lambda 与 Text 函数以显示新值；此过程称为“重组”。不依赖于该值的其他函数不会进行重组。

如前文所述，重组整个界面树在计算上成本高昂，因为会消耗计算能力并缩短电池续航时间。Compose 使用智能重组来解决此问题。

所谓的智能重组就是：Compose根据可组合函数的参数来决定是否进行重组。

也就是说，每一次可组合函数被调用的时候，他会检查所有传入的参数，如果本次传入的参数和上一次传入的参数都是相同的话（这里指的相同是指结构性相等，在kotlin中指的是==，在java中指的是调用对象的equals()方法) ，那么Compose就会略过调用这个可组合函数，以达到最快的重组效率。

让我们回到这个可组合函数，如果他的父级可组合函数由于某种原因触发了重组，那么Compose就会尝试调用MyScreen()来完成刷新，如果title参数没有发生变化的话，Compose实际上就会略过MyScreen的刷新。

@Composable
fun MyScreen(
title:String
){
Column{
Text(title)
}
}

三、Compose的生命周期

组合中可组合项的生命周期。进入组合，执行 0 次或多次重组，然后退出组合。

每一次composable（重组）就是调用一次可组合函数

四、remember与状态

由于 Compose 是声明式工具集，因此更新它的唯一方法是通过新参数调用同一可组合项。这些参数是界面状态的表现形式。每当状态更新时，都会发生重组。

1.remember

remember 会将对象存储在组合中，当调用 remember 的可组合项从组合中移除后，它会忘记该对象

为什么需要remember，是因为Compose使用了纯函数的形式表达UI（与flutter等框架使用对象不同），可组合函数本身可能会被多次调用，如果我们直接在方法体中声明属性，这个属性就会因为方法本身被多次调用从而丢失，因此我们需要一种让变量“持久化”的能力，remember就提供了这种能力，让某个变量从“Enter the Compotision”阶段一直保存到“leave the Composition”阶段。

被remember包裹住的变量，每一次组合的时候，取的都是同一个变量。

有时候，我们希望某个remember变量在恰当的时候发生变化，例如int类型的变量num变化的时候，自动生成对应的字符串，我们可以使用remember的key，当key发生变化的时候，remember的变量会重新生成。

var num by remember { mutableStateOf(0) }
val numString = remember(key1=num) {“我是数字$num”}

上述案例中，numString是受num影响的，如果num不变的情况下，numString取的值永远都是上一次生成的值，一旦num发生了变化，即remember中的key值变化，那么remember的lambda会重新执行来获取新值。

2.MutableState

mutableStateOf 会创建可观察的 MutableState，后者是与 Compose 运行时集成的可观察类型

interface MutableState : State {
override var value: T
}

如果 value 有任何变化，系统就会为用于读取 value 的所有可组合函数安排重组。

在可组合项中声明 MutableState 对象的方法有三种：

val mutableState = remember { mutableStateOf(default) }
var value by remember { mutableStateOf(default) }（实际中最多使用）
val (value, setValue) = remember { mutableStateOf(default) }

这些声明是等效的，以语法糖的形式针对状态的不同用法提供。您选择的声明应该能够在您编写的可组合项中生成可读性最高的代码。

简单来说，MutableState对象的作用就是一种可以被Compose观察其变化的对象，当一个MutableState变化的时候，这个对象所在的所有重组作用域都会进入重组。

*关于重组作用域的概念此处不展开，你可以大致理解为MutableState所在的那个可组合函数

通常MutableState是和remember一起出现的，下面演示一个组件：

@Composable
fun MyButton(){

var num:Int by remember{ mutableStateOf(0) }

Column{
Button(onClick = { num++ }) {
Text(“点我加一”)
}
Text(“当前点击次数：$num”)
}

}

很容易看出来，这是一个竖向的布局，上面是一个按钮，点击之后，会让num变量+1，然后触发重组，导致其下面的Text的显示内容也+1。

可能很多初学者看到num的类型是Int很奇怪，会奇怪为什么Int的类型变化会导致重组，不是说只有MutableState变化才会触发重组吗，这是由于使用了by这个操作符对MutableState进行了委托，num的get和set方法本质上是修改了MutableState的内部的value。

我们可以去除掉by操作符，代码会变成这样，本质是一样的：

@Composable
fun MyButton(){

val num: MutableState = remember{ mutableStateOf(0) }

Column{
Button(onClick = { num.value++ }) {
Text(“点我加一”)
}
Text(“当前点击次数：${num.value}”)
}

}

可以看出来，num的类型变成了MutableState，不能再对num修改，而是修改起内部的value，这样会导致Compose进行重组（也许你会好奇为什么会进行重组，这里大致的原理是每个重组作用域都会监听它内部所有的MutableState的value的变化，一旦他们发生了变化就会触发重组，是一个观察者模式的设计）。

实际开发中基本都是使用by的方式委托调用MutableState，因为不需要额外写.value。

五、解决附带效应

附带效应是指发生在可组合函数作用域之外的应用状态的变化，例如当进入页面的时候更新一下当前的位置，亦或者修改一下全局变量，如果直接在可组合函数里面引入这些附带效应的话，会让逻辑出现严重的问题，下面是两种常见的错误的附带效应的使用案例：

/**

手机位置更新服务
*/
object PhoneLocationUpdateService{
//…
fun updateMyLocation(){
// TODO: 更新当前的位置
}
//…
}

/**

全局变量、可组合函数以外的变量
*/
var globalParams:Int=0

@Composable
fun TestScreen(){

//❎的做法一
PhoneLocationUpdateService.updateMyLocation()
//❎错误的做法二
globalParams++

Column{
//…
}

}

为什么附带效应在Compose中存在问题？

这要结合Compose的生命周期来说，回归到生命周期的这张图中

如果我们希望可组合函数显示的时候，都让某个全局变量增加1的话，确实很容易直接在可组合函数的开头几句中直接让全局变量+1，但是需要重视的是，可组合函数会在生命周期期间多次重组的，也就是自身会被多次调用，这样就和我们需要的业务相违背了。

相似地，如果我们在AndroidView中的onLayout中插入某些访问全局变量的代码的话，可想而知会出现多大的问题（因为onLayout会频繁被调用而且次数未知）。

var globalParams:Int=0

class CrazyView @JvmOverloads constructor(
context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
) : View(context, attrs, defStyleAttr) {

override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
super.onLayout(changed, left, top, right, bottom)
//让人疯狂！！！
globalParams++
}

}