Map类型常用属性与方法

Map类型常用属性与方法

Map属性文档

length

📏** length → **int

介绍: 返回Map中键值对的数量。
类似JS: Object.keys(map).length
示例:

Map<String, int> map = {'a': 1, 'b': 2, 'c': 3};
print(map.length); // 输出: 3

JS示例:

let map = {a: 1, b: 2, c: 3};
console.log(Object.keys(map).length); // 输出: 3

---

isEmpty

🔍** isEmpty → **bool

介绍: 检查Map是否为空（length为0）。
类似JS: Object.keys(map).length === 0
示例:

Map<String, int> emptyMap = {};
Map<String, int> normalMap = {'a': 1};
print(emptyMap.isEmpty); // 输出: true
print(normalMap.isEmpty); // 输出: false

JS示例:

let emptyMap = {};
let normalMap = {a: 1};
console.log(Object.keys(emptyMap).length === 0); // 输出: true
console.log(Object.keys(normalMap).length === 0); // 输出: false

---

isNotEmpty

🔍** isNotEmpty → **bool

介绍: 检查Map是否不为空（length > 0）。
类似JS: Object.keys(map).length > 0
示例:

Map<String, int> map = {'a': 1};
print(map.isNotEmpty); // 输出: true

Map<String, int> emptyMap = {};
print(emptyMap.isNotEmpty); // 输出: false

JS示例:

let map = {a: 1};
console.log(Object.keys(map).length > 0); // 输出: true

let emptyMap = {};
console.log(Object.keys(emptyMap).length > 0); // 输出: false

---

keys

🔑** keys → **Iterable<K>

介绍: 返回包含Map中所有键的可迭代对象。
类似JS: Object.keys()
示例:

Map<String, int> map = {'a': 1, 'b': 2, 'c': 3};
print(map.keys); // 输出: (a, b, c)
print(map.keys.toList()); // 输出: [a, b, c]

JS示例:

let map = {a: 1, b: 2, c: 3};
console.log(Object.keys(map)); // 输出: ['a', 'b', 'c']

---

values

📊** values → **Iterable<V>

介绍: 返回包含Map中所有值的可迭代对象。
类似JS: Object.values()
示例:

Map<String, int> map = {'a': 1, 'b': 2, 'c': 3};
print(map.values); // 输出: (1, 2, 3)
print(map.values.toList()); // 输出: [1, 2, 3]

JS示例:

let map = {a: 1, b: 2, c: 3};
console.log(Object.values(map)); // 输出: [1, 2, 3]

---

entries

🔗** entries → **Iterable<MapEntry<K, V>>

介绍: 返回包含Map中所有键值对的可迭代对象。
类似JS: Object.entries()
示例:

Map<String, int> map = {'a': 1, 'b': 2};
print(map.entries); // 输出: (MapEntry(a: 1), MapEntry(b: 2))

for (var entry in map.entries) {
  print('${entry.key}: ${entry.value}');
}
// 输出:
// a: 1
// b: 2

JS示例:

let map = {a: 1, b: 2};
console.log(Object.entries(map)); // 输出: [['a', 1], ['b', 2]]

for (let [key, value] of Object.entries(map)) {
  console.log(`${key}: ${value}`);
}
// 输出:
// a: 1
// b: 2

---

Map方法文档

[]

📥** [ ] 操作符 → **V?

介绍: 获取指定键对应的值，如果键不存在则返回null。
类似JS: object[key]
示例:

Map<String, int> map = {'a': 1, 'b': 2};
print(map['a']); // 输出: 1
print(map['c']); // 输出: null

JS示例:

let map = {a: 1, b: 2};
console.log(map['a']); // 输出: 1
console.log(map['c']); // 输出: undefined

---

[]=

📤** [ ]= 操作符**

介绍: 设置指定键的值，如果键不存在则添加新的键值对。
类似JS: object[key] = value
示例:

Map<String, int> map = {};
map['a'] = 1; // 添加新键值对
map['a'] = 10; // 修改已存在的键的值
print(map); // 输出: {a: 10}

JS示例:

let map = {};
map['a'] = 1; // 添加新键值对
map['a'] = 10; // 修改已存在的键的值
console.log(map); // 输出: {a: 10}

---

putIfAbsent

➕** putIfAbsent(K key, V ifAbsent()) → **V

介绍: 如果键不存在，则使用ifAbsent函数计算值并添加到Map中，返回该键的值。
类似JS: 需要手动实现
示例:

Map<String, int> map = {'a': 1, 'b': 2};
int value1 = map.putIfAbsent('a', () => 100); // 键已存在，返回当前值
print(value1); // 输出: 1
print(map); // 输出: {a: 1, b: 2}

int value2 = map.putIfAbsent('c', () => 3); // 键不存在，添加新键值对
print(value2); // 输出: 3
print(map); // 输出: {a: 1, b: 2, c: 3}

JS示例:

let map = {a: 1, b: 2};

function putIfAbsent(map, key, ifAbsent) {
    if (!(key in map)) {
        map[key] = ifAbsent();
    }
    return map[key];
}

let value1 = putIfAbsent(map, 'a', () => 100);
console.log(value1); // 输出: 1
console.log(map); // 输出: {a: 1, b: 2}

let value2 = putIfAbsent(map, 'c', () => 3);
console.log(value2); // 输出: 3
console.log(map); // 输出: {a: 1, b: 2, c: 3}

---

addAll

🔗** addAll(Map<K, V> other) → **void

介绍: 将另一个Map的所有键值对合并到当前Map中，重复的键会被覆盖。
类似JS: Object.assign() 或扩展运算符
示例:

Map<String, int> map1 = {'a': 1, 'b': 2};
Map<String, int> map2 = {'b': 20, 'c': 3};
map1.addAll(map2);
print(map1); // 输出: {a: 1, b: 20, c: 3}

JS示例:

let map1 = {a: 1, b: 2};
let map2 = {b: 20, c: 3};
Object.assign(map1, map2);
console.log(map1); // 输出: {a: 1, b: 20, c: 3}

// 或使用扩展运算符（创建新对象）
// let merged = {...map1, ...map2};

---

addEntries

🔗** addEntries(Iterable<MapEntry<K, V» newEntries) → **void

介绍: 将多个MapEntry键值对添加到Map中。
类似JS: 需要手动实现
示例:

Map<String, int> map = {'a': 1, 'b': 2};
var newEntries = [MapEntry('c', 3), MapEntry('d', 4)];
map.addEntries(newEntries);
print(map); // 输出: {a: 1, b: 2, c: 3, d: 4}

JS示例:

let map = {a: 1, b: 2};
let newEntries = [['c', 3], ['d', 4]];

function addEntries(map, entries) {
    for (let [key, value] of entries) {
        map[key] = value;
    }
}

addEntries(map, newEntries);
console.log(map); // 输出: {a: 1, b: 2, c: 3, d: 4}

---

remove

❌** remove(Object? key) → **V?

介绍: 删除指定键及其对应的值，返回被删除的值，如果键不存在则返回null。
类似JS: delete 操作符
示例:

Map<String, int> map = {'a': 1, 'b': 2, 'c': 3};
int? removedValue = map.remove('b');
print(removedValue); // 输出: 2
print(map); // 输出: {a: 1, c: 3}

int? notFound = map.remove('x');
print(notFound); // 输出: null

JS示例:

let map = {a: 1, b: 2, c: 3};
delete map['b'];
console.log(map); // 输出: {a: 1, c: 3}

// 注意：JS的delete操作符返回boolean，表示是否成功删除

---

clear

🧹** clear() → **void

介绍: 清空Map，删除所有键值对。
类似JS: 手动清空对象
示例:

Map<String, int> map = {'a': 1, 'b': 2, 'c': 3};
print(map.length); // 输出: 3
map.clear();
print(map.length); // 输出: 0
print(map); // 输出: {}

JS示例:

let map = {a: 1, b: 2, c: 3};
console.log(Object.keys(map).length); // 输出: 3

// 清空对象
for (let key in map) {
    if (map.hasOwnProperty(key)) {
        delete map[key];
    }
}
// 或直接重新赋值
// map = {};
console.log(Object.keys(map).length); // 输出: 0

---

containsKey

🔍** containsKey(Object? key) → **bool

介绍: 检查Map是否包含指定的键。
类似JS: in 操作符或 hasOwnProperty()
示例:

Map<String, int> map = {'a': 1, 'b': 2};
print(map.containsKey('a')); // 输出: true
print(map.containsKey('c')); // 输出: false

JS示例:

let map = {a: 1, b: 2};
console.log('a' in map); // 输出: true
console.log('c' in map); // 输出: false
// 或使用 hasOwnProperty
console.log(map.hasOwnProperty('a')); // 输出: true

---

containsValue

🔍** containsValue(Object? value) → **bool

介绍: 检查Map是否包含指定的值。
类似JS: Object.values() 结合 includes()
示例:

Map<String, int> map = {'a': 1, 'b': 2, 'c': 3};
print(map.containsValue(2)); // 输出: true
print(map.containsValue(5)); // 输出: false

JS示例:

let map = {a: 1, b: 2, c: 3};
console.log(Object.values(map).includes(2)); // 输出: true
console.log(Object.values(map).includes(5)); // 输出: false

---

forEach

🔄** forEach(void action(K key, V value)) → **void

介绍: 遍历Map中的每个键值对，对每个元素执行指定的操作。
类似JS: Object.entries() 结合 forEach()
示例:

Map<String, int> map = {'a': 1, 'b': 2, 'c': 3};
map.forEach((key, value) {
  print('$key: $value');
});
// 输出:
// a: 1
// b: 2
// c: 3

JS示例:

let map = {a: 1, b: 2, c: 3};
Object.entries(map).forEach(([key, value]) => {
    console.log(`${key}: ${value}`);
});
// 输出:
// a: 1
// b: 2
// c: 3

---

update

🔄** update(K key, V update(V value), {V ifAbsent()?}) → **V

介绍: 更新指定键的值，如果键不存在且提供了ifAbsent函数，则添加新键值对。
类似JS: 需要手动实现
示例:

Map<String, int> map = {'a': 1, 'b': 2};

// 更新已存在的键
int newValue = map.update('a', (value) => value * 10);
print(newValue); // 输出: 10
print(map); // 输出: {a: 10, b: 2}

// 更新不存在的键（使用ifAbsent）
int addedValue = map.update('c', (value) => value * 10, ifAbsent: () => 30);
print(addedValue); // 输出: 30
print(map); // 输出: {a: 10, b: 2, c: 30}

JS示例:

let map = {a: 1, b: 2};

function update(map, key, updateFn, ifAbsent) {
    if (key in map) {
        map[key] = updateFn(map[key]);
    } else if (ifAbsent) {
        map[key] = ifAbsent();
    }
    return map[key];
}

let newValue = update(map, 'a', value => value * 10);
console.log(newValue); // 输出: 10
console.log(map); // 输出: {a: 10, b: 2}

let addedValue = update(map, 'c', value => value * 10, () => 30);
console.log(addedValue); // 输出: 30
console.log(map); // 输出: {a: 10, b: 2, c: 30}

---

updateAll

🔄** updateAll(V update(K key, V value)) → **void

介绍: 批量更新Map中所有键值对的值。
类似JS: 需要手动实现
示例:

Map<String, int> map = {'a': 1, 'b': 2, 'c': 3};
map.updateAll((key, value) => value * 2);
print(map); // 输出: {a: 2, b: 4, c: 6}

// 根据键名进行条件更新
map.updateAll((key, value) {
  if (key == 'a') return value * 10;
  if (key == 'b') return value + 5;
  return value;
});
print(map); // 输出: {a: 20, b: 9, c: 6}

JS示例:

let map = {a: 1, b: 2, c: 3};

function updateAll(map, updateFn) {
    for (let key in map) {
        if (map.hasOwnProperty(key)) {
            map[key] = updateFn(key, map[key]);
        }
    }
}

updateAll(map, (key, value) => value * 2);
console.log(map); // 输出: {a: 2, b: 4, c: 6}

updateAll(map, (key, value) => {
    if (key === 'a') return value * 10;
    if (key === 'b') return value + 5;
    return value;
});
console.log(map); // 输出: {a: 20, b: 9, c: 6}

---

removeWhere

❌** removeWhere(bool test(K key, V value)) → **void

介绍: 删除所有满足测试条件的键值对。
类似JS: 需要手动实现
示例:

Map<String, int> map = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5};
map.removeWhere((key, value) => value > 3);
print(map); // 输出: {a: 1, b: 2, c: 3}

map.removeWhere((key, value) => key == 'b');
print(map); // 输出: {a: 1, c: 3}

JS示例:

let map = {a: 1, b: 2, c: 3, d: 4, e: 5};

function removeWhere(map, test) {
    for (let key in map) {
        if (map.hasOwnProperty(key) && test(key, map[key])) {
            delete map[key];
        }
    }
}

removeWhere(map, (key, value) => value > 3);
console.log(map); // 输出: {a: 1, b: 2, c: 3}

removeWhere(map, (key, value) => key === 'b');
console.log(map); // 输出: {a: 1, c: 3}

---

map

🗺️** map<K2, V2>(MapEntry<K2, V2> transform(K key, V value)) → **Map<K2, V2>

介绍: 遍历每个键值对并根据转换函数创建新的Map。
类似JS: Object.entries() 结合 map() 和 Object.fromEntries()
示例:

Map<String, int> original = {'a': 1, 'b': 2, 'c': 3};

// 键值对调
Map<int, String> swapped = original.map((key, value) => MapEntry(value, key));
print(swapped); // 输出: {1: a, 2: b, 3: c}

// 转换键和值
Map<String, String> transformed = original.map((key, value) => 
  MapEntry(key.toUpperCase(), (value * 10).toString())
);
print(transformed); // 输出: {A: 10, B: 20, C: 30}

JS示例:

let original = {a: 1, b: 2, c: 3};

// 键值对调
let swapped = Object.fromEntries(
    Object.entries(original).map(([key, value]) => [value, key])
);
console.log(swapped); // 输出: {1: 'a', 2: 'b', 3: 'c'}

// 转换键和值
let transformed = Object.fromEntries(
    Object.entries(original).map(([key, value]) => 
        [key.toUpperCase(), (value * 10).toString()]
    )
);
console.log(transformed); // 输出: {A: '10', B: '20', C: '30'}

---

cast

🔄** cast<K2, V2>() → **Map<K2, V2>

介绍: 将Map的泛型类型提升为其父类或祖类。
类似JS: 无直接对应（JS是动态类型）
示例:

Map<String, int> specificMap = {'a': 1, 'b': 2};
Map<Object, Object> generalMap = specificMap.cast<Object, Object>();
generalMap['c'] = 'hello'; // 可以添加不同类型的值
print(generalMap); // 输出: {a: 1, b: 2, c: hello}

JS示例:

// JavaScript 是动态类型，无需类型转换
let map = {a: 1, b: 2};
map['c'] = 'hello'; // 直接添加不同类型的值
console.log(map); // 输出: {a: 1, b: 2, c: 'hello'}

---

补充说明

注意事项

1. Map类型: Dart中的Map主要有HashMap、LinkedHashMap和SplayTreeMap等实现
2. 键的唯一性: Map中的键必须是唯一的，重复的键会导致值被覆盖
3. 空安全: 使用[]操作符访问不存在的键会返回null
4. 遍历修改: 在forEach遍历过程中不能添加或删除键值对

常用开发场景

// 1. Map的创建和初始化
Map<String, dynamic> user = {
  'name': '张三',
  'age': 25,
  'email': 'zhangsan@example.com'
};

// 2. 安全访问和默认值
String userName = user['name'] ?? '未知用户';
int userAge = user['age'] ?? 0;

// 3. 数据转换和处理
Map<String, String> stringifiedUser = user.map((key, value) => 
  MapEntry(key, value.toString())
);

// 4. 过滤和筛选
Map<String, dynamic> adultUsers = Map.from(user)
  ..removeWhere((key, value) => key == 'age' && value < 18);

// 5. 合并多个Map
Map<String, dynamic> baseConfig = {'debug': false, 'version': '1.0.0'};
Map<String, dynamic> userConfig = {'debug': true, 'theme': 'dark'};
Map<String, dynamic> finalConfig = {}..addAll(baseConfig)..addAll(userConfig);

// JavaScript 对应示例
// 1. 对象的创建和初始化
let user = {
    name: '张三',
    age: 25,
    email: 'zhangsan@example.com'
};

// 2. 安全访问和默认值
let userName = user.name || '未知用户';
let userAge = user.age || 0;

// 3. 数据转换和处理
let stringifiedUser = Object.fromEntries(
    Object.entries(user).map(([key, value]) => [key, String(value)])
);

// 4. 过滤和筛选
let adultUsers = {...user};
if (adultUsers.age < 18) {
    delete adultUsers.age;
}

// 5. 合并多个对象
let baseConfig = {debug: false, version: '1.0.0'};
let userConfig = {debug: true, theme: 'dark'};
let finalConfig = {...baseConfig, ...userConfig};