codewave-openclaw-installer 1.0.0

package/skills/smart-customer-service/docs/codewave/20./345/272/224/347/224/250/345/274/200/345/217/221/15./351/200/273/350/276/221/345/212/237/350/203/275/345/256/236/347/216/260/50./345/206/205/347/275/256/345/207/275/346/225/260/344/275/277/347/224/250/20./345/210/227/350/241/250/357/274/210List/357/274/211/345/207/275/346/225/260.md

@@ -0,0 +1,1334 @@
+# 列表（List）函数
+
+| 函数名称               | 描述                                                   |
+| :----------------- | :--------------------------------------------------- |
+| [Add](#add)            | 向列表末尾添加一项，会修改原列表，无返回值。                               |
+| [AddAll](#addall)         | 将一个列表的各项添加到另一个列表末尾，会修改原列表，并返回列表长度。                   |
+| [Average](#average)        | 计算数值列表list内所有项的平均数。                                  |
+| [Contains](#contains)       | 判断指定列表是否包含指定项。                                       |
+| [CreateListPage](#createlistpage) | 将 List类型的数据转换为 { list: List,total: Integer }数据结构并返回。 |
+| [Distinct](#distinct)       | 为列表去除重复项，会修改原数据，无返回值。                                |
+| [DistinctBy](#distinctby)       | 在指定列表list中按照指定属性by去除重复项。                                |
+| [Filter](#filter)         | 根据筛选条件在列表中找到符合条件的所有项，并将它们组成一个新的列表返回。                 |
+| [Find](#find)           | 根据筛选条件筛选数据，返回符合条件的数据项。                               |
+| [FindIndex](#findindex)      | 根据筛选条件筛选数据，返回符合条件的数据项的索引。                            |
+| [Flatten](#flatten)        | 将嵌套的列表或数组展平为一维的 List类型的列表或数组。                        |
+| [Get](#get)            | 获取列表指定索引位置的数据并返回。                                    |
+| [GroupBy](#groupby)        | 按指定属性对列表分组，以选中的属性为key，原项作为value生成Map，并返回生成的Map（映射）。  |
+| [Head](#head)           | 获取列表的首项并返回。                                          |
+| [Insert](#insert)         | 向列表指定索引处插入新项，修改原列表，无返回值。                             |
+| [Last](#last)           | 获取列表的最后一项并返回。                                        |
+| [Max](#max)            | 查找列表中的最大值并返回。                                        |
+| [Min](#min)            | 查找列表中的最小值并返回。                                        |
+| [Product](#product)        | 计算数值列表各项的乘积并返回。                                      |
+| [Range](#range)        | 生成指定范围和步长的整数列表                                      |
+| [Remove](#remove)         | 删除列表中指定项，修改原列表，无返回值。                                 |
+| [RemoveAt](#removeat)       | 删除列表中指定索引位置的项，修改原列表，返回删除项内容。                         |
+| [Repeat](#repeat)       | 生成指定长度的重复项列表。                       |
+| [Reverse](#reverse)        | 反转列表项顺序，修改原列表，无返回值。                                  |
+| [Set](#set)            | 替换列表中指定索引位置的项，并返回新项的内容。                              |
+| [Slice](#slice)          | 按照指定规则对列表进行切片，返回切片后的子列表。                             |
+| [Sort](#sort)           | 按指定规则对列表排序，修改原列表，无返回值。                               |
+| [Sum](#sum)            | 计算数值列表所有项的和。                                         |
+| [ToMap](#tomap)          | 选取列表的某些属性或自身作为 key、value，构成 Map并返回。                  |
+| [Transform](#transform)      | 根据by定义的处理方式处理列表各项，返回新项构成的列表。                         |
+
+## Add
+
+**函数介绍**
+
+用于向列表末尾添加一项，会修改原列表数据，无返回值。例如，在页面中添加新的选项或标签。
+
+<img src="../assets/liebiaoListhanshu_202407221820_1.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需要进行操作的列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+
+    item：需要添加的项。可以是变量、逻辑、接口、内置函数等返回值为T的表达式。
+
+**输出参数**
+
+无
+
+**示例**
+
+已有局部变量exampleList，其数据类型为`List<Students>` ，Students为自定义数据结构，数据结构包含 name 和 age 属性，局部变量exampleList数据内容如下：
+
+```json
+[
+    Students {
+        name: "Alice",
+        age: 20
+    },
+    Students {
+        name: "Bob",
+        age: 22
+    }
+]
+```
+
+使用 Add 函数向列表添加新的元素。
+
+<img src="../assets/liebiaoListhanshu_202407221820_2.png" class="imgStyle" style="" />
+
+<div class="yellowBlock">
+
+使用Add内置函数会改变列表原数据，如此时调用函数后局部变量exampleList的数据内容如下：
+
+```json
+[
+    Students {
+        name: "Alice",
+        age: 20
+    },
+    Students {
+        name: "Bob",
+        age: 22
+    },
+    Students {
+        name: "David",
+        age: 19
+    }
+] 
+```
+
+</div>
+
+
+## AddAll
+
+**函数介绍**
+
+用于将参数列表 addList 的每一项添加到参数列表 list 的末尾，会修改原列表数据。
+
+<img src="../assets/liebiaoListhanshu_202407221820_3.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：原始列表。可以是变量、逻辑、接口、内置函数等返回值`List<T>`的表达式。
+- addList：在原始列表末尾增加的列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+
+**输出参数**
+
+输出一个整数，表示修改后的列表 list 的长度。
+
+<img src="../assets/liebiaoListhanshu_202407221820_4.png" class="imgStyle" style="" />
+
+**示例**
+
+已有局部变量exampleList，其数据类型为`List<Integer整数>` ，初始内容为 [1, 2, 3] ，另一个要添加的局部变量exampleList1，其数据类型为`List<Integer整数>` ，内容为 [4, 5, 6] 。
+
+使用 AddAll 函数将exampleList1的元素添加到另一个列表exampleList的末尾。
+
+<img src="../assets/liebiaoListhanshu_202407221820_5.png" class="imgStyle" style="" />
+
+调用函数后的返回结果为6。
+
+<div class="yellowBlock">
+
+注意：使用内置函数AddAll会改变原始列表数据，如此时局部变量exampleList的数据由 [1, 2 ,3] 会变成 [1, 2, 3, 4, 5, 6]。
+
+</div>
+
+## Average
+
+**函数介绍**
+
+用于计算数值列表list内所有项的平均数。
+
+<img src="../assets/liebiaoListhanshu_202407221820_6.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需要计算的数值类型列表。可以是变量、逻辑、接口、内置函数等返回值为`List<Integer整型>`和`List<Decimal小数>`的表达式。
+
+**输出参数**
+
+输出一个Decimal 小数类型的结果，表示计算得到的平均数。
+
+**示例**
+
+已有局部变量 exampleList 数据类型为`List<Integer整型>`，内容为 [3, 6, 9]。
+
+使用 Average函数，计算当前列表所有项的平均值。调用函数后的输出结果为6。
+
+<img src="../assets/liebiaoListhanshu_202407221820_7.png" class="imgStyle" style="" />
+
+## Contains
+
+**函数介绍**
+
+用判断指定列表是否包含指定项。
+
+<img src="../assets/liebiaoListhanshu_202407221820_8.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需要判断的列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+
+- item：指定项的值。可以是变量、逻辑、接口、内置函数等返回值为T的表达式。
+
+**输出参数**
+
+输出一个Boolean 布尔值类型的结果，表示列表是否包含指定项，若包含则返回true，不包含则返回false。
+
+**示例**
+
+局部变量 exampleList 数据类型为 `List<String>`，内容为["A","B","C"]。
+
+判断局部变量exampleList中是否包含“B”列表项。调用函数后输出结果为true。
+
+<img src="../assets/liebiaoListhanshu_202407221820_9.png" class="imgStyle" style="" />
+
+## CreateListPage
+
+**函数介绍**
+
+用于将`List<T>`类型的数据转换为`{list: List<T>,total: Integer }`数据结构并返回。常用于列表分页显示数据。
+
+**输入参数**
+
+- list：需要分页的列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+
+- total：需要分页的列表数据总条数，即输入参数list的list.length。可以是变量、逻辑、接口、内置函数等返回值为Integer整数的表达式。
+
+**输出参数**
+
+输出一个包含 list （分页后的列表）和 total （列表数据的总条数）的对象。如果输入的 list 为空，则 list 字段为一个空列表，total 为 0 ，如下：
+
+```json
+{
+    list: [],
+    total: 0
+}
+``` 
+
+**示例**
+
+局部变量goodsList数据类型为：
+
+```json
+List<{
+    id: Integer 整数,
+    createdTime: DateTime 日期时间,
+    updatedTime: DateTime 日期时间,
+    createdBy: String 文本,
+    updatedBy: String 文本,
+    name: String 文本,
+    price: Decimal 小数,
+    img: String 文本
+}>
+```
+
+将局部变量goodsList数据转换为`{ list: List<T>,total: Integer }`数据结构。
+
+<img src="../assets/liebiaoListhanshu_202407221820_10.png" class="imgStyle" style="" />
+
+调用函数后的返回结果数据类型为：
+
+```json
+{
+    list: List<{ 
+            id: Integer 整数, 
+            createdTime: DateTime 日期时间,
+            updatedTime: DateTime 日期时间, 
+            createdBy: String 文本, 
+            updatedBy: String 文本, 
+            name: String 文本,
+            price: Decimal 小数, 
+            img: String 文本
+          }>,
+    total: Integer 整数
+}
+```
+
+## Distinct
+
+**函数介绍**
+
+用于为列表去除重复项，会修改原数据，并返回去重后的列表。另外，此类会更改原数据且有返回值的函数，既可以在逻辑线中直接使用，即时满足后续逻辑处理环节对于排序结果的需求；也可以将其返回值赋给特定的变量，以便后续进一步处理。
+
+<img src="../assets/liebiaoListhanshu_202411111803_1.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需要去除重复项的列表。可以是变量、逻辑、接口、内置函数等返回值`List<T>`的表达式。
+
+**输出参数**
+
+输出去除重复项的列表，列表的类型与输入的list参数的类型一致，即`List<T>`。
+
+<img src="../assets/liebiaoListhanshu_202411111803_2.png" class="imgStyle" style="" />
+
+**示例**
+
+前提条件：已有局部变量exampleList数据类型为`List<String>`，内容为`["A","B","C","A"]`。
+
+具体操作：调用函数去除局部变量exampleList中的重复项。
+
+<img src="../assets/liebiaoListhanshu_202411111803_3.png" class="imgStyle" style="" />
+
+调用结果：Distinct内置函数会改变列表原数据，此时调用函数后局部变量exampleList的内容会由`["A","B","C","A"]`变成`["A","B","C"]`。
+
+## DistinctBy
+
+**函数介绍**
+
+用于在指定列表list中按照指定属性by去除重复项。
+
+<img src="../assets/liebiaoListhanshu_202407221820_13.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需去除重复项的列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。该选项参数支持除基础类型项组成的列表之外的所有列表。
+- by：用于指定要根据哪些属性或字段去除重复的项，若列表项无属性，则该函数不生效。
+
+   如下情况该函数不生效：
+
+   列表元素为基础数据类型（如Integer整数、Sting文本、Boolean 布尔值等）。
+
+   <img src="../assets/liebiaoListhanshu_202407221820_14.png" class="imgStyle" style="" />
+
+**输出参数**
+
+输出去除重复项后的列表。
+
+**示例**
+
+去除列表中名称属性重复的项。
+
+前提条件：
+
+1.  已有局部变量exampleList，其数据类型为`List<{product:Product}>`，Product为商品信息实体，实体包含以下属性：
+
+    - 名称属性：name，数据类型为 String 文本；
+    - 单价属性：price，数据类型为 Decimal小数；
+    - 类别属性：type，数据类型为 String 文本；
+    - 库存属性：stock，数据类型为 Integer整型；
+
+2.  局部变量exampleList存储有商品列表数据，且列表有重复数据如下：
+
+    <img src="../assets/liebiaoListhanshu_202407221820_15.png" class="imgStyle" style="" />
+
+具体操作：
+
+1.  调用函数DistinctBy处理列表数据。
+
+      <img src="../assets/liebiaoListhanshu_202407221820_16.png" class="imgStyle" style="" />
+
+1.  预览效果
+
+      <img src="../assets/liebiaoListhanshu_202407221820_17.png" class="imgStyle" style="" />
+
+## Filter
+
+**函数介绍**
+
+用于在指定列表list中通过筛选条件by找到符合条件的所有项，将它们组成一个类型为`List<T>`的列表并返回。
+
+<img src="../assets/liebiaoListhanshu_202501211815_1.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需要筛选的列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+- by：用于确定筛选条件，根据不同的应用场景，有多种定义方式：
+  - 简单场景：可以通过将表达式作为输入参数，简洁直观地设定筛选规则。此表达式可以是指定列表项的某个属性，或是列表项本身。同时，也可利用算术运算、比较运算以及逻辑运算来构建条件判断，最终输出布尔值结果，以此明确筛选标准。
+
+    <img src="../assets/liebiaoListhanshu_202501211815_2.png" class="imgStyle" style="" />
+
+  - 复杂场景：为满足更为复杂的筛选需求，可以通过添加子逻辑或服务端逻辑作为输入参数。具体细节可参考：[内置函数使用说明](../50.内置函数使用/03.内置函数使用说明.md)中的“适用场景” 相关描述 。
+  - 复用场景：若已有适用的服务端逻辑，可直接复用该逻辑作为输入参数，以提高开发效率。具体细节可参考：[内置函数使用说明](../50.内置函数使用/03.内置函数使用说明.md)中的“适用场景” 相关描述 。
+
+**输出参数**
+
+- 当数据中有符合筛选条件的项时，输出一个新的List，其中包含符合筛选条件的所有项。
+- 当数据中无符合筛选条件的项时，输出一个空的List。
+- 当输入的列表内容为空（即列表长度等于0）时，输出一个空的List。
+
+**示例**
+
+通过编辑表达式，将学生数据中，年龄大于等于18小于等与22的学生信息筛选出来。
+
+<img src="../assets/liebiaoListhanshu_202501211815_3.png" class="imgStyle" style="" />
+
+## Find
+
+**函数介绍**
+
+用于在指定列表list中根据筛选条件by筛选数据。
+
+<img src="../assets/liebiaoListhanshu_202501211815_4.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需要筛选的列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+- by：用于确定筛选条件，根据不同的应用场景，有多种定义方式：
+  - 简单场景：可以通过将表达式作为输入参数，简洁直观地设定筛选规则。此表达式可以是指定列表项的某个属性，或是列表项本身。同时，也可利用算术运算、比较运算以及逻辑运算来构建条件判断，最终输出布尔值结果，以此明确筛选标准。
+
+      <img src="../assets/liebiaoListhanshu_202501211815_5.png" class="imgStyle" style="" />
+
+  - 复杂场景：为满足更为复杂的筛选需求，可以通过添加子逻辑或服务端逻辑作为输入参数。具体细节可参考：[内置函数使用说明](../50.内置函数使用/03.内置函数使用说明.md)中的“适用场景” 相关描述 。
+  - 复用场景：若已有适用的服务端逻辑，可直接复用该逻辑作为输入参数，以提高开发效率。具体细节可参考：[内置函数使用说明](../50.内置函数使用/03.内置函数使用说明.md)中的“适用场景” 相关描述 。
+
+**输出参数**
+
+- 当数据中存在符合筛选条件的项时，输出第一个符合筛选条件的结果，数据类型根据输入参数list项的值类型决定。
+- 当数据中无符合筛选条件的项时，输出空值。
+- 当输入的列表内容为空（即列表长度等于0）时，输出空值。
+
+注意：为避免在列表为空的情况下，直接调用Find函数导致的空指针异常或其他不可预期的错误。在调用Find函数之前，应该对输入的列表进行判空操作。具体的各类型数据的非空判断操作说明可参见：[如何进行非空判断](../../../80.常见场景案例/50.逻辑场景/110.如何进行非空判断.md)。
+
+**示例**
+
+局部变量exampleList存储有商品列表数据，如下：
+
+```json
+[
+    {
+        product: Product {
+            id: 2916367350425344,
+            name: "娃哈哈",
+            price: 2,
+            type: "饮料",
+            stock: 996
+        }
+    },
+    {
+        product: Product {
+            id: 2916400584189696,
+            name: "辣条",
+            price: 3.5,
+            type: "零食",
+            stock: 1000
+        }
+    }
+]
+```
+
+调用函数Find处理列表数据，将列表项中，第一个库存数量大于500的项筛选出来。
+
+<img src="../assets/liebiaoListhanshu_202501211815_6.png" class="imgStyle" style="" />
+
+调用函数后的输出结果如下：
+
+```json
+{
+    product: Product {
+        id: 2916367350425344,
+        name: "娃哈哈",
+        price: 2,
+        type: "饮料",
+        stock: 996
+    }
+}
+```
+
+## FindIndex
+
+**函数介绍**
+
+用于在指定列表list中根据筛选条件by筛选数据。
+
+<img src="../assets/liebiaoListhanshu_202501211815_7.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需要筛选的列表，可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+- by：用于确定筛选条件，根据不同的应用场景，有多种定义方式：
+
+    - 简单场景：可以通过将表达式作为输入参数，简洁直观地设定筛选规则。此表达式可以是指定列表项的某个属性，或是列表项本身。同时，也可利用算术运算、比较运算以及逻辑运算来构建条件判断，最终输出布尔值结果，以此明确筛选标准。
+
+        <img src="../assets/liebiaoListhanshu_202501211815_8.png" class="imgStyle" style="" />
+
+    - 复杂场景：为满足更为复杂的筛选需求，可以通过添加子逻辑或服务端逻辑作为输入参数。具体细节可参考：[内置函数使用说明](../50.内置函数使用/03.内置函数使用说明.md)中的“适用场景” 相关描述 。
+    - 复用场景：若已有适用的服务端逻辑，可直接复用该逻辑作为输入参数，以提高开发效率。具体细节可参考：[内置函数使用说明](../50.内置函数使用/03.内置函数使用说明.md)中的“适用场景” 相关描述 。
+
+**输出参数**
+
+- 当数据中存在符合筛选条件的项时，输出一个整数，表示第一个符合条件的项的索引值。
+- 当数据中无符合筛选条件的项时，输出-1。
+- 当输入的列表内容为空（即列表长度等于0）时，输出 -1。
+
+**示例**
+
+局部变量exampleList存储有商品列表数据，如下：
+
+```json
+[
+    {
+        product: Product {
+            id: 2916367350425344,
+            name: "娃哈哈",
+            price: 2,
+            type: "饮料",
+            stock: 996
+        }
+    },
+    {
+        product: Product {
+            id: 2916400584189696,
+            name: "辣条",
+            price: 3.5,
+            type: "零食",
+            stock: 1000
+        }
+    }
+]
+```
+
+调用函数FindIndex处理列表数据，找到列表项中，第一个库存数量大于500列表项的索引值。输出结果为0。
+
+<img src="../assets/liebiaoListhanshu_202501211815_9.png" class="imgStyle" style="" />
+
+## Flatten
+
+**函数介绍**
+
+用于将嵌套的列表或数组展平为一维的`List<T>`类型的列表或数组。例如，在数据分析中，使用Flatten函数将多维数组展平为一维数组，即`List<List<T>>`变为`List<T>`，以便于进行数据聚合和分析。
+
+<img src="../assets/liebiaoListhanshu_202407221820_27.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：嵌套的列表。可以是变量、逻辑、接口、内置函数等返回值为嵌套列表的表达式，如返回值数据类型为`List<List<T>>`的表达式。
+
+**输出参数**
+
+输出展平后的一维列表（` List<T>`类型的列表或数组）。
+
+**示例**
+
+已有局部变量exampleList数据类型为`List<List<Integer整型>>`，内容为[[1,2],[3,4]]。
+
+将嵌套列表展平为一维列表。调用函数后的输出结果为 [1,2,3,4]。
+
+<img src="../assets/liebiaoListhanshu_202407221820_28.png" class="imgStyle" style="" />
+
+## Get
+
+**函数介绍**
+
+用于获取列表指定索引位置的数据并返回。
+
+<img src="../assets/liebiaoListhanshu_202407221820_29.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：用于获取数据的列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+- index：要获取的数据在列表中的索引位置，数据类型为Integer整型。用数字表示第几项，项数索引从0开始，第一个元素的索引位置为0，第二个元素的索引位置为1，以此类推。
+
+**输出参数**
+
+- 当指定索引位置存在时，输出指定索引位置的元素，其数据类型与列表中元素的类型相同。
+
+- 当指定索引位置不存在（即索引值小于 0 或大于等于列表长度）时，抛出如“Error: 列表访问越界，访问下标 0，列表长度 0” 异常。
+
+- 当输入的列表内容为空（即列表长度等于0）时，抛出如“Error: 列表访问越界，访问下标 0，列表长度 0” 异常。
+
+**示例**
+
+已有局部变量exampleList数据类型为`List<String>`，内容为 ["A","B","C"]。
+
+获取索引位置为2的列表项。调用函数后的返回结果为“C”。
+
+<img src="../assets/liebiaoListhanshu_202407221820_30.png" class="imgStyle" style="" />
+
+## GroupBy
+
+**函数介绍**
+
+用于对列表进行分组操作，将列表按照指定的属性进行分组，以选中的属性为key，原项作为value生成Map，并返回生成的Map（映射）。
+
+<img src="../assets/liebiaoListhanshu_202501211815_10.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需分组操作的列表。可以是变量、逻辑、接口、内置函数等返回值为List的表达式。该选项参数支持除基础类型项组成的列表之外的所有列表。
+
+- by：用于指定分组操作的条件，根据不同的应用场景，有多种定义方式：
+
+  - 简单场景： 通过编辑表达式进行分组。该表达式可以是指定列表项中的某个属性。根据该表达式的值对列表元素进行分组。若列表项无属性，则该函数不生效。
+
+    <img src="../assets/liebiaoListhanshu_202501211815_11.png" class="imgStyle" style="" />
+
+  - 复杂场景：为满足更为复杂的筛选需求，可以通过添加子逻辑或服务端逻辑作为输入参数。具体细节可参考：[内置函数使用说明](../50.内置函数使用/03.内置函数使用说明.md)中的“适用场景” 相关描述 。
+  - 复用场景：若已有适用的服务端逻辑，可直接复用该逻辑作为输入参数，以提高开发效率。具体细节可参考：[内置函数使用说明](../50.内置函数使用/03.内置函数使用说明.md)中的“适用场景” 相关描述 。
+
+**输出参数**
+
+返回一个Map>，其中K是根据指定属性分组的键的数据类型，V是列表元素的数据类型。
+
+**示例**
+
+以所选的年龄属性为分组，年龄属性值为key，原列表项为value，生成列表的Map（映射）。
+
+前提条件：
+
+已有局部变量data，数据类型为`List<{student: Student }>`
+
+```json
+[ 
+    { student: Student { name: "张三", age: 18 } },
+    { student: Student { name: "李四", age: 18 } },
+    { student: Student { name: "王五", age: 20 } } 
+]
+```
+
+具体操作：
+
+<img src="../assets/liebiaoListhanshu_202501211815_12.png" class="imgStyle" style="" />
+
+调用函数后的返回结果为：
+
+```json
+{ 
+    18 -> [
+        { 
+         student: Student {
+          name: "张三", 
+          age: 18 
+          } 
+     },
+     {
+          student: Student { 
+          name: "李四", 
+          age: 18 
+          } 
+      } 
+    ],
+    20 -> [ 
+        { 
+        student: Student {
+         name: "王五", 
+         age: 20 
+         }
+      } 
+    ] 
+}
+```
+
+## Head
+
+**函数介绍**
+
+用于获取列表的首项并返回。
+
+<img src="../assets/liebiaoListhanshu_202407221820_33.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需获取首项的列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+
+**输出参数**
+
+- 输出列表的首项，数据类型为输入参数`List<T>`对应的T 类型。
+- 如果列表为空（即列表长度等于 0），则输出空值。
+
+**示例**
+
+局部变量exampleList数据类型为`List<String>`，内容为 ["A","B","C"]。
+
+获取列表首项。调用函数后的输出结果为“A”。
+
+<img src="../assets/liebiaoListhanshu_202407221820_34.png" class="imgStyle" style="" />
+
+## Insert
+
+**函数介绍**
+
+用于向指定列表的指定索引处插入新项，原索引项依次后推，会改变列表原数据，无返回值。
+
+<img src="../assets/liebiaoListhanshu_202407221820_35.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需插入新项的列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+
+- index：插入新项的索引位置，数据类型为Integer整型。用数字表示第几项，项数索引从0开始，第一个元素的索引位置为0，第二个元素的索引位置为1，以此类推。可以是变量、逻辑、接口、内置函数等返回值为Integer整型的表达式。
+
+- item：待插入的项。可以是变量、逻辑、接口、内置函数等返回值为输入参数list的数据类型`List<T>`对应的T类型的表达式。
+
+**输出参数**
+
+无
+
+**示例**
+
+局部变量exampleList数据类型为`List<String>`，内容为 ["B","C","D"]。
+
+在列表索引为1位置的前面插入新项D。Insert内置函数无返回值，调用后会改变列表原数据，此时调用函数后局部变量exampleList的内容会由 ["B","C","D"]变成 ["A","B","C","D"]。
+
+<img src="../assets/liebiaoListhanshu_202407221820_36.png" class="imgStyle" style="" />
+
+## Last
+
+**函数介绍**
+
+用于获取列表的最后一项并返回。
+
+<img src="../assets/liebiaoListhanshu_202407221820_37.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需获取项的列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+
+**输出参数**
+
+- 输出列表的最后一项，数据类型为输入参数`List<T>`对应的T 类型。
+- 如果列表为空（即列表长度等于 0），则输出空值。
+
+**示例**
+
+局部变量exampleList数据类型为`List<String>`，内容为 ["A","B","C"]。
+
+获取列表末尾项。调用函数后的返回结果为“C”。
+
+<img src="../assets/liebiaoListhanshu_202407221820_38.png" class="imgStyle" style="" />
+
+## Max
+
+**函数介绍**
+
+用于在参数list中查找最大值并返回，返回值数据类型与输入参数list中项数据类型一致。
+
+<img src="../assets/liebiaoListhanshu_202407221820_39.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：用于查找最大值的列表。可以是变量、逻辑、接口、内置函数等返回值`List<Integer整型>`或`List<Decimal小数>`或`List<String>`的表达式。
+
+**输出参数**
+
+输出列表中的最大值。如果列表为空（即列表长度等于 0 ），则输出空值。
+
+**示例**
+
+局部变量exampleList数据类型为`List<Integer整型>`，内容为 [3,2,4,1]。
+
+获取列表中的最大项。调用函数后的返回结果为4。
+
+<img src="../assets/liebiaoListhanshu_202407221820_40.png" class="imgStyle" style="" />
+
+## Min
+
+**函数介绍**
+
+用于在参数list中查找最小值并返回，返回值数据类型与输入参数list中项数据类型一致。
+
+<img src="../assets/liebiaoListhanshu_202407221820_41.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：用于查找最小值的列表。可以是变量、逻辑、接口、内置函数等返值为`List<Integer整型>`或`List<Decimal小数>`或`List<String>`的表达式。
+
+**输出参数**
+
+输出列表中的最小值。如果列表为空（即列表长度等于 0 ），则输出空值。
+
+**示例**
+
+局部变量exampleList数据类型为`List<Integer整型>`，内容为 [3,2,4,1]。
+
+获取列表中的最小项。调用函数后的返回结果为1。
+
+<img src="../assets/liebiaoListhanshu_202407221820_42.png" class="imgStyle" style="" />
+
+## Product
+
+**函数介绍**
+
+用于计算一组数值（即参数list中的各项）的乘积并返回，返回值类型与输入参数list中项的数据类型一致。例如，当输入参数为 `List<Integer>`时，返回值的数据类型为 Integer。
+
+<img src="../assets/liebiaoListhanshu_202407221820_43.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需要计算乘积的数值所在的列表。可以是变量、逻辑、接口、内置函数等返回值为`List<Integer整型>`或`List<Decimal小数>`的表达式。
+
+**输出参数**
+
+输出列表中所有数值的乘积。如果列表为空（即列表长度等于 0 ），则输出空值。
+
+**示例**
+
+局部变量exampleList数据类型为`List<Integer整型>`，内容为 [1,2,3,4]。
+
+获取列表中所有项的乘积。调用函数后的输出结果为24。
+
+<img src="../assets/liebiaoListhanshu_202407221820_44.png" class="imgStyle" style="" />
+
+## Range
+
+**函数介绍**
+
+用于生成指定范围内的整数列表。如果希望生成整数值都相同的列表，需要使用Repeat函数。
+
+<img src="../assets/listhanshu_202411051018_1.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- start：起始值，Integer类型，默认为0。
+- end：终止值，Integer类型，该数字不会包含在最终生成的列表中。
+- step：步长，Integer类型，默认为1。
+
+**输出参数**
+
+输出一个整数列表List，列表中的第一个值为start参数，其他的值以step为步长递增，列表中不会包含end值。
+
+**示例**
+
+从0开始，到5结束，步长为1，输出结果为`[0,1,2,3,4]`
+
+<img src="../assets/listhanshu_202411051018_2.png" class="imgStyle" style="" />
+
+
+## Remove
+
+**函数介绍**
+
+用于从列表或数组中删除指定的项,会改变列表原数据，无返回值。
+
+<img src="../assets/liebiaoListhanshu_202407221820_45.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需要从中删除元素的目标列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+- item：待删除的项。可以是变量、逻辑、接口、内置函数等返回值为输入参数list的数据类型`List<T>`对应的T类型的表达式。
+
+**输出参数**
+
+无
+
+**示例**
+
+局部变量exampleList数据类型为`List<String>`，内容为 ["A","B","C"]。
+
+删除列表项“B”。调用函数后的返回结果为 ["A","C"]。
+
+<img src="../assets/liebiaoListhanshu_202407221820_46.png" class="imgStyle" style="" />
+
+注意：Remove内置函数无返回值，使用该内置函数会改变原列表数据，如此时调用函数后局部变量exampleList的内容会由[“A”,“B”,“C”]变成[“A”,“C”]。
+
+## RemoveAt
+
+**函数介绍**
+
+用于从列表删除指定索引位置的项，会改变列表原数据，返回删除项内容。
+
+<img src="../assets/liebiaoListhanshu_202407221820_47.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需要从中删除项的目标列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+- index：待删除的项的索引位置，数据类型为Integer整型。用数字表示第几项，项数索引从0开始，第一个元素的索引位置为0，第二个元素的索引位置为1，以此类推。可以是变量、逻辑、接口、内置函数等返回值为Integer整数类型的表达式。
+
+**输出参数**
+
+输出被删除的项，如果指定的索引位置不存在（即索引值小于 0 或大于等于列表长度），则抛出 如“Error: 列表访问越界，访问下标 0，列表长度 0” 异常。
+
+**示例**
+
+局部变量exampleList数据类型为`List<String>`，内容为 ["A","B","C"]。
+
+删除索引位置为1的列表项，获取删除项内容。调用函数后的返回结果为“B”。
+
+<img src="../assets/liebiaoListhanshu_202407221820_48.png" class="imgStyle" style="" />
+
+注意：调用RemoveAt内置函数会改变列表原数据，如此时调用函数后局部变量exampleList的内容会由[“A”,“B”,“C”]变成[“A”,“C”]。
+
+## Repeat
+
+**函数介绍**
+
+创建n个重复元素的列表。
+
+<img src="../assets/listhanshu_202411051018_3.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- item：需要重复的元素。通常是基础类型，如果不是基础类型，则生成的元素都是同一个对象。
+
+    > 基础类型是指除Boolean、Integer、Decimal、String、Date、Time、DateTime以外的类型。
+
+- length：生成列表的长度，即重复的item数量。
+- type：item的数据类型，输入item参数后会自动推断type类型，也可以手动选择。
+
+**输出参数**
+
+输出包含重复元素的列表List，例如`[0,0,0,0,0]`、`["A","A","A"]`
+
+**示例**
+
+生成一个初始化的数字列表，每个元素都为100，长度为5。调用函数后的输出结果为`[100,100,100,100,100]`
+
+<img src="../assets/listhanshu_202411051018_4.png" class="imgStyle" style="" />
+
+
+## Reverse
+
+**函数介绍**
+
+用于将列表的项顺序反转排列，会改变列表原数据，并返回反转排列后的列表。另外，此类会更改原数据且有返回值的函数，既可以在逻辑线中直接使用，即时满足后续逻辑处理环节对于排序结果的需求；也可以将其返回值赋给特定的变量，以便后续进一步处理。
+
+<img src="../assets/liebiaoListhanshu_202411111803_4.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需要反转排列的目标列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+
+**输出参数**
+
+输出反转排列后的列表，列表的类型与输入的list参数的类型一致，即`List<T>`。
+
+<img src="../assets/liebiaoListhanshu_202411111803_5.png" class="imgStyle" style="" />
+
+**示例**
+
+前提条件：局部变量exampleList数据类型为`List<String>`，内容为`["A","B","C"]`。
+
+具体操作：调用函数将列表项反向排列。
+
+<img src="../assets/liebiaoListhanshu_202411111803_6.png" class="imgStyle" style="" />
+
+调用结果：Reverse内置函数，调用后会改变列表原数据，此时调用函数后局部变量exampleList的内容会由`["A","B","C"]`变成`["C","B","A"]`。
+
+## Set
+
+**函数介绍**
+
+用于替换列表中指定索引位置的项，并返回新项的内容。替换操作会修改原始列表的数据，新项将覆盖原索引位置上的项。
+
+<img src="../assets/liebiaoListhanshu_202407221820_51.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需要替换项的目标列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+
+
+
+- index：待替换项的索引位置，数据类型为Integer整数。用数字表示第几项，项数索引从0开始，第一个元素的索引位置为0，第二个元素的索引位置为1，以此类推。可以是变量、逻辑、接口、内置函数等返回值为Integer整数的表达式。
+
+
+
+- item：待赋值项的新项。可以是变量、逻辑、接口、内置函数等返回值为输入参数list的数据类型`List<T>`对应的T类型的表达式。
+
+**输出参数**
+
+输出新设置的项，如果指定的索引位置不存在（即索引值小于 0 或大于等于列表长度），则抛出 如“Error: 列表访问越界，访问下标 0，列表长度 0” 异常。
+
+**示例**
+
+局部变量exampleList数据类型为`List<String>`，内容为 ["A","B","C"]。
+
+在列表索引位置为1处赋值新的列表项“D”。调用函数后的返回结果为“D”。
+
+<img src="../assets/liebiaoListhanshu_202407221820_52.png" class="imgStyle" style="" />
+
+注意：使用内置函数Set会改变列表原数据，如此时调用函数后局部变量exampleList的内容会由 ["A","B","C"]变成 ["A","D","C"]。
+
+## Slice
+
+**函数介绍**
+
+用于将列表按照指定规则进行切片，返回切片后的子列表。例如将列表中的前几个或后几个元素展示为页面组件中的选项或标签。
+
+<img src="../assets/liebiaoListhanshu_202407221820_53.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需要切片的列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+- start：切片起始的索引位置，表示从该位置开始，数据类型为Integer整型。用数字表示第几项，项数索引从0开始，第一个元素的索引位置为0，第二个元素的索引位置为1，以此类推。可以是变量、逻辑、接口、内置函数等返回值为Integer整数的表达式。
+- end：切片结束的索引位置，表示到该位置前结束，数据类型为Integer整型。用数字表示第几项，项数索引从0开始，第一个元素的索引位置为0，第二个元素的索引位置为1，以此类推。可以是变量、逻辑、接口、内置函数等返回值为Integer整数的表达式。
+
+**输出参数**
+
+返回一个新的子列表，如果 start 或 end 超出列表的有效范围，会抛出 如“Error: 列表访问越界，访问下标 6，列表长度 5” 异常。如果 start 大于 end ，则返回一个空列表。
+
+**示例**
+
+局部变量exampleList数据类型为`List<Integer整型>`，内容为 [1,2,3,4,5]。
+
+获取列表中从索引位置2到索引位置4前结束的列表切片。调用函数后的返回结果为[3,4]。
+
+<img src="../assets/liebiaoListhanshu_202407221820_54.png" class="imgStyle" style="" />
+
+## Sort
+
+**函数介绍**
+
+用于将列表按指定规则排序，会改变列表原数据，并返回排序后的列表。例如，将列表数据按照字母顺序、数字大小或时间顺序进行排序。另外，此类会更改原数据且有返回值的函数，既可以在逻辑线中直接使用，即时满足后续逻辑处理环节对于排序结果的需求；也可以将其返回值赋给特定的变量，以便后续进一步处理。
+
+<img src="../assets/liebiaoListhanshu_202501211815_13.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- str1：需要排序的列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+- by：用于指定排序条件，根据不同的应用场景，有多种定义方式：
+
+  - 简单场景：通过编辑表达式进行排序条件设定。
+
+    - by：支持Boolean布尔值、Integer整数、Decimal小数、String 文本、Date 日期、Time 时间、DateTime 日期时间类型的表达式，可以是指定列表项中的某个属性或项本身，或者通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值的表达式。
+    - order：排序规则。支持升序或降序设置，默认为asc，asc为升序，desc为降序。
+
+    <img src="../assets/liebiaoListhanshu_202501211815_14.png" class="imgStyle" style="" />
+
+  - 复杂场景：为满足更为复杂的筛选需求，可以通过添加子逻辑或服务端逻辑作为输入参数。具体细节可参考：[内置函数使用说明](../50.内置函数使用/03.内置函数使用说明.md)中的“适用场景” 相关描述 。
+  - 复用场景：若已有适用的服务端逻辑，可直接复用该逻辑作为输入参数，以提高开发效率。具体细节可参考：[内置函数使用说明](../50.内置函数使用/03.内置函数使用说明.md)中的“适用场景” 相关描述 。
+
+
+
+- 添加排序规则：支持添加多条排序规则，实现依据一个或多个属性对数据进行排序操作，同时支持与子逻辑一同设置排序规则。例如，在处理在线商店商品数据时，可按照商品价格、过期时间等多维度因素依次排序，排序属性的主次顺序自上而下遵循所设定的顺序。
+
+    <img src="../assets/liebiaoListhanshu_202501211815_15.png" class="imgStyle" style="" />
+
+    <details>
+    <summary title="什么是NASL">
+    点击查看：关于 Sort 内置函数添加排序规则的使用示例
+    </summary>
+
+    假设有一个存储书籍信息的列表，每个元素是一个包含书籍名称、出版年份和评分的对象，结构为`{list: List<{ books: Books }>,total: Integer 整数}`，现在要先按照出版年份升序排序，对于出版年份相同的书籍再按照评分降序排序。
+
+    **数据示例**：
+
+    ```json
+    {
+        list: [
+            {
+                books: Books {
+                    id: 3094854803911424,
+                    createdTime: "2025-03-28 18:26:29",
+                    updatedTime: "2025-03-28 18:26:29",
+                    createdBy: （空）,
+                    updatedBy: （空）,
+                    title: "Book C",
+                    year: "2020",
+                    rating: 4
+                }
+            },
+            {
+                books: Books {
+                    id: 3094855022973696,
+                    createdTime: "2025-03-28 18:26:56",
+                    updatedTime: "2025-03-28 18:26:56",
+                    createdBy: （空）,
+                    updatedBy: （空）,
+                    title: "Book B",
+                    year: "2022",
+                    rating: 3
+                }
+            },
+            {
+                books: Books {
+                    id: 3094855144887040,
+                    createdTime: "2025-03-28 18:27:11",
+                    updatedTime: "2025-03-28 18:27:11",
+                    createdBy: （空）,
+                    updatedBy: （空）,
+                    title: "Book A",
+                    year: "2024",
+                    rating: 3
+                }
+            },
+            {
+                books: Books {
+                    id: 3094855326790400,
+                    createdTime: "2025-03-28 18:27:33",
+                    updatedTime: "2025-03-28 18:27:33",
+                    createdBy: （空）,
+                    updatedBy: （空）,
+                    title: "Book D",
+                    year: "2020",
+                    rating: 3
+                }
+            }
+        ],
+        total: 4
+    }
+    ```
+
+    **操作步骤**：
+
+    使用Sort函数添加排序规则
+
+    <img src="../assets/sortneizhihanshu_202503311038_1.png" class="imgStyle" style="" />
+
+    在上述图片中，sort方法接受一个比较函数。首先比较两本书的出版年份year，如果年份不同，就按照年份差值进行升序排序（差值为负时a在b前面，差值为正时b在a前面）。如果年份相同，再比较评分rating，通过b.rating - a.rating实现降序排序（即评分高的书排在前面）。
+
+    **排序后的数据示例**：
+
+    <img src="../assets/sortneizhihanshu_202503311038_2.png" class="imgStyle" style="" />
+
+
+    </details>
+
+**输出参数**
+
+输出经过排序后的列表，列表的类型与输入的list参数的类型一致，即`List<T>`。
+
+<img src="../assets/liebiaoListhanshu_202501211815_16.png" class="imgStyle" style="" />
+
+**示例**
+
+将商品数据按单价降序排列。
+
+局部变量data数据类型为`List<{product:Product}>`，存储数据如下：
+
+```json
+[
+    {
+        product: Product {
+            name: "娃哈哈",
+            price: 10,
+            type: "饮料",
+            stock: 996
+        }
+    },
+    {
+        product: Product {
+            name: "辣条",
+            price: 3.5,
+            type: "零食",
+            stock: 1000
+        }
+    },
+    {
+        product: Product {
+            name: "薯片",
+            price: 8,
+            type: "零食",
+            stock: 1000
+        }
+    }
+]
+```
+
+具体操作：调用函数Sort处理列表数据。
+
+<img src="../assets/liebiaoListhanshu_202501211815_17.png" class="imgStyle" style="" />
+
+调用结果：调用函数后data数据会按单价降序排列。
+
+```json
+[
+    {
+        product: Product {
+            name: "辣条",
+            price: 3.5,
+            type: "零食",
+            stock: 1000
+        }
+    },
+    {
+        product: Product {
+            name: "薯片",
+            price: 8,
+            type: "零食",
+            stock: 1000
+        }
+    },
+    {
+        product: Product {
+            name: "娃哈哈",
+            price: 10,
+            type: "饮料",
+            stock: 996
+        }
+    }
+]
+```
+
+## Sum
+
+**函数介绍**
+
+用于计算数值列表（即参数list） 中所有项的和，并返回`List<Integer整数>`或 `List<Decimal小数>`的结果，如果参数 list 内容为空，则返回null。例如，可以对数值型列表数据进行统计。
+
+<img src="../assets/liebiaoListhanshu_202407221820_59.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需要计算和的数值列表。可以是变量、逻辑、接口、内置函数等返回值为`List<Integer整数>`或`List<Decimal小数>`的表达式。
+
+**输出参数**
+
+输出列表中所有数值的和。如果列表为空（即列表长度等于 0 ），则输出空值。
+
+**示例**
+
+局部变量exampleList数据类型为`List<Integer整数>`，内容为`[1,2,3,4]`。
+
+获取列表中所有项的和。调用函数后的返回结果为10。
+
+<img src="../assets/liebiaoListhanshu_202407221820_60.png" class="imgStyle" style="" />
+
+
+## ToMap
+
+**函数介绍**
+
+用于选取列表的某些属性或自身作为 key、value，构成Map并返回，如果列表为空，则返回空Map。
+
+<img src="../assets/liebiaoListhanshu_202501211815_18.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需要转换为字典或映射的列表。可以是变量、逻辑、接口、内置函数等返回值为`List<T>`的表达式。
+- by：用于确定转换的规则，根据不同的应用场景，有多种定义方式：
+
+  - 简单场景：通过编辑表达式进行转换规则设定。可通过指定列表项中的某个属性或项本身，提取 key 和 value。例如， 对于一个存储学生信息的列表，其中每个元素是一个包含学生 `studentID`、`name` 和 `score` 的对象，可以使用表达式 `item.name` 来提取每个学生的名字，这里的 `item` 代表列表中的每一项，`item.name` 表示提取该项的 `name` 属性作为 `value`，而 `item` 本身的唯一标识可以作为 `key`，如学号`item.studentID`。
+
+    <img src="../assets/liebiaoListhanshu_202501211815_19.png" class="imgStyle" style="" />
+
+  - 复杂场景：为满足更为复杂的筛选需求，可以通过添加子逻辑或服务端逻辑作为输入参数。具体细节可参考：[内置函数使用说明](../50.内置函数使用/03.内置函数使用说明.md)中的“适用场景” 相关描述 。
+  - 复用场景：若已有适用的服务端逻辑，可直接复用该逻辑作为输入参数，以提高开发效率。具体细节可参考：[内置函数使用说明](../50.内置函数使用/03.内置函数使用说明.md)中的“适用场景” 相关描述 。
+
+**输出参数**
+
+输出一个`Map<K,V>`，其中K是根据指定规则提取的 key 的数据类型，V是根据指定规则提取的 value 的数据类型。如果输入的列表为空，则输出一个空的Map。
+
+**示例**
+
+将列表转换为字典或映射。
+
+局部变量data数据类型为`List<product: Product>`，存储数据如下：
+
+```json
+[
+    {
+        product: Product {
+            id: 2725431489665024,
+            name: "哇哈哈",
+            price: 9.9,
+            supplier: 2725430920697856,
+            type: "饮料"
+        }
+    },
+    {
+        product: Product {
+            id: 2725431614175232,
+            name: "果冻",
+            price: 6,
+            supplier: 2725431180892160,
+            type: "零食"
+        }
+    }
+]
+```
+
+具体操作：
+
+<img src="../assets/liebiaoListhanshu_202501211815_20.png" class="imgStyle" style="" />
+
+调用函数后的返回结果为`Map<String 文本, Decimal 小数>`类型，如下：
+
+```json
+{ "果冻" -> 6, "哇哈哈" -> 9.9 }
+```
+
+## Transform
+
+**函数介绍**
+
+用于根据by定义的处理方式对列表的每一项数据进行处理，得到新项，返回新项构成的列表。
+
+<img src="../assets/liebiaoListhanshu_202501211815_21.png" class="imgStyle" style="" />
+
+**输入参数**
+
+- list：需进行处理的列表。可以是变量、逻辑、接口、内置函数等返回值为List的表达式。
+- by：用于确定处理方式，根据不同的应用场景，有多种定义方式：
+  - 简单场景：通过编辑表达式进行处理方式设定。这个表达式可以是指定列表项中的某个属性，也可以是项本身，或者通过算数运算、比较运算或逻辑运算等对列表项进行操作，从而得出处理后的新项。例如，将列表的studentID和score属性组合成新结构`List<{studentID: Integer 整数,score: Decimal 小数}>`输出，实现对原列表数据的重新构建 。
+
+    <img src="../assets/liebiaoListhanshu_202501211815_22.png" class="imgStyle" style="" />
+
+  - 复杂场景：为满足更为复杂的筛选需求，可以通过添加子逻辑或服务端逻辑作为输入参数。具体细节可参考：[内置函数使用说明](../50.内置函数使用/03.内置函数使用说明.md)中的“适用场景” 相关描述 。
+  - 复用场景：若已有适用的服务端逻辑，可直接复用该逻辑作为输入参数，以提高开发效率。具体细节可参考：[内置函数使用说明](../50.内置函数使用/03.内置函数使用说明.md)中的“适用场景” 相关描述 。
+
+**输出参数**
+
+输出一个新的列表，其中包含对原始列表中每一项按照指定处理方式处理后得到的新项。如果输入的列表为空，则输出一个空列表。
+
+**示例**
+
+提取商品列表中的库存信息。
+
+局部变量data数据类型为`List<product: Product>`，存储商品数据如下：
+
+```json
+[
+    {
+        product: Product {
+            id: 3047331261616640,
+            createdTime: "2025-01-20 14:59:35",
+            updatedTime: "2025-01-20 15:11:16",
+            name: "薯片",
+            price: 10,
+            stock: 200
+        }
+    },
+    {
+        product: Product {
+            id: 3047344124908032,
+            createdTime: "2025-01-20 15:25:46",
+            updatedTime: "2025-01-20 15:25:46",
+            name: "可乐",
+            price: 29.9,
+            stock: 300
+        }
+    },
+    {
+        product: Product {
+            id: 3047344250073600,
+            createdTime: "2025-01-20 15:26:01",
+            updatedTime: "2025-01-20 15:26:01",
+            name: "大礼包",
+            price: 69.9,
+            stock: 1000
+        }
+    }
+]
+```
+
+具体操作：
+
+<img src="../assets/liebiaoListhanshu_202501211815_23.png" class="imgStyle" style="" />
+
+调用函数后的返回结果为`List<{name:String,stock:Integer}>`类型，如下：
+
+```json
+[
+    {
+        name: "薯片",
+        stock: 200
+    },
+    {
+        name: "可乐",
+        stock: 300
+    },
+    {
+        name: "大礼包",
+        stock: 1000
+    }
+]
+```
+
+
+<div style="text-align: right;font-size: 14px;">
+    <span style="color: rgb(78, 110, 142);">创建人：</span>
+    <span style="color: rgb(118, 118, 118);">小白</span>
+    <span style="color: rgb(78, 110, 142);margin: 0 0 0 40px;">更新时间：</span>
+    <span style="color: rgb(118, 118, 118);">2025年01月21日</span>
+</div>
+
+  <style>
+  .yellowBlock {
+    /* color: #FFFFFF; */
+    border-left-width: 0.5rem;
+    border-left-style: solid;
+    padding: 0.1rem 1.5rem;
+    margin:1rem 0;
+    background-color: #fcf5e1;
+    border-color: #eaaa08;
+  }
+  </style>