ArkTS 数组方法全解

const list = ['a', 'b', 'c'];
list.forEach((item, i) => {
  console.log(i, item);
});
// 0 a / 1 b / 2 c

val list = listOf("a", "b", "c")
list.forEach { println(it) }
list.forEachIndexed { i, item ->
  println("$i $item")
}

const nums = [1, 2, 3];
// 每个 ×2
const doubled = nums.map(n => n * 2);
// [2, 4, 6]，原 nums 不变

// 对象数组：提取字段
const names = users.map(u => u.name);

val nums = listOf(1, 2, 3)
val doubled = nums.map { it * 2 }   // [2,4,6]
val names = users.map { it.name }

const nums = [1, 2, 3, 4, 5];
const even = nums.filter(n => n % 2 === 0);
// [2, 4]

// 对象数组：过滤状态
const active = users.filter(u => u.id > 0);

val nums = listOf(1, 2, 3, 4, 5)
val even = nums.filter { it % 2 == 0 } // [2,4]
val active = users.filter { it.id > 0 }

const list: number[] = [1, 2];
const len = list.push(3);     // len = 3
list.push(4, 5);              // [1,2,3,4,5]
console.log(list);

val list = mutableListOf(1, 2)
list.add(3)             // 返回 Boolean
list.add(4); list.add(5)
// [1,2,3,4,5]

const user = users.find(u => u.id === 2);
// 找到 → {id:2,name:'Joy'}
// 没找到 → undefined（需判空！）

if (user !== undefined) {
  console.log(user.name);
}

// firstOrNull 等价 find
val user = users.find { it.id == 2 }
val u2 = users.firstOrNull { it.id == 2 }
// 没找到 → null（可 ?. 处理）

const idx = users.findIndex(u => u.id === 2);
// 2；没找到 → -1
if (idx !== -1) {
  users.splice(idx, 1);   // 删除该元素
}

val idx = users.indexOfFirst { it.id == 2 }
// -1 表示没找到
if (idx != -1) users.removeAt(idx)

const hasAdult = users.some(u => u.age >= 18);
// true / false

// 权限判断常见用法
const canEdit = roles.some(r => r === 'admin');

val hasAdult = users.any { it.age >= 18 }
val canEdit = roles.any { it == "admin" }

const allValid = users.every(u => u.name.length > 0);
// 表单/校验场景常用

val allValid = users.all { it.name.isNotEmpty() }

const tags = ['new', 'hot'];
if (tags.includes('hot')) { /* ... */ }

// 注意：对象按引用比较
const a = {x:1};
[{x:1}].includes(a);   // false（不同引用）

val tags = listOf("new", "hot")
if ("hot" in tags) { }   // 或
if (tags.contains("hot")) { }

const i = ['a','b','c'].indexOf('b'); // 1
const j = ['a','b'].indexOf('z');     // -1

// 从指定位置搜
const k = [1,2,1,2].indexOf(2, 2);    // 3

val i = listOf("a","b","c").indexOf("b") // 1
val j = listOf("a","b").indexOf("z")     // -1

let a = [1, 2, 3, 4];

a.splice(1, 1);        // 从索引1删1个 → a=[1,3,4]
a.splice(1, 0, 9);     // 索引1插9不删 → [1,9,3,4]
a.splice(2, 2, 7, 8);  // 删2个再插2个
                       // → [1,9,7,8]

val a = mutableListOf(1, 2, 3, 4)
a.removeAt(1)          // 删1个
a.add(1, 9)            // 索引1插9
a.subList(2, 4).clear()// 删区间
a.addAll(2, listOf(7,8))

const nums = [1, 2, 3, 4];
// 求和（init=0 是初始累加器）
const sum = nums.reduce((acc, n) => acc + n, 0); // 10

// 转成 Map（按 id 分组）
const byId = users.reduce((m, u) => {
  m[u.id] = u; return m;
}, {} as Record<number, User>);

val nums = listOf(1, 2, 3, 4)
val sum = nums.fold(0) { acc, n -> acc + n }
// 或 nums.sum()
val byId = users.associateBy { it.id }

const nums = [3, 1, 2];
nums.sort((a, b) => a - b);  // 升序 → [1,2,3]
nums.sort((a, b) => b - a);  // 降序

// 对象排序
users.sort((a, b) => a.id - b.id);

// ⚠️ 不传回调：按字符串排！
[10, 2, 1].sort();  // [1, 10, 2] 错！

val nums = listOf(3, 1, 2)
nums.sorted()                 // 新数组升序
nums.sortedByDescending { it }
users.sortedBy { it.id }     // 对象排序
// sorted() 返回新数组，不改原

const a = [1, 2, 3, 4, 5];
a.slice(1, 3);   // [2, 3]（不含索引3）
a.slice(2);      // [3, 4, 5]
const copy = a.slice();  // 整份浅拷贝

val a = listOf(1, 2, 3, 4, 5)
a.subList(1, 3)  // [2,3]（视图，改它会影响 a！）
a.take(3)        // 前3个，新列表
a.drop(2)        // 丢前2个

const a = [1, 2];
const b = [3, 4];
a.concat(b);          // [1,2,3,4]，a 不变
[...a, ...b];         // 展开写法（推荐）
[...a, 5];            // 追加单个元素

val a = listOf(1, 2)
val b = listOf(3, 4)
a + b                 // [1,2,3,4]
a + 5                 // [1,2,5]
a.plus(b)

['a', 'b', 'c'].join(',');     // "a,b,c"
['a', 'b'].join(' | ');        // "a | b"
[1, 2, 3].join('-');           // "1-2-3"

listOf("a","b","c").joinToString(",")
listOf("a","b").joinToString(" | ")
// joinToString 还能加 prefix/suffix
users.joinToString { it.name }

const a = [1, 2, 3];
a.reverse();        // a 变成 [3,2,1]
[...a].reverse();   // 不破坏原数组的写法

val a = listOf(1, 2, 3)
a.reversed()        // 返回新列表 [3,2,1]
a.asReversed()      // 视图

const a = [2, 3];
a.unshift(0, 1);    // a = [0,1,2,3]
console.log(a.length);

val a = mutableListOf(2, 3)
a.add(0, 0)        // 索引0插入
a.add(0, 1)

const a = [1, 2, 3];
const last = a.pop();   // last=3, a=[1,2]
const empty = [].pop(); // undefined

val a = mutableListOf(1, 2, 3)
val last = a.removeLast()   // 3, a=[1,2]
// 或 a.removeAt(a.lastIndex)

const a = [1, 2, 3];
const head = a.shift();  // head=1, a=[2,3]

val a = mutableListOf(1, 2, 3)
val head = a.removeFirst()  // 1, a=[2,3]

// Set → Array
const set = new Set([1, 2, 2]);
const arr = Array.from(set);   // [1, 2]

// Map 的 key 列表
const m = new Map([[1,'a'],[2,'b']]);
const keys = Array.from(m.keys()); // [1,2]

// 带映射：等于 from + map
const doubles = Array.from([1,2,3], n => n*2); // [2,4,6]

val set = setOf(1, 2, 2)
val arr = set.toList()        // [1,2]
val m = mapOf(1 to "a", 2 to "b")
val keys = m.keys.toList()    // [1,2]

const groups = [['a','b'], ['c']];
const flat = groups.flatMap(g => g);  // ['a','b','c']

// 经典：一对多展开
const tags = users.flatMap(u => u.tags);

val groups = listOf(listOf("a","b"), listOf("c"))
val flat = groups.flatMap { it }  // [a,b,c]
val tags = users.flatMap { it.tags }

[1, [2, 3]].flat();          // [1,2,3]
[1, [2, [3]]].flat(2);       // [1,2,3]
[1, [2, [3]]].flat(Infinity);// 彻底摊平

listOf(1, listOf(2, 3)).flatten()
// [1,2,3]

const a = new Array(3).fill(0);  // [0,0,0]
[1,2,3,4].fill(9, 1, 3);         // [1,9,9,4]

val a = MutableList(3) { 0 }     // [0,0,0]
val b = MutableList(4) { 1 }
b.fill(9, 1, 3)                  // [1,9,9,4]

const a = [10, 20, 30];
a.at(-1);   // 30（最后一个）
a.at(-2);   // 20
a.at(0);    // 10

val a = listOf(10, 20, 30)
a.last()        // 30
a[a.lastIndex]  // 30
// Kotlin 没有负索引，用 last()/get

const a = ['x', 'y'];
for (const [i, v] of a.entries()) {
  console.log(i, v);   // 0 x / 1 y
}
const idx = Array.from(a.keys());  // [0,1]
const vals = Array.from(a.values()); // ['x','y']

val a = listOf("x", "y")
for ((i, v) in a.withIndex()) {
  println("$i $v")
}
val idx = a.indices.toList()  // 0..1
val vals = a.toList()

// 把 [2,3) 复制到从索引0开始
[1, 2, 3, 4].copyWithin(0, 2, 4);
// → [3, 4, 3, 4]

// Kotlin 标准库无直接等价，
// 一般用 subList + addAll 组合实现

const s = ['a','b','c'].reduceRight(
  (acc, v) => acc + v, '');  // "cba"

listOf("a","b","c").foldRight("") { v, acc -> acc + v }
// "cba"

Array.of(1, 2, 3);   // [1,2,3]
Array.of(3);         // [3]
new Array(3);        // [empty×3] 长度3空位

arrayOf(1, 2, 3)     // [1,2,3]
// Kotlin 没「长度空位」歧义

Array.isArray([1, 2]);   // true
Array.isArray('hi');     // false

function handle(x: number[] | string) {
  if (Array.isArray(x)) {
    x.forEach(n => console.log(n));
  }
}

// Kotlin 用 is 运行时判断
fun handle(x: Any) {
  if (x is List<*>) {
    x.forEach { println(it) }
  }
}