Source: https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/for/
Documentation version: v5.3.2

# FOR

`FOR`语句通过遍历的方式展开列表或表中的所有元素，使得后续语句可以逐个处理这些元素。

如果多个`FOR`语句级联在一起，它们将生成相应列表或表中所有元素的笛卡尔积。

## 语法

语法图源码

 for_statement for_ordinality_or_offset  

````
for_statement ::=
        'FOR' variable_name 'IN' ( list_value_expression ('||' list_value_expression)* | table_reference_value_expression ) for_ordinality_or_offset?

for_ordinality_or_offset ::=
        ('WITH ORDINALITY' | 'WITH OFFSET') index_variable_name

````

## 参数

### `variable_name`

在遍历过程中指代列表或表中每个元素的变量名称。`variable_name`可以是常规标识符或使用反引号(```)包围的分隔标识符。有关标识符的更多信息，请参见[标识符命名规则](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/overview/keywords-identifiers/#_3)。

### `list_value_expression`

计算结果为列表或列表的引用的值表达式。可以是变量、函数调用或任何计算结果为列表的表达式。

更多信息，请参见[列表类型](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/data-types/list-type/)、[列表函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/list/)和[构造表达式](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/expressions/construct/)。

### `||`

用于将多个列表合并为一个列表的连接运算符。

### `table_reference_value_expression`

计算结果为表的引用的值表达式，例如[表变量](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/variable-definition/table-variable/)。

### `for_ordinality_or_offset`

用于在迭代期间为每个元素添加位置索引的可选子句。

#### `WITH ORDINALITY`

为列表或表中的每个元素返回基于 1 （从 1 开始）的索引的子句。

#### `WITH OFFSET`

为列表或表中的每个元素返回基于 0 （从 0 开始）的索引的子句。

#### `index_variable_name`

索引变量的名称，用于在迭代过程中保存当前元素的序号。

`index_variable_name`可以是常规标识符或使用反引号(```)包围的分隔标识符。有关标识符的更多信息，请参见[标识符命名规则](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/overview/keywords-identifiers/#_3)。

`index_variable_name`不能与`variable_name`相同。

## 示例

以下示例基于[示例数据集](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/overview/example-dataset/)。

### 展开列表

````
'''
LET l = list[1, 2, 3] 
FOR e IN l 
RETURN e
'''

````

上述语句展开列表`l`并返回结果集`e`。

返回：

````
+---+
| e |
+---+
| 1 |
| 2 |
| 3 |
+---+

````

### 展开嵌套列表

````
'''
LET ll = list[list[1, 2, 3], list[4, 5, 6]] 
FOR l IN ll 
FOR e IN l 
RETURN e
'''

````

上述语句首先展开嵌套列表`ll`，返回结果集`l`。然后展开列表`l`，返回结果集`e`。

返回：

````
+---+
| e |
+---+
| 1 |
| 2 |
| 3 |
| 4 |
| 5 |
| 6 |
+---+

````

### 展开两个列表

````
'''
LET l1 = list[1, 2, 3], l2 = list[4, 5, 6] 
FOR e1 IN l1 
FOR e2 IN l2 
RETURN e1, e2
'''

````

上述语句展开列表`l1`，返回结果集`e1`。然后展开列表`l2`，返回结果集`e2`。结果集`e1`和`e2`使用笛卡尔积进行组合。

返回：

````
+----+----+
| e1 | e2 |
+----+----+
| 1  | 4  |
| 1  | 5  |
| 1  | 6  |
| 2  | 4  |
| 2  | 5  |
| 2  | 6  |
| 3  | 4  |
| 3  | 5  |
| 3  | 6  |
+----+----+

````

### 展开由函数返回的列表

````
'''
USE movie 
MATCH p =  (v@Actor)-[]->(f@Movie{name:"Wilbur Wants to Kill Himself"})-[]->(g@Genre) 
LET sz = length(p), vid = v.id, l = range(1, length(p)) 
FOR e IN l 
RETURN DISTINCT sz, vid, l, e 
ORDER BY vid 
LIMIT 6
'''

````

上述语句执行以下操作：

1. 匹配从点`v`开始到点`g`结束的路径`p`。路径`p`包含两个边。
2. 使用`length()`计算路径`p`的长度并赋值给`sz`，将点`v`的 ID 赋值给`vid`，并使用`range()`生成一个始于 1 ，终于路径长度`p`的数字列表赋值给`l`。
3. 使用`FOR`语句展开列表`l`并返回结果集`e`。
4. 返回`sz`、`vid`、`l`和`e`，不包含重复项。
5. 按点`v`的 ID 对结果集进行排序，并将结果集限制为 6 行。

返回：

````
+----+------+-------+---+
| sz | vid  | l     | e |
+----+------+-------+---+
| 2  | 1019 | [1,2] | 2 |
| 2  | 1019 | [1,2] | 1 |
| 2  | 1643 | [1,2] | 1 |
| 2  | 1643 | [1,2] | 2 |
| 2  | 1833 | [1,2] | 2 |
| 2  | 1833 | [1,2] | 1 |
+----+------+-------+---+

````

### 展开两个由`||`连接的列表

````
'''
LET l1 = list[1, 2, 3], l2 = trim(list[4, 5, 6, 7], 2) 
FOR e IN l1 || l2 
RETURN e
'''

````

返回：

````
+---+
| e |
+---+
| 1 |
| 2 |
| 3 |
| 4 |
| 5 |
+---+

````

### 展开表格

````
'''
TABLE t { id, name, birthDate } =  
    ( 10001, 'Alice', DATE '1990-01-01' ),  
    ( 10002, 'Bob', DATE '1991-02-02' ),  
    ( 10003, 'Charlie', DATE '1992-03-03' ) 
FOR e IN t 
RETURN e.id, e.name, e.birthDate
'''

````

返回：

````
+-------+---------+-------------+
| e.id  | e.name  | e.birthDate |
+-------+---------+-------------+
| 10001 | Alice   | 1990-01-01  |
| 10002 | Bob     | 1991-02-02  |
| 10003 | Charlie | 1992-03-03  |
+-------+---------+-------------+

````

### 展开列表并返回从 1 开始的索引

````
'''
LET l=list[10, 20, 30] 
FOR e IN l WITH ORDINALITY idx 
RETURN e, idx
'''

````

返回：

````
+----+-----+
| e  | idx |
+----+-----+
| 10 | 1   |
| 20 | 2   |
| 30 | 3   |
+----+-----+

````

### 展开列表并返回从 0 开始的索引

````
'''
FOR i IN range(1, 10239) WITH OFFSET idx
RETURN i, idx
ORDER BY i ASC 
LIMIT 5
'''

````

返回：

````
+---+-----+
| i | idx |
+---+-----+
| 1 | 0   |
| 2 | 1   |
| 3 | 2   |
| 4 | 3   |
| 5 | 4   |
+---+-----+

````