List类型常用属性与方法
List类型常用属性与方法
List类型常用属性与方法
List 属性文档
length
📏** length → **int
介绍: 返回 List 中元素的数量。
类似JS: Array.prototype.length
示例:
1
2
List<String> fruits = ['apple', 'banana', 'orange'];
print(fruits.length); // 输出: 3
JS示例:
1
2
let fruits = ['apple', 'banana', 'orange'];
console.log(fruits.length); // 输出: 3
isEmpty
🔍** isEmpty → **bool
介绍: 检查 List 是否为空（length 为 0）。
类似JS: Array.prototype.length === 0
示例:
1
2
3
4
5
List<int> numbers = [];
print(numbers.isEmpty); // 输出: true
List<String> names = ['John'];
print(names.isEmpty); // 输出: false
JS示例:
1
2
3
4
5
let numbers = [];
console.log(numbers.length === 0); // 输出: true
let names = ['John'];
console.log(names.length === 0); // 输出: false
isNotEmpty
🔍** isNotEmpty → **bool
介绍: 检查 List 是否不为空（length > 0）。
类似JS: Array.prototype.length > 0
示例:
1
2
3
4
5
List<String> items = ['item1'];
print(items.isNotEmpty); // 输出: true
List<int> emptyList = [];
print(emptyList.isNotEmpty); // 输出: false
JS示例:
1
2
3
4
5
let items = ['item1'];
console.log(items.length > 0); // 输出: true
let emptyList = [];
console.log(emptyList.length > 0); // 输出: false
reversed
🔄** reversed → **Iterable<E>
介绍: 返回一个包含原 List 元素反转顺序的新 Iterable。
类似JS: Array.prototype.reverse()（但 Dart 返回 Iterable，JS 直接修改原数组）
是否修改原List: ❌ 不修改原 List
区别: Dart 中 reversed 返回 Iterable，不修改原 List；JS 的 reverse() 直接修改原数组
示例:
1
2
3
4
List<int> numbers = [1, 2, 3];
var reversedNumbers = numbers.reversed;
print(reversedNumbers.toList()); // 输出: [3, 2, 1]
print(numbers); // 原List不变: [1, 2, 3]
JS示例:
1
2
3
4
let numbers = [1, 2, 3];
let reversedNumbers = [...numbers].reverse(); // 创建副本避免修改原数组
console.log(reversedNumbers); // 输出: [3, 2, 1]
console.log(numbers); // 原数组不变: [1, 2, 3]
first
🥇** first → **E
介绍: 获取 List 的第一个元素。
类似JS: array[0]
示例:
1
2
3
4
5
6
List<String> colors = ['red', 'green', 'blue'];
print(colors.first); // 输出: red
// 空List访问first会抛出异常
List<int> empty = [];
// print(empty.first); // 会抛出StateError
JS示例:
1
2
3
4
5
let colors = ['red', 'green', 'blue'];
console.log(colors[0]); // 输出: red
let empty = [];
console.log(empty[0]); // 输出: undefined
last
🥇** last → **E
介绍: 获取 List 的最后一个元素。
类似JS: array[array.length - 1] 或 array.at(-1)
示例:
1
2
3
4
5
List<int> scores = [90, 85, 95, 88];
print(scores.last); // 输出: 88
List<String> single = ['only'];
print(single.last); // 输出: only
JS示例:
1
2
3
4
5
6
let scores = [90, 85, 95, 88];
console.log(scores[scores.length - 1]); // 输出: 88
console.log(scores.at(-1)); // 输出: 88
let single = ['only'];
console.log(single[single.length - 1]); // 输出: only
List 方法文档
add
➕** add(E value) → **void
介绍: 在 List 末尾添加一个元素。
类似JS: Array.prototype.push()
是否修改原List: ✅ 修改原 List
示例:
1
2
3
List<String> shoppingList = ['milk', 'bread'];
shoppingList.add('eggs');
print(shoppingList); // 输出: [milk, bread, eggs]
JS示例:
1
2
3
let shoppingList = ['milk', 'bread'];
shoppingList.push('eggs');
console.log(shoppingList); // 输出: ['milk', 'bread', 'eggs']
addAll
➕** addAll(Iterable**** iterable) → ****void**
介绍: 将另一个 Iterable 的所有元素添加到 List 末尾。
类似JS: Array.prototype.push(...items) 或 Array.prototype.concat()
是否修改原List: ✅ 修改原 List
区别: JS 的 concat 返回新数组，addAll 直接修改原 List
示例:
1
2
3
4
5
6
7
8
List<String> fruits = ['apple', 'banana'];
List<String> moreFruits = ['orange', 'grape'];
fruits.addAll(moreFruits);
print(fruits); // 输出: [apple, banana, orange, grape]
// 也可以添加其他Iterable
fruits.addAll(['kiwi', 'mango']);
print(fruits); // 输出: [apple, banana, orange, grape, kiwi, mango]
JS示例:
1
2
3
4
5
6
7
8
let fruits = ['apple', 'banana'];
let moreFruits = ['orange', 'grape'];
fruits.push(...moreFruits);
console.log(fruits); // 输出: ['apple', 'banana', 'orange', 'grape']
// 使用 concat（返回新数组）
let newFruits = fruits.concat(['kiwi', 'mango']);
console.log(newFruits); // 输出: ['apple', 'banana', 'orange', 'grape', 'kiwi', 'mango']
insert
📥** insert(int index, E element) → **void
介绍: 在指定索引位置插入一个元素。
类似JS: Array.prototype.splice(index, 0, item)
是否修改原List: ✅ 修改原 List
示例:
1
2
3
4
5
6
7
List<int> numbers = [1, 3, 4];
numbers.insert(1, 2); // 在索引1处插入2
print(numbers); // 输出: [1, 2, 3, 4]
// 在开头插入
numbers.insert(0, 0);
print(numbers); // 输出: [0, 1, 2, 3, 4]
JS示例:
1
2
3
4
5
6
7
let numbers = [1, 3, 4];
numbers.splice(1, 0, 2); // 在索引1处插入2
console.log(numbers); // 输出: [1, 2, 3, 4]
// 在开头插入
numbers.splice(0, 0, 0);
console.log(numbers); // 输出: [0, 1, 2, 3, 4]
insertAll
📥** insertAll(int index, Iterable**** iterable) → ****void**
介绍: 在指定索引位置插入另一个 Iterable 的所有元素。
类似JS: Array.prototype.splice(index, 0, ...items)
是否修改原List: ✅ 修改原 List
示例:
1
2
3
List<String> colors = ['red', 'blue', 'yellow'];
colors.insertAll(1, ['green', 'purple']);
print(colors); // 输出: [red, green, purple, blue, yellow]
JS示例:
1
2
3
let colors = ['red', 'blue', 'yellow'];
colors.splice(1, 0, ...['green', 'purple']);
console.log(colors); // 输出: ['red', 'green', 'purple', 'blue', 'yellow']
remove
❌** remove(Object? value) → **bool
介绍: 移除 List 中第一个出现的指定元素，成功返回 true。
类似JS: 无直接对应，可用 Array.prototype.indexOf() + splice() 实现
是否修改原List: ✅ 修改原 List
示例:
1
2
3
4
5
6
7
8
List<String> fruits = ['apple', 'banana', 'orange', 'banana'];
bool removed = fruits.remove('banana');
print(removed); // 输出: true
print(fruits); // 输出: [apple, orange, banana] - 只删除了第一个banana
// 移除不存在的元素
bool notFound = fruits.remove('grape');
print(notFound); // 输出: false
JS示例:
1
2
3
4
5
6
7
8
9
10
11
12
13
let fruits = ['apple', 'banana', 'orange', 'banana'];
let index = fruits.indexOf('banana');
let removed = index !== -1;
if (removed) {
fruits.splice(index, 1);
}
console.log(removed); // 输出: true
console.log(fruits); // 输出: ['apple', 'orange', 'banana'] - 只删除了第一个banana
// 移除不存在的元素
let notFoundIndex = fruits.indexOf('grape');
let notFound = notFoundIndex !== -1;
console.log(notFound); // 输出: false
removeAt
❌** removeAt(int index) → **E
介绍: 移除指定索引位置的元素，并返回该元素。
类似JS: Array.prototype.splice(index, 1)[0]
是否修改原List: ✅ 修改原 List
示例:
1
2
3
4
List<String> languages = ['Dart', 'JavaScript', 'Python', 'Java'];
String removedLanguage = languages.removeAt(1);
print(removedLanguage); // 输出: JavaScript
print(languages); // 输出: [Dart, Python, Java]
JS示例:
1
2
3
4
let languages = ['Dart', 'JavaScript', 'Python', 'Java'];
let removedLanguage = languages.splice(1, 1)[0];
console.log(removedLanguage); // 输出: JavaScript
console.log(languages); // 输出: ['Dart', 'Python', 'Java']
removeLast
❌** removeLast() → **E
介绍: 移除并返回 List 的最后一个元素。
类似JS: Array.prototype.pop()
是否修改原List: ✅ 修改原 List
示例:
1
2
3
4
List<int> stack = [1, 2, 3, 4];
int lastItem = stack.removeLast();
print(lastItem); // 输出: 4
print(stack); // 输出: [1, 2, 3]
JS示例:
1
2
3
4
let stack = [1, 2, 3, 4];
let lastItem = stack.pop();
console.log(lastItem); // 输出: 4
console.log(stack); // 输出: [1, 2, 3]
removeRange
❌** removeRange(int start, int end) → **void
介绍: 移除从 start（包含）到 end（不包含）索引范围内的所有元素。
类似JS: Array.prototype.splice(start, end - start)
是否修改原List: ✅ 修改原 List
示例:
1
2
3
List<int> numbers = [1, 2, 3, 4, 5, 6];
numbers.removeRange(1, 4); // 移除索引1到3的元素
print(numbers); // 输出: [1, 5, 6]
JS示例:
1
2
3
let numbers = [1, 2, 3, 4, 5, 6];
numbers.splice(1, 3); // 移除索引1开始的3个元素
console.log(numbers); // 输出: [1, 5, 6]
removeWhere
❌** removeWhere(bool test(E element)) → **void
介绍: 移除所有满足测试条件的元素。
类似JS: 需要组合使用，如赋值 array = array.filter()，但 Dart 是直接修改原数组
是否修改原List: ✅ 修改原 List
区别: JS 的 filter 返回新数组，removeWhere 直接修改原 List
示例:
1
2
3
List<int> numbers = [1, 2, 3, 4, 5, 6];
numbers.removeWhere((number) => number % 2 == 0); // 移除所有偶数
print(numbers); // 输出: [1, 3, 5]
JS示例:
1
2
3
4
let numbers = [1, 2, 3, 4, 5, 6];
// JS 需要重新赋值，不能直接修改原数组
numbers = numbers.filter(number => number % 2 !== 0);
console.log(numbers); // 输出: [1, 3, 5]
clear
🧹** clear() → **void
介绍: 清空 List，移除所有元素。
类似JS: Array.prototype.length = 0 或 Array.prototype.splice(0)
是否修改原List: ✅ 修改原 List
示例:
1
2
3
4
5
List<String> tasks = ['task1', 'task2', 'task3'];
print(tasks.length); // 输出: 3
tasks.clear();
print(tasks.length); // 输出: 0
print(tasks); // 输出: []
JS示例:
1
2
3
4
5
let tasks = ['task1', 'task2', 'task3'];
console.log(tasks.length); // 输出: 3
tasks.length = 0; // 或 tasks.splice(0)
console.log(tasks.length); // 输出: 0
console.log(tasks); // 输出: []
indexOf
🔎** indexOf(E element, [int start = 0]) → **int
介绍: 从 start 处开始查找指定元素，返回其第一次出现的索引，未找到返回 -1。
类似JS: Array.prototype.indexOf()
是否修改原List: ❌ 不修改原 List
示例:
1
2
3
List<String> fruits = ['apple', 'banana', 'orange', 'banana'];
print(fruits.indexOf('banana')); // 输出: 1
print(fruits.indexOf('banana', 2)); // 从索引2开始查找，输出: 3
JS示例:
1
2
3
let fruits = ['apple', 'banana', 'orange', 'banana'];
console.log(fruits.indexOf('banana')); // 输出: 1
console.log(fruits.indexOf('banana', 2)); // 从索引2开始查找，输出: 3
lastIndexOf
🔎** lastIndexOf(E element, [int? start]) → **int
介绍: 从后往前查找指定元素，返回其最后一次出现的索引。
类似JS: Array.prototype.lastIndexOf()
是否修改原List: ❌ 不修改原 List
示例:
1
2
3
List<String> items = ['a', 'b', 'c', 'a', 'b'];
print(items.lastIndexOf('a')); // 输出: 3
print(items.lastIndexOf('b')); // 输出: 4
JS示例:
1
2
3
let items = ['a', 'b', 'c', 'a', 'b'];
console.log(items.lastIndexOf('a')); // 输出: 3
console.log(items.lastIndexOf('b')); // 输出: 4
contains
✅** contains(Object? element) → **bool
介绍: 判断 List 是否包含某个元素。
类似JS: Array.prototype.includes()
是否修改原List: ❌ 不修改原 List
区别: JS 的 includes 是 ES2016 新增，Dart 一直有 contains
示例:
1
2
3
List<String> colors = ['red', 'green', 'blue'];
print(colors.contains('green')); // 输出: true
print(colors.contains('yellow')); // 输出: false
JS示例:
1
2
3
let colors = ['red', 'green', 'blue'];
console.log(colors.includes('green')); // 输出: true
console.log(colors.includes('yellow')); // 输出: false
elementAt
📍** elementAt(int index) → **E
介绍: 获取指定索引位置的元素，功能等同于 list[index]。
类似JS: array[index]
是否修改原List: ❌ 不修改原 List
示例:
1
2
3
List<int> numbers = [10, 20, 30, 40];
print(numbers.elementAt(2)); // 输出: 30
print(numbers[2]); // 同样输出: 30
JS示例:
1
2
let numbers = [10, 20, 30, 40];
console.log(numbers[2]); // 输出: 30
any
🔍** any(bool test(E element)) → **bool
介绍: 检查 List 中是否至少有一个元素满足给定的测试条件。
类似JS: Array.prototype.some()
是否修改原List: ❌ 不修改原 List
示例:
1
2
3
List<int> numbers = [1, 2, 3, 4, 5];
print(numbers.any((n) => n > 3)); // 输出: true
print(numbers.any((n) => n > 10)); // 输出: false
JS示例:
1
2
3
let numbers = [1, 2, 3, 4, 5];
console.log(numbers.some(n => n > 3)); // 输出: true
console.log(numbers.some(n => n > 10)); // 输出: false
every
✅** every(bool test(E element)) → **bool
介绍: 检查 List 中是否所有元素都满足给定的测试条件。
类似JS: Array.prototype.every()
是否修改原List: ❌ 不修改原 List
示例:
1
2
3
4
5
List<int> numbers = [2, 4, 6, 8];
print(numbers.every((n) => n % 2 == 0)); // 输出: true
List<int> mixedNumbers = [2, 4, 5, 8];
print(mixedNumbers.every((n) => n % 2 == 0)); // 输出: false
JS示例:
1
2
3
4
5
let numbers = [2, 4, 6, 8];
console.log(numbers.every(n => n % 2 === 0)); // 输出: true
let mixedNumbers = [2, 4, 5, 8];
console.log(mixedNumbers.every(n => n % 2 === 0)); // 输出: false
sublist
✂️** sublist(int start, [int? end]) → **List<E>
介绍: 返回一个新的 List，包含从 start（包含）到 end（不包含）之间的元素。
类似JS: Array.prototype.slice()
是否修改原List: ❌ 不修改原 List
区别: JS 的 slice 第二个参数也是包含的，Dart 的 sublist 不包含 end
示例:
1
2
3
List<String> colors = ['red', 'green', 'blue', 'yellow', 'purple'];
print(colors.sublist(1, 3)); // 输出: [green, blue]
print(colors.sublist(2)); // 输出: [blue, yellow, purple]
JS示例:
1
2
3
let colors = ['red', 'green', 'blue', 'yellow', 'purple'];
console.log(colors.slice(1, 3)); // 输出: ['green', 'blue']
console.log(colors.slice(2)); // 输出: ['blue', 'yellow', 'purple']
getRange
📊** getRange(int start, int end) → **Iterable<E>
介绍: 获取从 start（包含）到 end（不包含）索引范围内的元素，返回一个 Iterable。
类似JS: Array.prototype.slice() 但返回 Iterable 而非数组
是否修改原List: ❌ 不修改原 List
示例:
1
2
3
4
List<int> numbers = [1, 2, 3, 4, 5];
var range = numbers.getRange(1, 4);
print(range); // 输出: (2, 3, 4)
print(range.toList()); // 转换为List: [2, 3, 4]
JS示例:
1
2
3
let numbers = [1, 2, 3, 4, 5];
let range = numbers.slice(1, 4);
console.log(range); // 输出: [2, 3, 4]
setRange
🔄** setRange(int start, int end, Iterable**** iterable, [int skipCount = 0]) → ****void**
介绍: 将指定索引范围 [start, end) 的元素，替换为另一个 Iterable 中的元素。
类似JS: 无直接对应，可用循环实现
是否修改原List: ✅ 修改原 List
示例:
1
2
3
List<int> numbers = [1, 2, 3, 4, 5];
numbers.setRange(1, 4, [10, 20, 30]);
print(numbers); // 输出: [1, 10, 20, 30, 5]
JS示例:
1
2
3
4
5
6
let numbers = [1, 2, 3, 4, 5];
let newValues = [10, 20, 30];
for (let i = 1, j = 0; i < 4 && j < newValues.length; i++, j++) {
numbers[i] = newValues[j];
}
console.log(numbers); // 输出: [1, 10, 20, 30, 5]
fillRange
🎨** fillRange(int start, int end, [E? fillValue]) → **void
介绍: 将指定索引范围 [start, end) 的元素设置为 fillValue。
类似JS: Array.prototype.fill()
是否修改原List: ✅ 修改原 List
区别: JS 的 fill 可以只传一个值，Dart 必须指定范围
示例:
1
2
3
List<int> numbers = [1, 2, 3, 4, 5];
numbers.fillRange(1, 4, 0);
print(numbers); // 输出: [1, 0, 0, 0, 5]
JS示例:
1
2
3
let numbers = [1, 2, 3, 4, 5];
numbers.fill(0, 1, 4);
console.log(numbers); // 输出: [1, 0, 0, 0, 5]
replaceRange
🔄** replaceRange(int start, int end, Iterable**** replacements) → ****void**
介绍: 将指定索引范围 [start, end) 的元素，替换为 replacements 中的元素。
类似JS: Array.prototype.splice(start, deleteCount, ...replacements)
是否修改原List: ✅ 修改原 List
示例:
1
2
3
List<String> items = ['a', 'b', 'c', 'd', 'e'];
items.replaceRange(1, 4, ['x', 'y', 'z']);
print(items); // 输出: [a, x, y, z, e]
JS示例:
1
2
3
let items = ['a', 'b', 'c', 'd', 'e'];
items.splice(1, 3, 'x', 'y', 'z');
console.log(items); // 输出: ['a', 'x', 'y', 'z', 'e']
sort
🔄** sort([int compare(E a, E b)?]) → **void
介绍: 对 List 的元素进行排序。可自定义比较函数，默认按自然顺序升序排列。
类似JS: Array.prototype.sort()
是否修改原List: ✅ 修改原 List
区别: Dart 的比较函数返回 int（负数/0/正数），JS 返回 boolean
示例:
1
2
3
4
5
6
7
List<int> numbers = [3, 1, 4, 1, 5, 9, 2];
numbers.sort();
print(numbers); // 输出: [1, 1, 2, 3, 4, 5, 9]
// 自定义排序：降序
numbers.sort((a, b) => b.compareTo(a));
print(numbers); // 输出: [9, 5, 4, 3, 2, 1, 1]
JS示例:
1
2
3
4
5
6
7
let numbers = [3, 1, 4, 1, 5, 9, 2];
numbers.sort();
console.log(numbers); // 输出: [1, 1, 2, 3, 4, 5, 9]
// 自定义排序：降序
numbers.sort((a, b) => b - a);
console.log(numbers); // 输出: [9, 5, 4, 3, 2, 1, 1]
shuffle
🎲** shuffle([Random? random]) → **void
介绍: 随机打乱 List 中元素的顺序。
类似JS: 需要自定义实现，无内置方法
是否修改原List: ✅ 修改原 List
示例:
1
2
3
List<int> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9];
numbers.shuffle();
print(numbers); // 输出随机顺序，如: [3, 8, 1, 6, 4, 2, 9, 5, 7]
JS示例:
1
2
3
4
5
6
7
let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9];
// Fisher-Yates 洗牌算法
for (let i = numbers.length - 1; i > 0; i--) {
const j = Math.floor(Math.random() * (i + 1));
[numbers[i], numbers[j]] = [numbers[j], numbers[i]];
}
console.log(numbers); // 输出随机顺序，如: [3, 8, 1, 6, 4, 2, 9, 5, 7]
asMap
🗺️** asMap() → **Map<int, E>
介绍: 将 List 转换为一个 Map，其中键是元素的索引，值是元素本身。
类似JS: 无直接对应，需要手动实现
是否修改原List: ❌ 不修改原 List
示例:
1
2
3
List<String> colors = ['red', 'green', 'blue'];
Map<int, String> colorMap = colors.asMap();
print(colorMap); // 输出: {0: red, 1: green, 2: blue}
JS示例:
1
2
3
4
5
6
let colors = ['red', 'green', 'blue'];
let colorMap = {};
colors.forEach((color, index) => {
colorMap[index] = color;
});
console.log(colorMap); // 输出: {0: 'red', 1: 'green', 2: 'blue'}
toSet
🎯** toSet() → **Set<E>
介绍: 将 List 转换为一个 Set，会自动去除重复元素。
类似JS: new Set(array)
是否修改原List: ❌ 不修改原 List
区别: JS 的 Set 是不同数据结构，Dart 的 toSet() 返回 Set 但用法类似
示例:
1
2
3
List<int> numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4];
Set<int> uniqueNumbers = numbers.toSet();
print(uniqueNumbers); // 输出: {1, 2, 3, 4}
JS示例:
1
2
3
4
let numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4];
let uniqueNumbers = new Set(numbers);
console.log(uniqueNumbers); // 输出: Set {1, 2, 3, 4}
console.log([...uniqueNumbers]); // 转换为数组: [1, 2, 3, 4]
join
🔗** join([String separator = “”]) → **String
介绍: 将 List 中的每个元素转换为 String 并用分隔符连接，返回一个字符串。
类似JS: Array.prototype.join()
是否修改原List: ❌ 不修改原 List
示例:
1
2
3
4
List<String> words = ['Hello', 'World', 'Dart'];
print(words.join()); // 输出: HelloWorldDart
print(words.join(' ')); // 输出: Hello World Dart
print(words.join(', ')); // 输出: Hello, World, Dart
JS示例:
1
2
3
4
let words = ['Hello', 'World', 'Dart'];
console.log(words.join()); // 输出: HelloWorldDart
console.log(words.join(' ')); // 输出: Hello World Dart
console.log(words.join(', ')); // 输出: Hello, World, Dart
followedBy
➕** followedBy(Iterable**** other) → ****Iterable
介绍: 返回当前 List 与另一个 Iterable 连接后的 Iterable。
类似JS: 无直接对应，可用扩展运算符 [...array1, ...array2]
是否修改原List: ❌ 不修改原 List
区别: followedBy 返回 Iterable，不立即创建新 List
示例:
1
2
3
4
List<int> list1 = [1, 2, 3];
List<int> list2 = [4, 5, 6];
var combined = list1.followedBy(list2);
print(combined.toList()); // 输出: [1, 2, 3, 4, 5, 6]
JS示例:
1
2
3
4
let list1 = [1, 2, 3];
let list2 = [4, 5, 6];
let combined = [...list1, ...list2];
console.log(combined); // 输出: [1, 2, 3, 4, 5, 6]
map
🗺️** map****(T f(E e)) → ****Iterable
介绍: 将 List 中的每个元素按函数 f 进行转换，返回包含所有转换后元素的 Iterable。
类似JS: Array.prototype.map()
是否修改原List: ❌ 不修改原 List
示例:
1
2
3
List<int> numbers = [1, 2, 3, 4, 5];
var squared = numbers.map((n) => n * n);
print(squared.toList()); // 输出: [1, 4, 9, 16, 25]
JS示例:
1
2
3
let numbers = [1, 2, 3, 4, 5];
let squared = numbers.map(n => n * n);
console.log(squared); // 输出: [1, 4, 9, 16, 25]
where
🔍** where(bool test(E element)) → **Iterable<E>
介绍: 返回一个包含所有满足测试条件元素的 Iterable。
类似JS: Array.prototype.filter()
是否修改原List: ❌ 不修改原 List
示例:
1
2
3
List<int> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var evenNumbers = numbers.where((n) => n % 2 == 0);
print(evenNumbers.toList()); // 输出: [2, 4, 6, 8, 10]
JS示例:
1
2
3
let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let evenNumbers = numbers.filter(n => n % 2 === 0);
console.log(evenNumbers); // 输出: [2, 4, 6, 8, 10]
expand
🔄** expand****(Iterable**** f(E element)) → ****Iterable
介绍: 将每个元素扩展为零个或多个元素。
类似JS: Array.prototype.flatMap()
是否修改原List: ❌ 不修改原 List
示例:
1
2
3
List<String> phrases = ['hello world', 'dart programming'];
var words = phrases.expand((phrase) => phrase.split(' '));
print(words.toList()); // 输出: [hello, world, dart, programming]
JS示例:
1
2
3
let phrases = ['hello world', 'dart programming'];
let words = phrases.flatMap(phrase => phrase.split(' '));
console.log(words); // 输出: ['hello', 'world', 'dart', 'programming']
fold
🧮** fold****(T initialValue, T combine(T previousValue, E element)) → ****T**
介绍: 将 List 的每个元素按函数进行组合，从一个初始值开始，返回一个单一的最终结果。
类似JS: Array.prototype.reduce() 但有初始值
是否修改原List: ❌ 不修改原 List
区别: JS 的 reduce 初始值可选，Dart 的 fold 必须提供初始值
示例:
1
2
3
List<int> numbers = [1, 2, 3, 4, 5];
int sum = numbers.fold(0, (previous, element) => previous + element);
print(sum); // 输出: 15
JS示例:
1
2
3
let numbers = [1, 2, 3, 4, 5];
let sum = numbers.reduce((previous, element) => previous + element, 0);
console.log(sum); // 输出: 15
reduce
🧮** reduce(E combine(E value, E element)) → **E
介绍: 用指定的函数连续地将 List 的元素组合起来，返回一个单一的结果。
类似JS: Array.prototype.reduce()
是否修改原List: ❌ 不修改原 List
区别: reduce 不能为空列表，fold 可以
示例:
1
2
3
4
5
6
7
List<int> numbers = [1, 2, 3, 4, 5];
int sum = numbers.reduce((value, element) => value + element);
print(sum); // 输出: 15
// 注意：空列表会抛出异常
List<int> emptyList = [];
// int result = emptyList.reduce((a, b) => a + b); // 会抛出StateError
JS示例:
1
2
3
4
5
6
7
let numbers = [1, 2, 3, 4, 5];
let sum = numbers.reduce((value, element) => value + element);
console.log(sum); // 输出: 15
// 注意：空数组会抛出异常
let emptyList = [];
// let result = emptyList.reduce((a, b) => a + b); // 会抛出TypeError
补充说明
注意事项
- 空 List 访问：访问
first、last或对空 List 使用reduce()会抛出异常 - 索引越界：访问不存在的索引会抛出
RangeError - 性能考虑：对于大型 List，考虑使用
Iterable方法链式操作而非多次修改原 List - 不可变 List：如果使用
const创建的 List，所有修改方法都会抛出异常
常用开发场景
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 1. 列表筛选和转换
List<int> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
List<int> evenSquares = numbers
.where((n) => n % 2 == 0)
.map((n) => n * n)
.toList();
print(evenSquares); // 输出: [4, 16, 36, 64, 100]
// 2. 列表去重
List<String> duplicates = ['a', 'b', 'a', 'c', 'b', 'd'];
List<String> unique = duplicates.toSet().toList();
print(unique); // 输出: ['a', 'b', 'c', 'd']
// 3. 列表排序
List<String> names = ['John', 'Alice', 'Bob', 'Charlie'];
names.sort();
print(names); // 输出: ['Alice', 'Bob', 'Charlie', 'John']
// 4. 列表分组
List<int> scores = [85, 92, 78, 95, 88, 72];
List<int> highScores = scores.where((score) => score >= 90).toList();
print(highScores); // 输出: [92, 95]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// JavaScript 对应示例
// 1. 数组筛选和转换
let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let evenSquares = numbers
.filter(n => n % 2 === 0)
.map(n => n * n);
console.log(evenSquares); // 输出: [4, 16, 36, 64, 100]
// 2. 数组去重
let duplicates = ['a', 'b', 'a', 'c', 'b', 'd'];
let unique = [...new Set(duplicates)];
console.log(unique); // 输出: ['a', 'b', 'c', 'd']
// 3. 数组排序
let names = ['John', 'Alice', 'Bob', 'Charlie'];
names.sort();
console.log(names); // 输出: ['Alice', 'Bob', 'Charlie', 'John']
// 4. 数组分组
let scores = [85, 92, 78, 95, 88, 72];
let highScores = scores.filter(score => score >= 90);
console.log(highScores); // 输出: [92, 95]