> ## Documentation Index
> Fetch the complete documentation index at: https://fluxon.tabooproject.org/llms.txt
> Use this file to discover all available pages before exploring further.

# List 扩展函数

> 列表操作、遍历、转换等扩展方法

List 扩展函数通过上下文调用语法 `::` 使用，提供集合操作能力。

## 基础属性

| 方法          | 说明        |
| ----------- | --------- |
| `size()`    | 返回列表长度。   |
| `isEmpty()` | 检查列表是否为空。 |

```fluxon theme={null}
[1, 2, 3] :: size()       # => 3
[] :: isEmpty()           # => true
[1] :: isEmpty()          # => false
```

## 元素访问

| 方法           | 说明                     |
| ------------ | ---------------------- |
| `get(index)` | 获取指定索引的元素。             |
| `first()`    | 获取第一个元素，空列表返回 `null`。  |
| `last()`     | 获取最后一个元素，空列表返回 `null`。 |

```fluxon theme={null}
[1, 2, 3] :: get(0)       # => 1
[1, 2, 3] :: first()      # => 1
[1, 2, 3] :: last()       # => 3
[] :: first()             # => null
```

也可以使用索引访问语法：

```fluxon theme={null}
list = [1, 2, 3]
&list[0]                  # => 1
&list[2]                  # => 3
```

## 元素修改（可变列表）

以下方法仅适用于可变列表：

| 方法                     | 说明                |
| ---------------------- | ----------------- |
| `set(index, value)`    | 设置指定索引的元素。        |
| `add(value)`           | 在末尾添加元素。          |
| `add(index, value)`    | 在指定位置插入元素。        |
| `remove(index)`        | 移除指定索引的元素并返回。     |
| `removeElement(value)` | 移除首个匹配的元素，返回是否成功。 |
| `clear()`              | 清空列表。             |

```fluxon theme={null}
list = mutableList([1, 2, 3])
list :: add(4)            # list = [1, 2, 3, 4]
list :: set(0, 10)        # list = [10, 2, 3, 4]
list :: remove(1)         # => 2, list = [10, 3, 4]
list :: clear()           # list = []
```

## 查找与包含

| 方法                     | 说明                      |
| ---------------------- | ----------------------- |
| `contains(element)`    | 检查是否包含指定元素。             |
| `indexOf(element)`     | 返回元素首次出现的索引，未找到返回 `-1`。 |
| `lastIndexOf(element)` | 返回元素最后一次出现的索引。          |

```fluxon theme={null}
[1, 2, 3, 2] :: contains(2)      # => true
[1, 2, 3, 2] :: indexOf(2)       # => 1
[1, 2, 3, 2] :: lastIndexOf(2)   # => 3
[1, 2, 3] :: contains(5)         # => false
```

## 遍历与转换

| 方法                           | 说明               |
| ---------------------------- | ---------------- |
| `forEach(action)`            | 对每个元素执行操作。       |
| `map(transform)`             | 转换每个元素，返回新列表。    |
| `filter(predicate)`          | 过滤元素，返回满足条件的新列表。 |
| `reduce(initial, operation)` | 将列表归约为单个值。       |
| `flatMap(transform)`         | 转换并展平结果。         |

```fluxon theme={null}
[1, 2, 3] :: forEach(fn(x) { print(&x) })

# map 转换
[1, 2, 3] :: map(fn(x) { &x * 2 })        # => [2, 4, 6]

# filter 过滤
[1, 2, 3, 4, 5] :: filter(fn(x) { &x % 2 == 0 })  # => [2, 4]

# reduce 归约
[1, 2, 3, 4] :: reduce(0, fn(acc, x) { &acc + &x })  # => 10

# flatMap 展平
[[1, 2], [3, 4]] :: flatMap(fn(x) { &x })  # => [1, 2, 3, 4]
```

## 排序与反转

| 方法                   | 说明               |
| -------------------- | ---------------- |
| `sorted()`           | 返回排序后的新列表（自然顺序）。 |
| `sortedBy(selector)` | 按指定键排序，返回新列表。    |
| `sortedDescending()` | 返回降序排序后的新列表。     |
| `reversed()`         | 返回反转后的新列表。       |

```fluxon theme={null}
[3, 1, 2] :: sorted()             # => [1, 2, 3]
[3, 1, 2] :: sortedDescending()   # => [3, 2, 1]
[1, 2, 3] :: reversed()           # => [3, 2, 1]

# 按属性排序
users :: sortedBy(fn(u) { &u.age })
```

## 切片与分组

| 方法                | 说明         |
| ----------------- | ---------- |
| `take(n)`         | 取前 n 个元素。  |
| `drop(n)`         | 跳过前 n 个元素。 |
| `slice(from, to)` | 切片（左闭右开）。  |
| `chunked(size)`   | 按指定大小分组。   |
| `distinct()`      | 去重，返回新列表。  |

```fluxon theme={null}
[1, 2, 3, 4, 5] :: take(3)        # => [1, 2, 3]
[1, 2, 3, 4, 5] :: drop(2)        # => [3, 4, 5]
[1, 2, 3, 4, 5] :: slice(1, 4)    # => [2, 3, 4]
[1, 2, 3, 4, 5] :: chunked(2)     # => [[1, 2], [3, 4], [5]]
[1, 2, 2, 3, 3] :: distinct()     # => [1, 2, 3]
```

## 聚合

| 方法                 | 说明           |
| ------------------ | ------------ |
| `sum()`            | 数值列表求和。      |
| `average()`        | 数值列表求平均值。    |
| `min()`            | 返回最小元素。      |
| `max()`            | 返回最大元素。      |
| `count(predicate)` | 统计满足条件的元素数量。 |

```fluxon theme={null}
[1, 2, 3, 4, 5] :: sum()          # => 15
[1, 2, 3, 4, 5] :: average()      # => 3.0
[3, 1, 4, 1, 5] :: min()          # => 1
[3, 1, 4, 1, 5] :: max()          # => 5
[1, 2, 3, 4, 5] :: count(fn(x) { &x > 2 })  # => 3
```

## 条件检查

| 方法                | 说明             |
| ----------------- | -------------- |
| `any(predicate)`  | 检查是否有任意元素满足条件。 |
| `all(predicate)`  | 检查是否所有元素都满足条件。 |
| `none(predicate)` | 检查是否没有元素满足条件。  |

```fluxon theme={null}
[1, 2, 3] :: any(fn(x) { &x > 2 })   # => true
[1, 2, 3] :: all(fn(x) { &x > 0 })   # => true
[1, 2, 3] :: none(fn(x) { &x < 0 })  # => true
```

## 连接

| 方法                                 | 说明             |
| ---------------------------------- | -------------- |
| `join()`                           | 将元素连接为字符串。     |
| `join(separator)`                  | 使用指定分隔符连接。     |
| `join(separator, prefix, postfix)` | 使用分隔符、前缀、后缀连接。 |

```fluxon theme={null}
[1, 2, 3] :: join()               # => "123"
[1, 2, 3] :: join(", ")           # => "1, 2, 3"
[1, 2, 3] :: join(", ", "[", "]") # => "[1, 2, 3]"
```

## 相关链接

* [String 扩展函数](/language/extensions/string)
* [Map 扩展函数](/language/extensions/map)
* [控制流（循环）](/language/control-flow#循环)
* [字面量与类型](/language/literals-and-types)