# 玄铁数组编程指南
> 类型详情页:[数组](关键字/数组.md)
数组是玄铁最常用的集合类型，支持动态扩容、索引访问、丰富的内置方法，以及通过标准库获得的函数式高阶操作。
---
### 创建与初始化
```xuantie
设 空数组 = [] // 空数组
设 数字 = [1, 2, 3, 4, 5] // 整数数组
设 混合 = [1, "hello", 真] // 数组可容纳不同类型的元素
```
---
### 索引访问
使用 `[索引]` 读写数组元素，索引从 0 开始：
```xuantie
设 列表 = [10, 20, 30]
示(列表[0]) // 10
示(列表[1]) // 20
列表[1] = 99 // 修改元素
示(列表[1]) // 99
```
---
### 属性
| 属性 | 写法 | 说明 |
|------|------|------|
| 长度 | `列表.长度` | 返回数组元素个数（整数值） |
```xuantie
设 列表 = [1, 2, 3]
示(列表.长度) // 3
```
---
### 内置方法
> 方法名可跳转类型详情页:[数组](关键字/数组.md)
| 方法 | 写法 | 说明 |
|------|------|------|
| [追加](关键字/数组.md) | `列表.追加(元素)` | 在末尾追加一个元素 |
| [删](关键字/数组.md) | `列表.删(索引)` | 删除指定索引处的元素 |
| [插](关键字/数组.md) | `列表.插(索引, 元素)` | 在指定索引处插入元素 |
| [找](关键字/数组.md) | `列表.找(元素)` | 查找元素，返回索引（找不到返回 -1） |
| [含?](关键字/数组.md) | `列表.含?(元素)` | 判断是否包含某元素，返回布尔值 |
| [包含?](关键字/数组.md) | `列表.包含?(元素)` | 同 `含?`，别名 |
| [连接](关键字/数组.md) | `列表.连接(分隔符)` | 用分隔符连接所有元素为字符串 |
```xuantie
设 列表 = [1, 2, 3]
列表.追加(4) // [1, 2, 3, 4]
示(列表.长度) // 4
列表.删(1) // 删除索引 1 → [1, 3, 4]
示(列表.长度) // 3
列表.插(1, 99) // [1, 99, 3, 4]
设 位置 = 列表.找(99) // 返回 1
设 位置 = 列表.找(100) // 返回 -1（未找到）
若 列表.含?(3) { 示("有 3") } // "有 3"
设 串 = 列表.连接(", ") // "1, 99, 3, 4"
```
---
### 遍历数组
```xuantie
// 方式一：按索引遍历
设 列表 = [10, 20, 30]
设 i = 0
当 i < 列表.长度 {
示(列表[i])
i = i + 1
}
// 方式二：遍历循环（推荐）
遍历 元素 于 列表 {
示(元素)
}
```
---
### 高阶方法（标准库）
通过引入 `lib/数组.xt` 标准库获得函数式编程能力（下表各方法均有独立小节，点击可跳转）：
```xuantie
引 "../lib/数组.xt" 予 A
设 数字 = [1, 2, 3, 4, 5]
```
#### 映射
对每个元素应用变换函数，返回新数组。
```xuantie
设 平方 = A.映射(数字, 函(x) { 返 x * x })
// 平方 → [1, 4, 9, 16, 25]
```
#### 过滤
保留满足谓词条件的元素，返回新数组。
```xuantie
设 偶数 = A.过滤(数字, 函(x) { 返 x % 2 == 0 })
// 偶数 → [2, 4]
```
#### 归纳
从左到右累积，类似其他语言的 reduce/fold。
```xuantie
设 总和 = A.归纳(数字, 0, 函(累计, x) { 返 累计 + x })
// 总和 → 15
```
#### 查找
返回第一个满足谓词的元素，找不到返回 `空`。
```xuantie
设 大值 = A.查找(数字, 函(x) { 返 x > 3 })
// 大值 → 4
```
#### 每个?
所有元素都满足谓词时返回 `真`。
```xuantie
A.每个?(数字, 函(x) { 返 x > 0 }) // 真
A.每个?(数字, 函(x) { 返 x % 2 == 0 }) // 假
```
#### 存在?
至少一个元素满足谓词时返回 `真`。
```xuantie
A.存在?(数字, 函(x) { 返 x > 4 }) // 真
```
#### 排序
冒泡排序，原地修改数组并返回。
```xuantie
设 乱序 = [3, 1, 4, 1, 5]
A.排序(乱序, 函(a, b) { 返 a - b })
// 乱序 → [1, 1, 3, 4, 5]
```
> 比较函返回正数表示 a > b（需交换），返回 0 或负数表示不需交换。
#### 去重
返回去除重复元素后的新数组。
```xuantie
设 去重后 = A.去重([1, 2, 2, 3, 3, 3])
// 去重后 → [1, 2, 3]
```
#### 反转
返回元素顺序颠倒的新数组。
```xuantie
设 反转后 = A.反转([1, 2, 3])
// 反转后 → [3, 2, 1]
```
---
### 完整示例
```xuantie
引 "../lib/数组.xt" 予 A
示("--- 数组高阶方法完整示例 ---")
设 数据 = [5, 2, 8, 2, 1, 9, 3]
// 1. 去重 → 排序 → 过滤偶数 → 映射平方
设 去重数据 = A.去重(数据)
A.排序(去重数据, 函(a, b) { 返 a - b })
示("去重排序后: " & 去重数据.连接(", "))
设 偶数 = A.过滤(去重数据, 函(x) { 返 x % 2 == 0 })
示("偶数: " & 偶数.连接(", "))
设 平方 = A.映射(偶数, 函(x) { 返 x * x })
示("平方: " & 平方.连接(", "))
// 2. 统计
设 总和 = A.归纳(数据, 0, 函(累计, x) { 返 累计 + x })
设 有大值 = A.存在?(数据, 函(x) { 返 x > 7 })
示("总和: #{总和}, 存在>7: #{有大值}")
```
输出：
```xuantie
--- 数组高阶方法完整示例 ---
去重排序后: 1, 2, 3, 5, 8, 9
偶数: 2, 8
平方: 4, 64
总和: 30, 存在>7: 真
```
---
*上一篇：[05_模块系统.md](./05_模块系统.md)*