sdk/com.m8test.script.core.api.coroutines.flow/Flow

Flow

interface Flow<T> : ObjectWrapper<ERROR CLASS: Symbol not found for kotlinx.coroutines.flow.Flow<T>>

一个异步数据流，可以按顺序发出多个值，并正常完成或因异常而终止。

Flow 类似于集合或序列，但它的值是异步计算的。

冷流 (Cold Flow)

默认情况下，Flow 是“冷”的。这意味着在调用一个终端操作符（如 collect）之前， Flow 内部的代码不会执行。每次调用终端操作符都会重新执行一遍 Flow 的构建逻辑。

操作符

中间操作符: 如 map, filter 等。它们本身不执行任何操作，只是构建一个操作链，并返回一个新的 Flow。
终端操作符: 如 collect, first, toList 等。它们会触发整个 Flow 链的执行（称为“收集”），并返回一个最终结果。

Author

M8Test, [email protected], https://m8test.com

Parameters

Flow 发出的值的类型。

Functions

all

abstract fun all(scope: CoroutineScope, predicate: (CoroutineScope, T) -> Deferred<Boolean>): Deferred<Boolean>

终端操作符，用于检查 Flow 中是否所有元素都满足给定的条件 predicate。

also

abstract fun also(block: (ERROR CLASS: Symbol not found for kotlinx.coroutines.flow.Flow<T>) -> Unit): ObjectWrapper<ERROR CLASS: Symbol not found for kotlinx.coroutines.flow.Flow<T>>

对 ObjectWrapper 调用给定的 block 函数，并返回 ObjectWrapper 本身。

any

abstract fun any(scope: CoroutineScope, predicate: (CoroutineScope, T) -> Deferred<Boolean>): Deferred<Boolean>

终端操作符，用于检查 Flow 中是否至少有一个元素满足给定的条件 predicate。

apply

abstract fun apply(block: ERROR CLASS: Symbol not found for kotlinx.coroutines.flow.Flow<T>.() -> Unit): ObjectWrapper<ERROR CLASS: Symbol not found for kotlinx.coroutines.flow.Flow<T>>

对 ObjectWrapper 调用给定的 block 函数，并返回 ObjectWrapper 本身。

catch

abstract fun catch(action: (CoroutineScope, FlowCollector<T>, Throwable) -> Job): Flow<T>

捕获上游 Flow 中发生的异常。

chunked

abstract fun chunked(size: Int): Flow<List<T>>

将 Flow 分割成多个列表，每个列表的大小不超过指定的 size。最后一个列表可能小于 size。

collect

abstract fun collect(scope: CoroutineScope, collector: (CoroutineScope, T) -> Job): Job

收集此 Flow 发出的所有值。

count

abstract fun count(scope: CoroutineScope): Deferred<Int>

返回 Flow 中的元素数量。

debounce

abstract fun debounce(timeoutMillis: Long): Flow<T>

返回一个镜像原始 Flow 的新 Flow，但会过滤掉在给定的 timeoutMillis 时间内后跟新值的旧值。总是会发出最新的值。

distinctUntilChanged

abstract fun distinctUntilChanged(areEquivalent: (T, T) -> Boolean): Flow<T>

过滤掉 连续重复 的元素，仅当相邻两次值通过 areEquivalent 比较返回 true 时视为重复。

distinctUntilChangedBy

abstract fun <K> distinctUntilChangedBy(keySelector: (T) -> K): Flow<T>

根据 keySelector 提取的“键”进行 相邻去重，键相同即视为重复。

filter

abstract fun filter(predicate: (CoroutineScope, T) -> Deferred<Boolean>): Flow<T>

返回一个只包含原始 Flow 中满足给定条件的元素的新 Flow。

filterIsInstance

abstract fun <R : Any> filterIsInstance(klass: KClass<R>): Flow<R>

返回一个只包含指定类型 R 的实例的 Flow。

filterNot

abstract fun filterNot(predicate: (CoroutineScope, T) -> Deferred<Boolean>): Flow<T>

返回一个只包含原始 Flow 中不满足给定条件的元素的新 Flow。

filterNotNull

abstract fun filterNotNull(): Flow<T>

返回一个过滤掉所有 null 值的 Flow。

first

abstract fun first(scope: CoroutineScope, predicate: (CoroutineScope, T) -> Deferred<Boolean>): Deferred<T>

返回此 Flow 中满足给定条件 predicate 的第一个值，然后取消 Flow 的收集。如果没有元素满足条件，将会抛出 NoSuchElementException 异常。

firstOrNull

abstract fun firstOrNull(scope: CoroutineScope, predicate: (CoroutineScope, T) -> Deferred<Boolean>): Deferred<T?>

返回此 Flow 中满足给定条件 predicate 的第一个值，如果 Flow 中没有元素满足条件则返回 null。

flowOn

abstract fun flowOn(context: CoroutineContext.() -> Unit): Flow<T>

改变上游 Flow（即此 flowOn 调用之前的所有操作）执行的协程上下文。

fold

abstract fun <R> fold(scope: CoroutineScope, initial: R, operation: (CoroutineScope, acc: R, value: T) -> Deferred<R>): Deferred<R>

使用给定的初始值 initial 和操作函数 operation 来累积 Flow 中的值。返回最终的累积结果。

getOrigin

abstract fun getOrigin(): ERROR CLASS: Symbol not found for kotlinx.coroutines.flow.Flow<T>

获取原始的对象.

last

abstract fun last(scope: CoroutineScope): Deferred<T>

返回此 Flow 发出的最后一个值。如果 Flow 为空，将会抛出 NoSuchElementException 异常。

lastOrNull

abstract fun lastOrNull(scope: CoroutineScope): Deferred<T?>

返回此 Flow 发出的最后一个值，如果 Flow 为空则返回 null。

launchIn

abstract fun launchIn(scope: CoroutineScope): Job

收集 Flow，但忽略所有发出的值，仅启动 Flow 的执行。

let

abstract fun <R> let(block: (ERROR CLASS: Symbol not found for kotlinx.coroutines.flow.Flow<T>) -> R): ObjectWrapper<R>?

对 ObjectWrapper 调用给定的 block 函数，并返回 block 函数的结果包装在 ObjectWrapper 中。

map

abstract fun <R> map(transform: (CoroutineScope, T) -> Deferred<R>): Flow<R>

对 Flow 中的每个元素应用给定的转换函数，并返回一个包含转换后结果的新 Flow。

mapNotNull

abstract fun <R : Any> mapNotNull(transform: (CoroutineScope, T) -> Deferred<R?>): Flow<R>

对 Flow 中的每个元素应用给定的转换函数，并返回一个只包含非 null 转换结果的新 Flow。

none

abstract fun none(scope: CoroutineScope, predicate: (CoroutineScope, T) -> Deferred<Boolean>): Deferred<Boolean>

终端操作符，用于检查 Flow 中是否没有元素满足给定的条件 predicate。

onCompletion

abstract fun onCompletion(action: (CoroutineScope, Throwable?) -> Job): Flow<T>

在 Flow 收集完成时（无论正常完成还是因异常终止）执行给定的 action。

onEach

abstract fun onEach(action: (CoroutineScope, T) -> Job): Flow<T>

返回一个 Flow，它会在下游消费上游的每个值之前，先对该值执行给定的 action。

reduce

abstract fun reduce(scope: CoroutineScope, operation: (CoroutineScope, accumulator: T, value: T) -> Deferred<T>): Deferred<T>

使用流的第一个元素作为初始值，通过给定的操作函数 operation 来累积 Flow 中的值。如果 Flow 为空，将会抛出 NoSuchElementException 异常。

run

abstract fun <R> run(block: ERROR CLASS: Symbol not found for kotlinx.coroutines.flow.Flow<T>.() -> R): ObjectWrapper<R>?

对 ObjectWrapper 调用给定的 block 函数，并返回 block 函数的结果包装在 ObjectWrapper 中。

runningFold

abstract fun <R> runningFold(initial: R, operation: (CoroutineScope, accumulator: R, value: T) -> Deferred<R>): Flow<R>

使用给定的初始值 initial 和操作函数 operation 来折叠 Flow，并发出每一个中间的累积结果。

runningReduce

abstract fun runningReduce(operation: (CoroutineScope, accumulator: T, value: T) -> Deferred<T>): Flow<T>

与 runningFold 类似，但使用流的第一个元素作为初始累积值。

sample

abstract fun sample(periodMillis: Long): Flow<T>

返回一个 Flow，它在给定的采样周期 periodMillis 内，只发出原始 Flow 发出的最新值。

setOrigin

abstract fun setOrigin(origin: ERROR CLASS: Symbol not found for kotlinx.coroutines.flow.Flow<T>)

设置原始对象

single

abstract fun single(scope: CoroutineScope): Deferred<T>

返回此 Flow 发出的唯一一个值。如果 Flow 为空，会抛出 NoSuchElementException。如果 Flow 包含多个元素，会抛出 IllegalArgumentException。

singleOrNull

abstract fun singleOrNull(scope: CoroutineScope): Deferred<T?>

返回此 Flow 发出的唯一一个值，如果 Flow 为空或包含多个元素，则返回 null。

take

abstract fun take(count: Int): Flow<T>

返回一个只发出前 count 个元素的 Flow。

takeIf

abstract fun takeIf(predicate: (ERROR CLASS: Symbol not found for kotlinx.coroutines.flow.Flow<T>) -> Boolean): ObjectWrapper<ERROR CLASS: Symbol not found for kotlinx.coroutines.flow.Flow<T>>?

如果 ObjectWrapper 满足给定的 predicate，则返回 ObjectWrapper 本身，否则返回 null 包装在 ObjectWrapper? 中。

takeUnless

abstract fun takeUnless(predicate: (ERROR CLASS: Symbol not found for kotlinx.coroutines.flow.Flow<T>) -> Boolean): ObjectWrapper<ERROR CLASS: Symbol not found for kotlinx.coroutines.flow.Flow<T>>?

如果 ObjectWrapper 不满足给定的 predicate，则返回 ObjectWrapper 本身，否则返回 null 包装在 ObjectWrapper? 中。

takeWhile

abstract fun takeWhile(predicate: (CoroutineScope, T) -> Deferred<Boolean>): Flow<T>

只要给定的条件为 true，就持续发出元素。一旦条件变为 false，Flow 就会停止。

timeout

abstract fun timeout(millis: Long): Flow<T>

返回一个 Flow，如果上游在给定的超时时间内没有发出任何值，该 Flow 将会抛出 TimeoutCancellationException。

toList

abstract fun toList(scope: CoroutineScope): Deferred<List<T>>

将 Flow 的所有元素收集到一个列表中。

withIndex

abstract fun withIndex(): Flow<IndexedValue<T>>

将 Flow 中的每个元素包装成一个 IndexedValue 对象，该对象包含元素的原始值和它在流中的索引（从0开始）。