🗂️ 集合（Collection）#

#bs.collection:help

Manipulate collections with a full set of functional operations. This module is NOT a stream module, features are not lazy.

🔧 函数#

下方列出了该模块提供的全部函数。

输入与输出

与大多数 Bookshelf 模块不同，集合功能通常从 bs:out 而非 bs:in 读取输入。这样设计便于链式操作：一个函数的输出会立刻成为下一个函数的输入。

移除开头元素#

从集合开头移除元素的操作。

移除开头元素

#bs.collection:drop {number:<value>}

移除集合中的前 N 个元素。

输入:

存储 bs:out collection.value: 要从中删除元素的集合。

函数宏：

参数
- number：要移除的元素数量。

输出:

存储 bs:out collection.value: 删除了前 N 个元素后的集合。

示例：移除前 2 个元素。

data modify storage bs:out collection.value set value [1, 2, 3, 4, 5]
function #bs.collection:drop {number: 2}
# bs:out collection.value = [3, 4, 5]

移除开头符合条件的元素

#bs.collection:drop_while {run:<value>}

只要谓词条件成立，就从集合开头依次移除元素，直到遇到不满足条件的元素时停止。

输入:

存储 bs:out collection.value: 要从中删除元素的集合。

函数宏：

参数
- run：谓词函数。

输出:

存储 bs:out collection.value: 剩余的元素。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- value：当前正在处理的元素。
- index：从零开始的当前元素索引。

返回：成功（1）则继续移除，失败（0）则停止。

示例：删除元素直到值为 3。

data modify storage bs:out collection.value set value [1, 2, 3, 4, 5]
function #bs.collection:drop_while {run: "execute unless data storage bs:lambda {collection: {value: 3}}"}
# bs:out collection.value = [3, 4, 5]

筛选#

用于筛选集合中一部分元素的操作。

去重

#bs.collection:distinct

移除集合中的重复项，仅保留每个元素首次出现的项。

输入:: 存储 bs:out collection.value: 要处理的集合。
输出:: 存储 bs:out collection.value: 去重后的集合。

示例：去除重复项。

data modify storage bs:out collection.value set value [1, 2, 2, 3, 1]
function #bs.collection:distinct
# bs:out collection.value = [1, 2, 3]

过滤

#bs.collection:filter {run:<value>}

仅保留满足谓词条件的元素。

输入:

存储 bs:out collection.value: 要过滤的集合。

函数宏：

参数
- 运行: 测试每个元素的谓词函数。

输出:

存储 bs:out collection.value: 仅包含匹配元素的过滤后的集合。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- value：当前正在处理的元素。
- index：从零开始的当前元素索引。

返回值: 成功 (1) 保留元素，否则失败 (0)。

示例：仅保留等于 3 的元素。

data modify storage bs:out collection.value set value [1, 3, 2, 3, 4]
function #bs.collection:filter {run: "execute if data storage bs:lambda collection{value: 3}"}
# bs:out collection.value = [3, 3]

查找#

定位元素或其索引的操作。

查找

#bs.collection:find {run:<value>}

查找第一个满足谓词条件的元素。

输入:

存储 bs:out collection.value: 要搜索的集合。

函数宏：

参数
- run：谓词函数。

输出:

存储 bs:out collection:

输出数据
- 值: 第一个匹配的元素（如果未找到则移除）。
- 索引: 匹配元素的索引，如果未找到则为 -1。

返回值: 如果找到元素则成功，否则失败。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- value：当前正在处理的元素。
- index：从零开始的当前元素索引。

返回值: 匹配时成功 (1)，否则失败 (0)。

示例：找到第一个等于 “b” 的元素。

data modify storage bs:out collection.value set value ["a", "b", "c"]
function #bs.collection:find {run: "execute if data storage bs:lambda collection{value: 'b'}"}
# bs:out collection.value = "b"
# bs:out collection.index = 1

查找最后一个

#bs.collection:find_last {run:<value>}

查找最后一个满足谓词条件的元素。

输入:

存储 bs:out collection.value: 要搜索的集合。

函数宏：

参数
- run：谓词函数。

输出:

存储 bs:out collection:

输出数据
- 值: 最后一个匹配的元素（如果未找到则移除）。
- 索引: 匹配元素的索引，如果未找到则为 -1。

返回值: 如果找到元素则成功，否则失败。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- value：当前正在处理的元素。
- index：从零开始的当前元素索引。

返回值: 匹配时成功 (1)，否则失败 (0)。

示例：查找最后一个等于3的元素。

data modify storage bs:out collection.value set value [1, 2, 3, 4, 3, 5]
function #bs.collection:find_last {run: "execute if data storage bs:lambda collection{value: 3}"}
# bs:out collection.value = 3
# bs:out collection.index = 4

索引查找

#bs.collection:index_of {run:<value>}

查找第一个匹配谓词的元素索引。

输入:

存储 bs:out collection.value: 要搜索的集合。

函数宏：

参数
- run：谓词函数。

输出:

存储 bs:out collection.value：第一个匹配元素的零基索引，如果不存在则为 -1。

返回值: 如果找到元素则成功，否则失败。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- value：当前正在处理的元素。
- index：从零开始的当前元素索引。

返回值: 匹配时成功 (1)，否则失败 (0)。

示例：查找值3的索引。

data modify storage bs:out collection.value set value [1, 2, 3, 4, 3, 5]
function #bs.collection:index_of {run: "execute if data storage bs:lambda collection{value: 3}"}
# bs:out collection.value = 2

最后索引查找

#bs.collection:last_index_of {run:<value>}

查找最后一个匹配谓词的元素索引。

输入:

存储 bs:out collection.value: 要搜索的集合。

函数宏：

参数
- run：谓词函数。

输出:

存储 bs:out collection.value：最后一个匹配元素的零基索引，如果不存在则为 -1。

返回值: 如果找到元素则成功，否则失败。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- value：当前正在处理的元素。
- index：从零开始的当前元素索引。

返回值: 匹配时成功 (1)，否则失败 (0)。

示例：查找值3的最后一个索引。

data modify storage bs:out collection.value set value [1, 2, 3, 4, 3, 5]
function #bs.collection:last_index_of {run: "execute if data storage bs:lambda collection{value: 3}"}
# bs:out collection.value = 4

展平#

将嵌套集合展平的操作。

连接

#bs.collection:concat

将列表组成的列表连接为一个列表。功能上等同于 flatten；当需要强调“连接”而不是“展平”时，可使用这个语义别名。

输入:: 存储 bs:out collection.value：要连接的列表的列表。
输出:: 存储 bs:out collection.value：展平后的列表，包含所有子列表中的元素，按顺序排列。

示例：连接列表。

data modify storage bs:out collection.value set value [[1, 2], [3], [4, 5]]
function #bs.collection:concat
# bs:out collection.value = [1, 2, 3, 4, 5]

展平

#bs.collection:flatten

将嵌套集合展平一级。

输入:: 存储 bs:out collection.value：要展平的嵌套集合。
输出:: 存储 bs:out collection.value：展平后的集合。

示例：展平二维数组。

data modify storage bs:out collection.value set value [[1, 2], [3, 4], [5]]
function #bs.collection:flatten
# bs:out collection.value = [1, 2, 3, 4, 5]

深度展平

#bs.collection:flatten_deep

递归地将任意深度的嵌套集合展平。保留非列表元素。

输入:: 存储 bs:out collection.value：要展平的嵌套集合。
输出:: 存储 bs:out collection.value：深度展平后的集合。

示例：展平深度嵌套结构。

data modify storage bs:out collection.value set value [1, [2, 3], [[4], 5]]
function #bs.collection:flatten_deep
# bs:out collection.value = [1, 2, 3, 4, 5]

折叠#

使用显式初始累加器将集合归约为单个值。

折叠

#bs.collection:fold {run:<value>,initial:<value>}

从指定的初始值开始，依次用函数把当前结果与下一个元素合并，最终得到一个值。

输入:

存储 bs:out collection.value：要折叠的集合。

函数宏：

参数
- run：组合累加器和值的 lambda 函数。
- initial：累加器的初始值，必须是有效的 NBT 值。

输出:

存储 bs:out collection.value：最终累加的值。

返回：成功时为 0。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- accumulator：（输入）当前累加的值。
- value：（输入）当前正在处理的元素。
- index：（输入）当前元素的从零开始的索引。
- result：（输出）新的累加值。

示例：使用自定义函数进行 fold（有关 lambda 的详细信息，请参见 reduce）。

data modify storage bs:out collection.value set value [1, 2, 3]
function #bs.collection:fold {run: "data modify storage bs:lambda collection.result set from storage bs:lambda collection.value", initial: 0}
# bs:out collection.value = 3 (last element replaces accumulator each time)

右折叠

#bs.collection:fold_right {run:<value>,initial:<value>}

从右向左应用函数，并使用指定的初始值将集合归约为单个值。

输入:

存储 bs:out collection.value：要折叠的集合。

函数宏：

参数
- run：组合累加器和值的 lambda 函数。
- initial：累加器的初始值，必须是有效的 NBT 值。

输出:

存储 bs:out collection.value：最终累加的值。

返回：成功时为 0。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- accumulator：（输入）当前累加的值。
- value：（输入）当前正在处理的元素。
- index：（输入）当前元素的从零开始的索引。
- result：（输出）新的累加值。

生成#

创建新集合的操作。

生成

#bs.collection:generate {run:<value>,limit:<value>}

反复调用生成器函数，直至达到限制值，从而生成一个集合。

输入:

函数宏：

参数
- run：用于生成值的要执行的命令。
- limit：要生成的值的数量。

输出:

存储 bs:out collection.value：生成的列表。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- index：正在生成的当前索引（从零开始）。
- result: (output) the value generated by run

示例：生成 [0, 1, 2]。

function #bs.collection:generate {run: "data modify storage bs:lambda collection.result set from storage bs:lambda collection.index", limit: 3}
# bs:out collection.value = [0, 1, 2]

条件生成

#bs.collection:generate_while {run:<value>,predicate:<value>}

在谓词条件成立时反复调用生成器函数，以生成集合。

输入:

函数宏：

参数
- run：用于生成值的要执行的命令。
- predicate：对生成的值进行检查的谓词，返回成功则继续，失败则停止。

输出:

存储 bs:out collection.value：生成的列表。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- index：正在生成的当前索引（从零开始）。
- result: (output) the value generated by run

Lambda 谓词:

存储 bs:lambda collection:

Lambda 数据
- value: the value generated by run
- index：正在生成的当前索引（从零开始）。

返回: 成功继续，失败停止。

示例：在结果不等于3时生成与索引相等的值。

function #bs.collection:generate_while {run: "data modify storage bs:lambda collection.result set from storage bs:lambda collection.index", predicate: "execute unless data storage bs:lambda {collection: {result: 3}}"}
# bs:out collection.value = [0, 1, 2]

范围

#bs.collection:range {min:<value>,max:<value>,step:<value>}

从 min（包含）到 max（不包含）按指定 step 生成数字序列。

输入:

函数宏：

参数
- min: 起始值（包含）。
- max: 结束值（不包含）。
- step: 每个值之间的步长。

输出:

存储 bs:out collection.value: 生成的整数列表。

示例：生成 0, 1, 2, 3, 4。

function #bs.collection:range {min: 0, max: 5, step: 1}
# bs:out collection.value = [0, 1, 2, 3, 4]

function #bs.collection:range {min: 0, max: 5, step: 2}
# bs:out collection.value = [0, 2, 4]

重复

#bs.collection:repeat {value:<value>,count:<value>}

创建一个由 count 个 value 副本组成的集合。

输入:

函数宏：

参数
- value: 要重复的值（必须是有效的NBT值）。
- count: 重复值的次数。

输出:

存储 bs:out collection.value：生成的列表。

示例：重复一个值3次。

function #bs.collection:repeat {value: 5, count: 3}
# bs:out collection.value = [5, 5, 5]

重复字符串

要重复字符串，值必须用双引号括起来（例如 “‘Hello’”）。

遍历#

依次对集合中的每个元素执行 Lambda 函数。

对于每个

#bs.collection:for_each {run:<value>}

对集合中的每个元素执行操作。

输入:

存储 bs:out collection.value: 要迭代的集合。

函数宏：

参数
- run: 在每个元素上执行的lambda函数。

输出:

无返回值。该函数用于逐项执行操作，不会生成新的集合。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- value：当前正在处理的元素。
- index：从零开始的当前元素索引。

示例：显示每个元素。

data modify storage bs:out collection.value set value ["Hello", "World", "!"]
function #bs.collection:for_each {run: "tellraw @a [{\"storage\":\"bs:lambda\",\"nbt\":\"collection.value\"}]"}
# Displays each string to all players

映射#

用于转换集合中各元素的操作。

扁平映射

#bs.collection:flat_map {run:<value>}

将每个元素转换为一个集合，再将所有结果展平为一个集合。

输入:

存储器 bs:out collection.value：要转换的集合。

函数宏：

参数
- run: 在每个元素上执行的lambda函数。

输出:

存储器 bs:out collection.value：扁平化后的转换集合。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- value：当前正在处理的元素。
- index：从零开始的当前元素索引。
- 结果：（输出）要扁平化到结果中的值列表。

示例：将每个数字转换为其倍数的列表并扁平化。

# This would require a custom function that returns a list
data modify storage bs:out collection.value set value [1, 2, 3]
function #bs.collection:flat_map {run: "function mypack:get_multiples"}
# If get_multiples returns [n, n*2] for each n, result would be [1, 2, 2, 4, 3, 6]

映射

#bs.collection:map {run:<value>}

使用lambda函数转换集合中的每个元素。

输入:

存储器 bs:out collection.value：要转换的集合。

函数宏：

参数
- run: 在每个元素上执行的lambda函数。

输出:

存储器 bs:out collection.value：转换后的集合。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- value：当前正在处理的元素。
- index：从零开始的当前元素索引。
- 结果：（输出）该元素的转换值。

示例：将列表中的每个数字加倍。

data modify storage bs:out collection.value set value [1, 2, 3, 4, 5]
function #bs.collection:map {run: "execute store result storage bs:lambda collection.result int 2 run data get storage bs:lambda collection.value"}
# bs:out collection.value = [2, 4, 6, 8, 10]

数值聚合#

从集合计算单个数值结果的操作。

平均值

#bs.collection:iaverage {scale:<value>}

计算数字集合（整数）的平均值（均值）。

输入:

存储器 bs:out collection.value：数字集合。

函数宏：

参数
- 尺度：应用于返回值的缩放因子（例如 1000 以获得 3 位小数精度）。

输出:

存储器 bs:out collection.value：平均值（未缩放）。

返回值：平均值乘以 scale 后的整数。

示例：[1, 2, 3, 4, 5] 的平均值。

data modify storage bs:out collection.value set value [1, 2, 3, 4, 5]
function #bs.collection:iaverage {scale: 1000}
# bs:out collection.value = 3.0d
# Return value = 3000

计数

#bs.collection:count

计算集合中元素的数量。

输入:

存储器 bs:out collection.value：要计数的集合。

输出:

存储 bs:out collection.value: 元素数量。

返回: 集合中元素的整数计数。

示例: 计数元素。

data modify storage bs:out collection.value set value [1, 2, 3, 4, 5]
function #bs.collection:count
# bs:out collection.value = 5

最大值

#bs.collection:imax

在一组整数集合中找到最大值。

输入:: 存储 bs:out collection.value: 整数集合。
输出:: 存储 bs:out collection.value: 最大值。

最小值

#bs.collection:imin

在一组整数集合中找到最小值。

输入:: 存储 bs:out collection.value: 整数集合。
输出:: 存储 bs:out collection.value: 最小值。

求和

#bs.collection:isum

计算集合中所有数字的总和（整数）。

输入:: 存储器 bs:out collection.value：数字集合。
输出:: 存储 bs:out collection.value: 总和。

分区#

根据谓词将集合分成两个。

分区

#bs.collection:partition {run:<value>}

根据谓词将集合分成两个集合：一个包含匹配谓词的元素，另一个包含不匹配的元素。

输入:

存储 bs:out collection.value: 要分区的集合。

函数宏：

参数
- 运行: 测试每个元素的谓词函数。

输出:

Storage bs:out collection.value: a list containing two lists: [matches, non_matches]

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- value：当前正在处理的元素。
- index：从零开始的当前元素索引。

返回值: 匹配时成功 (1)，否则失败 (0)。

示例: 将偶数和奇数分区。

data modify storage bs:out collection.value set value [1, 2, 3, 4, 5]
# Assume is_even returns 1 for even numbers, 0 for odd
function #bs.collection:partition {run: "function mypack:is_even"}
# bs:out collection.value = [[2, 4], [1, 3, 5]]

查看#

对集合中的每个元素执行 Lambda 函数，同时保持集合不变。

查看

#bs.collection:peek {run:<value>}

逐个执行操作，但不改变集合内容。适合在调试时查看中间数据，或在链式调用中添加额外操作。

输入:

存储 bs:out collection.value: 要迭代的集合。

函数宏：

参数
- run: 在每个元素上执行的lambda函数。

输出:

存储 bs:out collection.value: 原始集合，未改变。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- value：当前正在处理的元素。
- index：从零开始的当前元素索引。

示例: 处理时记录元素。

data modify storage bs:out collection.value set value [1, 2, 3]
# Log each element then continue with other operations
function #bs.collection:peek {run: "tellraw @a [{\"text\":\"Processing: \"},{\"storage\":\"bs:lambda\",\"nbt\":\"collection.value\"}]"}
# bs:out collection.value = [1, 2, 3]

谓词#

测试集合并返回成功或失败状态的操作。

所有

#bs.collection:all {run:<value>}

测试所有元素是否满足谓词条件。

输入:

存储 bs:out collection.value：要测试的集合。

函数宏：

参数
- run：谓词函数。

输出:

返回：如果所有元素匹配则成功 (1)。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- value：当前正在处理的元素。
- index：从零开始的当前元素索引。

返回值: 匹配时成功 (1)，否则失败 (0)。

任意

#bs.collection:any {run:<value>}

测试是否至少有一个元素满足谓词条件。

输入:

存储 bs:out collection.value：要测试的集合。

函数宏：

参数
- run：谓词函数。

输出:

返回：如果任一元素匹配则成功 (1)。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- value：当前正在处理的元素。
- index：从零开始的当前元素索引。

返回值: 匹配时成功 (1)，否则失败 (0)。

包含

#bs.collection:contains {searched:<value>}

检查集合是否包含特定值。

输入:

存储 bs:out collection.value: 要搜索的集合。

函数宏：

参数
- 搜索：要搜索的值。

输出:

返回：如果找到则成功 (1)，否则失败 (0)。

为空

#bs.collection:is_empty

测试集合是否为空。

输入:: 存储 bs:out collection.value：要测试的集合。
输出:: 返回：如果为空则成功 (1)。

没有

#bs.collection:none {run:<value>}

测试是否没有元素满足谓词条件。

输入:

存储 bs:out collection.value：要测试的集合。

函数宏：

参数
- run：谓词函数。

输出:

返回：如果没有元素匹配则成功 (1)。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- value：当前正在处理的元素。
- index：从零开始的当前元素索引。

返回值: 匹配时成功 (1)，否则失败 (0)。

归约#

将集合归约为单一值，使用第一个元素作为初始累加器。

归约

#bs.collection:reduce {run:<value>}

通过应用将累加器与每个元素组合的函数，将集合归约为单一值。

输入:

存储 bs:out collection.value：要归约的集合。

函数宏：

参数
- run：组合累加器和值的 lambda 函数。

输出:

存储 bs:out collection.value：最终累加的值。

返回：成功时返回 0，如果集合为空则失败。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- accumulator：（输入）当前累加的值。
- value：（输入）当前正在处理的元素。
- index：（输入）当前元素的从零开始的索引。
- result：（输出）新的累加值。

示例：使用归约获取最后一个元素。

data modify storage bs:out collection.value set value [1, 2, 3, 4, 5]
function #bs.collection:reduce {run: "data modify storage bs:lambda collection.result set from storage bs:lambda collection.value"}
# bs:out collection.value = 5

右归约

#bs.collection:reduce_right {run:<value>}

通过从右向左应用函数将集合缩减为单个值，从最后一个元素作为初始累加器开始。

输入:

存储 bs:out collection.value：要归约的集合。

函数宏：

参数
- run：组合累加器和值的 lambda 函数。

输出:

存储 bs:out collection.value：最终累加的值。

返回：成功时返回 0，如果集合为空则失败。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- accumulator：（输入）当前累加的值。
- value：（输入）当前正在处理的元素。
- index：（输入）当前元素的从零开始的索引。
- result：（输出）新的累加值。

反转#

反转元素的顺序。

反转

#bs.collection:reverse

反转集合中元素的顺序。

输入:: 存储 bs:out collection.value：要反转的集合。
输出:: 存储 bs:out collection.value：元素顺序反转后的集合。

示例：反转列表。

data modify storage bs:out collection.value set value [1, 2, 3, 4, 5]
function #bs.collection:reverse
# bs:out collection.value = [5, 4, 3, 2, 1]

缩放#

将集合中的每个数字乘以一个因子。

缩放

#bs.collection:scale {scale:<value>}

将集合中的所有数字乘以一个缩放因子。

输入:

存储 bs:out collection.value：要缩放的数字集合。

函数宏：

参数
- 缩放：缩放因子（乘数）。

输出:

存储 bs:out collection.value：所有值乘以缩放后的集合。

示例：将所有元素乘以10。

data modify storage bs:out collection.value set value [1, 2]
function #bs.collection:scale {scale: 10}
# bs:out collection.value = [10, 20]

扫描#

命名约定

scan_reduce 和 scan_fold 镜像了 reduce 和 fold，但返回每个中间累加器值而不是仅返回最终值。_right 后缀表示从右到左处理。

扫描折叠

#bs.collection:scan_fold {run:<value>,initial:<value>}

类似于 fold，但返回所有中间累加器值的列表。

输入:

存储 bs:out collection.value：要扫描的集合。

函数宏：

参数
- 运行：lambda 函数。
- 初始值：初始值，必须是一个有效的NBT值。

输出:

存储 bs:out collection.value：中间结果列表。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- accumulator：（输入）当前累加的值。
- value：（输入）当前正在处理的元素。
- index：（输入）当前元素的从零开始的索引。
- result：（输出）新的累加值。

扫描右折叠

#bs.collection:scan_fold_right {run:<value>,initial:<value>}

类似于 fold_right，但返回所有中间累加器值的列表。

输入:

存储 bs:out collection.value：要扫描的集合。

函数宏：

参数
- 运行：lambda 函数。
- 初始值：初始值，必须是一个有效的NBT值。

输出:

存储 bs:out collection.value：中间结果列表。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- accumulator：（输入）当前累加的值。
- value：（输入）当前正在处理的元素。
- index：（输入）当前元素的从零开始的索引。
- result：（输出）新的累加值。

扫描归约

#bs.collection:scan_reduce {run:<value>}

类似于 reduce，但返回所有中间累加器值的列表。

输入:

存储 bs:out collection.value：要扫描的集合。

函数宏：

参数
- 运行：lambda 函数。

输出:

存储 bs:out collection.value：中间结果列表。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- accumulator：（输入）当前累加的值。
- value：（输入）当前正在处理的元素。
- index：（输入）当前元素的从零开始的索引。
- result：（输出）新的累加值。

右扫描归约

#bs.collection:scan_reduce_right {run:<value>}

类似于 reduce_right，但返回所有中间累加器值的列表。

输入:

存储 bs:out collection.value：要扫描的集合。

函数宏：

参数
- 运行：lambda 函数。

输出:

存储 bs:out collection.value：中间结果列表。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- accumulator：（输入）当前累加的值。
- value：（输入）当前正在处理的元素。
- index：（输入）当前元素的从零开始的索引。
- result：（输出）新的累加值。

集合操作#

将集合按集合（set）语义处理的操作。

差集

#bs.collection:difference

计算两个集合的差集（存在于第一个集合但不在第二个中的元素，无重复）。

输入:

存储 bs:out collection.value：第一个集合。

存储 bs:in collection：第二个集合。

输出:

存储 bs:out collection.value：两个集合的差集。

示例：[1, 2, 3] 与 [2, 3, 4] 的差集。

data modify storage bs:out collection.value set value [1, 2, 3]
data modify storage bs:in collection set value [2, 3, 4]
function #bs.collection:difference
# bs:out collection.value = [1]

交集

#bs.collection:intersect

计算两个集合的交集（同时存在于两个集合中的元素，无重复）。

输入:

存储 bs:out collection.value：第一个集合。

存储 bs:in collection：第二个集合。

输出:

存储 bs:out collection.value：两个集合的交集。

示例：[1, 2, 3] 与 [2, 3, 4] 的交集。

data modify storage bs:out collection.value set value [1, 2, 3]
data modify storage bs:in collection set value [2, 3, 4]
function #bs.collection:intersect
# bs:out collection.value = [2, 3]

对称差集

#bs.collection:symmetric_difference

计算两个集合的对称差集（存在于任一个集合但不同时存在于两个中的元素，无重复）。

输入:

存储 bs:out collection.value：第一个集合。

存储 bs:in collection：第二个集合。

输出:

存储 bs:out collection.value：两个集合的对称差集。

示例：[1, 2, 3] 与 [2, 3, 4] 的对称差集。

data modify storage bs:out collection.value set value [1, 2, 3]
data modify storage bs:in collection set value [2, 3, 4]
function #bs.collection:symmetric_difference
# bs:out collection.value = [1, 4]

并集

#bs.collection:union

计算两个集合的并集（存在于任一个集合中的元素，无重复）。

输入:

存储 bs:out collection.value：第一个集合。

存储 bs:in collection：第二个集合。

输出:

存储 bs:out collection.value：两个集合的并集。

示例：[1, 2] 与 [2, 3] 的并集。

data modify storage bs:out collection.value set value [1, 2]
data modify storage bs:in collection set value [2, 3]
function #bs.collection:union
# bs:out collection.value = [1, 2, 3]

切片#

将集合拆分为子集合或窗口的操作。

分块

#bs.collection:chunk {size:<value>}

将一个集合拆分为大小为 N 的块。如果集合大小不能被 N 整除，最后一个块将包含剩余的元素。

输入:

存储 bs:out collection.value：要拆分的集合。

函数宏：

参数
- size：每个块的大小。

输出:

存储 bs:out collection.value：块列表（列表的列表）。

示例：将列表分块成对。

data modify storage bs:out collection.value set value [1, 2, 3, 4, 5]
function #bs.collection:chunk {size: 2}
# bs:out collection.value = [[1, 2], [3, 4], [5]]

切片

#bs.collection:slice {min:<value>,max:<value>}

从集合中提取从 min（包含）到 max（不包含）的部分。支持负索引（从末尾计数）。如果 min >= max 或索引超出范围（在解析负索引后），函数将失败。

输入:

存储 bs:out collection.value：要切片的集合。

函数宏：

参数
- min：起始索引（包含）。
- max：结束索引（不包含）。

输出:

存储 bs:out collection.value：切片后的集合。

示例：获取索引 1 到 3 的元素。

data modify storage bs:out collection.value set value [0, 1, 2, 3, 4]
function #bs.collection:slice {min: 1, max: 3}
# bs:out collection.value = [1, 2]

滑动

#bs.collection:sliding {size:<value>,step:<value>}

从集合中创建元素的滑动窗口。

输入:

存储 bs:out collection.value: 要处理的集合。

函数宏：

参数
- size：每个窗口中的元素数量。
- step：窗口移动的元素数量。

输出:

存储 bs:out collection.value：窗口列表（列表的列表）。

示例：大小为 2、步长为 1 的滑动窗口。

data modify storage bs:out collection.value set value [1, 2, 3, 4]
function #bs.collection:sliding {size: 2, step: 1}
# bs:out collection.value = [[1, 2], [2, 3], [3, 4]]

保留#

保留集合开头元素的操作。

保留

#bs.collection:take {number:<value>}

从集合中取出前 N 个元素。

输入:

存储 bs:out collection.value：要取出的集合。

函数宏：

参数
- number：要取出的元素数量。

输出:

存储 bs:out collection.value: 仅包含前 N 个元素的集合。

示例：取前 3 个元素。

data modify storage bs:out collection.value set value [1, 2, 3, 4, 5]
function #bs.collection:take {number: 3}
# bs:out collection.value = [1, 2, 3]

条件取

#bs.collection:take_while {run:<value>}

从集合开头取元素，只要谓词为真。

输入:

存储 bs:out collection.value：要取出的集合。

函数宏：

参数
- run：谓词函数。

输出:

存储 bs:out collection.value: 取出的元素。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- value：当前正在处理的元素。
- index：从零开始的当前元素索引。

返回：成功 (1) 继续取，失败 (0) 停止。

示例：取元素直到值为 4。

data modify storage bs:out collection.value set value [1, 2, 3, 4, 5]
function #bs.collection:take_while {run: "execute unless data storage bs:lambda {collection: {value: 4}}"}
# bs:out collection.value = [1, 2, 3]

监听#

对整个集合运行 lambda，原样传递。

监听

#bs.collection:tap {run:<value>}

对整个集合执行操作。适用于副作用或记录集合状态。

输入:

存储 bs:out collection.value: 要处理的集合。

函数宏：

参数
- run：要执行的 lambda 函数。

输出:

存储 bs:out collection.value: 原始集合，未改变。

Lambda 函数:

存储 bs:lambda collection:

Lambda 数据
- value：整个集合。

示例：记录集合的大小。

data modify storage bs:out collection.value set value [1, 2, 3]
function #bs.collection:tap {run: "tellraw @a [{\"text\":\"Collection: \"},{\"storage\":\"bs:lambda\",\"nbt\":\"collection.value\"}]"}
# bs:out collection.value = [1, 2, 3]

配对#

按对应位置将两个集合配对。

配对

#bs.collection:zip

将两个集合按对应位置配对，得到一个元素对列表。

输入:

存储 bs:out collection.value：第一个集合。

存储 bs:in collection：第二个集合。

输出:

存储 bs:out collection.value：由元素对 [[a1, b1], [a2, b2], ...] 组成的列表，长度与较短的集合一致。

示例：压缩两个列表。

data modify storage bs:out collection.value set value [1, 2, 3]
data modify storage bs:in collection set value [4, 5]
function #bs.collection:zip
# bs:out collection.value = [[1, 4], [2, 5]]

💬 这对你有帮助吗？

欢迎在下方留下你的问题和反馈！