---
url: /v6.2/calculation-function-array.md
---
# 数组函数

## list_collect

| 语法         | list_collect(ARG)         |
|--------------|---------------------------|
| 参数说明     | 参与计算的参数，可选类型：任意 |
| 返回值类型   | 数组                     |
| 描述         | 聚合函数，把 arg 的参数收集为数组。（返回格式为数组类型，如果您发现显示为null，可以尝试将其转为字符串类型查看。） |
| 例子         | list_collect({f1})，返回：包含 f1 字段所有值的数组 |

## list_collect_flatten

| 语法         | list_collect_flatten(ARR) |
|--------------|---------------------------|
| 参数说明     | 数组类型参数，可选类型：数组 |
| 返回值类型   | 数组                     |
| 描述         | 聚合函数，把 arr 的参数收集打平为数组。（返回格式为数组类型，如果您发现显示为null，可以尝试将其转为字符串类型查看。） |
| 例子         | list_collect_flatten({f1})，返回：把 f1 数组的所有元素拿出来，拼成一个新的数组。 |

## list_contains

| 语法         | list_contains(ARR1, ARR2) |
|--------------|---------------------------|
| 参数说明     | 1. 数组1，可选类型：数组；2. 数组2，可选类型：数组 |
| 返回值类型   | 布尔                      |
| 描述         | 判断 arr1 是否包含 arr2 中的所有元素 |
| 例子         | list_contains(\[1, 2, 3], \[2, 3])，返回：TRUE |

## list_count

| 语法         | list_count(ARR)           |
|--------------|---------------------------|
| 参数说明     | 数组类型参数，可选类型：数组 |
| 返回值类型   | 数字                    |
| 描述         | 获取数组长度 |
| 例子         | list_count(\[1, 2, 3])，返回：3 |

## list_distinct

| 语法         | list_distinct(ARR)        |
|--------------|---------------------------|
| 参数说明     | 数组类型参数，可选类型：数组 |
| 返回值类型   | 数组                     |
| 描述         | 消除数组的重复元素 |
| 例子         | list_distinct(\[1, 2, 2, 3])，返回：\[1, 2, 3] |

## list_elements

| 语法         | list_elements(ARR)        |
|--------------|---------------------------|
| 参数说明     | 数组类型参数，可选类型：数组 |
| 返回值类型   | ANY                       |
| 描述         | 将指定数组的所有元素拆分成多行 |
| 例子         | list_elements(\[1, 2, 3])，返回：1、2、3（分行显示） |

## list_except

| 语法         | list_except(ARR1, ARR2)   |
|--------------|---------------------------|
| 参数说明     | 1. 数组1，可选类型：数组；2. 数组2，可选类型：数组 |
| 返回值类型   | 数组                     |
| 描述         | 返回在 arr1 中存在并且在 arr2 中不存在的元素 |
| 例子         | list_except(\[1, 2, 3], \[2, 4])，返回：\[1, 3] |

## list_get

| 语法         | list_get(ARR, INDEX)      |
|--------------|---------------------------|
| 参数说明     | 1. 数组类型参数，可选类型：数组；2. 索引位置，可选类型：数字 |
| 返回值类型   | 任意类型                       |
| 描述         | 获取数组指定位置的元素 |
| 例子         | list_get(\[10, 20, 30], 1)，返回：20（索引从0开始时） |

## list_in

| 语法         | list_in(ARR, ARG)         |
|--------------|---------------------------|
| 参数说明     | 1. 数组类型参数，可选类型：数组；2. 待判断的值，可选类型：任意类型 |
| 返回值类型   | 布尔                      |
| 描述         | 判断指定数组中是否存在给定的 arg 值 |
| 例子         | list_in(\[1, 2, 3], 2)，返回：TRUE |

## list_intersect

| 语法         | list_intersect(ARR1, ARR2) |
|--------------|---------------------------|
| 参数说明     | 1. 数组1，可选类型：数组；2. 数组2，可选类型：数组 |
| 返回值类型   | 数组                     |
| 描述         | 计算两个数组的交集 |
| 例子         | list_intersect(\[1, 2, 3], \[2, 3, 4])，返回：\[2, 3] |

## list_lower

| 语法         | list_lower(ARR)           |
|--------------|---------------------------|
| 参数说明     | 数组类型参数，可选类型：数组 |
| 返回值类型   | NUMBER                    |
| 描述         | 获取指定数组的下界 |
| 例子         | list_lower(\[1, 2, 3])，返回：1（通常数组下界从1开始） |

## list_slice

| 语法         | list_slice(ARR, ARG1, ARG2) |
|--------------|---------------------------|
| 参数说明     | 1. 数组类型参数，可选类型：数组；2. 下界索引，可选类型：数字；3. 上界索引，可选类型：数字 |
| 返回值类型   | 数组                     |
| 描述         | 返回 arr 在指定下界 arg1 与上界 arg2 的切片 |
| 例子         | list_slice(\[1, 2, 3, 4], 1, 3)，返回：\[2, 3] |

## list_union

| 语法         | list_union(ARR1, ARR2)    |
|--------------|---------------------------|
| 参数说明     | 1. 数组1，可选类型：数组；2. 数组2，可选类型：数组 |
| 返回值类型   | 数组                     |
| 描述         | 计算两个数组的并集 |
| 例子         | list_union(\[1, 2], \[2, 3])，返回：\[1, 2, 2, 3] |

## list_upper

| 语法         | list_upper(ARR)           |
|--------------|---------------------------|
| 参数说明     | 数组类型参数，可选类型：数组 |
| 返回值类型   | NUMBER                    |
| 描述         | 获取指定数组的上界 |
| 例子         | list_upper(\[1, 2, 3])，返回：3（通常数组上界为长度） |

## set_collect

| 语法         | set_collect(ARG)          |
|--------------|---------------------------|
| 参数说明     | 参与计算的参数，可选类型：任意类型|
| 返回值类型   | 数组                     |
| 描述         | 聚合函数，把 arg 的参数收集为去重数组。（返回格式为数组类型，如果您发现显示为null，可以尝试将其转为字符串类型查看。） |
| 例子         | set_collect(\[1, 2, 2, 3])，返回：\[1, 2, 3] |

## set_collect_flatten

| 语法         | set_collect_flatten(ARR)  |
|--------------|---------------------------|
| 参数说明     | 数组类型参数，可选类型：数组 |
| 返回值类型   | 数组                     |
| 描述         | 聚合函数，把 arr 的参数收集打平为去重数组。（返回格式为数组类型，如果您发现显示为null，可以尝试将其转为字符串类型查看。） |
| 例子         | set_collect_flatten(\[\[1, 2], \[2, 3]])，返回：\[1, 2, 3] |

## set_union

| 语法         | set_union(ARR1, ARR2)     |
|--------------|---------------------------|
| 参数说明     | 1. 数组1，可选类型：数组；2. 数组2，可选类型：数组 |
| 返回值类型   | 数组                     |
| 描述         | 计算两个数组的去重并集 |
| 例子         | set_union(\[1, 2], \[2, 3])，返回：\[1, 2, 3] |

## str_to_array

| 语法         | str_to_array(ARG1, ARG2)  |
|--------------|---------------------------|
| 参数说明     | 1. 文本类型参数，可选类型：STRING；2. 分隔符，可选类型：STRING |
| 返回值类型   | 数组                     |
| 描述         | 将文本 arg1 按照分隔符 arg2 分割成数组 |
| 例子         | str_to_array('a,b,c', ',')，返回：\["a", "b", "c"] |