```dart
var gifts = {
  'first' : 'partridge',
  'second': 'turtledoves',
  'fifth' : 'golden rings'
};

var gifts = new Map();
gifts['first'] = 'partridge';
gifts['second'] = 'turtledoves';
gifts['fifth'] = 'golden rings';

var gifts = {'first': 'partridge'};
gifts['fourth'] = 'calling birds';

final constantMap = const {
  2: 'helium',
  10: 'neon',
  18: 'argon',
};

var pages = <String, String>{
  'index.html': 'Homepage',
  'robots.txt': 'Hints for web robots',
  'humans.txt': 'We are people, not machines'
};
```

## 从 map 中删除 key 和 value

```dart
// 使用中括号来访问或者设置 map 中的数据，
// 使用 remove() 函数来从 map 中删除 key 和 value。
var nobleGases = {54: 'xenon'};
// Retrieve a value with a key.
assert(nobleGases[54] == 'xenon');
// Check whether a map contains a key.
assert(nobleGases.containsKey(54));
// Remove a key and its value.
nobleGases.remove(54);
assert(!nobleGases.containsKey(54));
```

## Maps(字典)遍历，获取 map 的所有 key 和 value

```dart
// 使用 .length 来获取 map 中键值对的数目
var gifts = {'first': 'partridge'};
gifts['fourth'] = 'calling birds';
assert(gifts.length == 2);

var hawaiianBeaches = {
  'Oahu'      : ['Waikiki', 'Kailua', 'Waimanalo'],
  'Big Island': ['Wailea Bay', 'Pololu Beach'],
  'Kauai'     : ['Hanalei', 'Poipu']
};

// Get all the keys as an unordered collection
// (an Iterable).
var keys = hawaiianBeaches.keys;

assert(keys.length == 3);
assert(new Set.from(keys).contains('Oahu'));

// Get all the values as an unordered collection
// (an Iterable of Lists).
var values = hawaiianBeaches.values;
assert(values.length == 3);
assert(values.any((v) => v.contains('Waikiki')));
```

## 判断 map 是否包含一个 key

```dart
// 由于 map 的 value 可以为 null，
// 所有通过 key 来获取 value 并通过 判断 value 是否为 null 来判断 key 是否存在是 行不通的。
var hawaiianBeaches = {
  'Oahu'      : ['Waikiki', 'Kailua', 'Waimanalo'],
  'Big Island': ['Wailea Bay', 'Pololu Beach'],
  'Kauai'     : ['Hanalei', 'Poipu']
};

assert(hawaiianBeaches.containsKey('Oahu'));
assert(!hawaiianBeaches.containsKey('Florida'));
```


dart.md

```go
ages := make(map[string]int)
ages["alice"] = 31
ages["charlie"] = 34
// 或
ages := map[string]int{
    "alice":   31,
    "charlie": 34,
}

// 删除元素
delete(ages, "alice") // remove element ages["alice"]

// 不能对map的元素进行取址操作
// 原因是map可能随着元素数量的增长而重新分配更大的内存空间，从而可能导致之前的地址无效
_ = &ages["bob"] // compile error: cannot take address of map element

// 向一个nil值的map存入元素将导致一个panic异常
ages["carol"] = 21 // panic: assignment to entry in nil map

age, ok := ages["bob"]
if !ok { /* "bob" is not a key in this map; age == 0. */ }

if age, ok := ages["bob"]; !ok { /* ... */ }
```

遍历 map

```go
// 迭代顺序是不确定
for name, age := range ages {
    fmt.Printf("%s\t%d\n", name, age)
}

// 排序遍历
import "sort"

var names []string
// names := make([]string, 0, len(ages))
for name := range ages {
    names = append(names, name)
}
sort.Strings(names)
for _, name := range names {
    fmt.Printf("%s\t%d\n", name, ages[name])
}
```

映射将键映射到值。
映射的零值为 nil 。nil 映射既没有键，也不能添加键。
`make` 函数会返回给定类型的映射，并将其初始化备用。

map 类型可以写为 map[K]V，其中 K 和 V 分别对应 key 和 value。
其中 K 对应的 key 必须是支持==比较运算符的数据类型，
所以 map 可以通过测试 key 是否相等来判断是否已经存在。
对于 V 对应的 value 数据类型则没有任何的限制。

内置的`make`函数可以创建一个 map：
也可以用`map`字面值的语法创建 map，同时还可以指定一些最初的`key/value`：

```go
ages := map[string]int{
  "alice":   31,
  "charlie": 34,
}
// 这相当于
ages := make(map[string]int)
ages["alice"] = 31
ages["charlie"] = 34


// 声明一个key是字符串，值为int的字典,这种方式的声明需要在使用之前使用make初始化
var numbers map[string]int
// 另一种map的声明方式
numbers := make(map[string]int)
numbers["one"] = 1  //赋值
numbers["ten"] = 10 //赋值
numbers["three"] = 3


package main
import "fmt"
type Vertex struct {
  Lat, Long float64
}
var m map[string]Vertex
func main() {
  m = make(map[string]Vertex)
  m["Bell Labs"] = Vertex{
    40.68433, -74.39967,
  }
  fmt.Println(m["Bell Labs"])
}
// {40.68433 -74.39967}


// 映射的文法与结构体相似，不过必须有键名。
package main
import "fmt"
type Vertex struct {
  Lat, Long float64
}
var m = map[string]Vertex{
  "Bell Labs": Vertex{
    40.68433, -74.39967,
  },
  "Google": Vertex{
    37.42202, -122.08408,
  },
}
func main() {
  fmt.Println(m)
}


// 若顶级类型只是一个类型名，你可以在文法的元素中省略它。
package main
import "fmt"
type Vertex struct {
  Lat, Long float64
}
var m = map[string]Vertex{
  "Bell Labs": {40.68433, -74.39967},
  "Google":    {37.42202, -122.08408},
}
func main() {
  fmt.Println(m)
}


// 修改映射
package main

import "fmt"

func main() {
  m := make(map[string]int)

  m["Answer"] = 42 // 在映射 m 中插入或修改元素：
  fmt.Println("The value:", m["Answer"]) // 获取元素：

  m["Answer"] = 48
  fmt.Println("The value:", m["Answer"])

  delete(m, "Answer") // 删除元素：
  fmt.Println("The value:", m["Answer"])

  // 通过双赋值检测某个键是否存在：
  // 若 key 在 m 中，ok 为 true ；否则，ok 为 false。
  // 若 key 不在映射中，那么 elem 是该映射元素类型的零值。
  // 同样的，当从映射中读取某个不存在的键时，结果是映射的元素类型的零值。
  v, ok := m["Answer"]
  fmt.Println("The value:", v, "Present?", ok)
}
// The value: 42
// The value: 48
// The value: 0
// The value: 0 Present? false
```


go.md

JavaScript 的对象（Object），本质上是键值对的集合（Hash 结构），但是传统上只能用字符串当作键。
WeakMap 结构与 Map 结构类似，也是用于生成键值对的集合。

- WeakMap 只接受对象作为键名（null 除外），不接受其他类型的值作为键名。
- WeakMap 的键名所指向的对象，不计入垃圾回收机制。

Map 结构原生提供三个遍历器生成函数和一个遍历方法。

- `keys()`：返回键名的遍历器。
- `values()`：返回键值的遍历器。
- `entries()`：返回所有成员的遍历器。
- `forEach()`：遍历 Map 的所有成员。

```js
let { keys, values, entries } = Object;
let obj = { a: 1, b: 2, c: 3 };
for (let key of keys(obj)) {
  console.log(key); // 'a', 'b', 'c'
}
for (let value of values(obj)) {
  console.log(value); // 1, 2, 3
}
for (let [key, value] of entries(obj)) {
  console.log([key, value]); // ['a', 1], ['b', 2], ['c', 3]
}

const m = new Map();
const o = { p: "Hello World" };
m.set(o, "content");
m.get(o); // "content"
m.has(o); // true
m.delete(o); // true
m.has(o); // false

const map = new Map([
  ["name", "张三"],
  ["title", "Author"],
]);
map.size; // 2
map.has("name"); // true
map.get("name"); // "张三"
map.has("title"); // true
map.get("title"); // "Author"

const map = new Map();
map.set("foo", true);
map.set("bar", false);
map.size; // 2

const m = new Map();
m.set(undefined, "nah");
m.has(undefined); // true
m.delete(undefined);
m.has(undefined); // false

let map = new Map();
map.set("foo", true);
map.set("bar", false);
map.size; // 2
map.clear();
map.size; // 0

const map = new Map([
  ["F", "no"],
  ["T", "yes"],
]);

for (let key of map.keys()) {
  console.log(key);
}
// "F"
// "T"

for (let value of map.values()) {
  console.log(value);
}
// "no"
// "yes"

for (let item of map.entries()) {
  console.log(item[0], item[1]);
}
// "F" "no"
// "T" "yes"

// 或者
for (let [key, value] of map.entries()) {
  console.log(key, value);
}
// "F" "no"
// "T" "yes"

// 等同于使用map.entries()
for (let [key, value] of map) {
  console.log(key, value);
}
// "F" "no"
// "T" "yes"

const someVariable = 2;
const someDict = { [someVariable + 1]: "three" };
// three
console.log(someDict[3]);
```

## 从 map 中删除 key 和 value

```js
const m = new Map();
m.set(undefined, "nah");
m.has(undefined); // true
m.delete(undefined);
m.has(undefined); // false

var obj = Object.defineProperties(
  {},
  {
    p1: { value: 1, configurable: true },
    p2: { value: 2, configurable: false },
  }
);
delete obj.p1; // true
delete obj.p2; // false
obj.p1; // undefined
obj.p2; // 2
```

## Maps(字典)遍历，获取 map 的所有 key 和 value

```js
// for...in循环
// 它遍历的是对象所有可遍历（enumerable）的属性，会跳过不可遍历的属性。
// 它不仅遍历对象自身的属性，还遍历继承的属性。
var obj = { a: 1, b: 2, c: 3 };
for (var i in obj) {
  console.log("键名：", i);
  console.log("键值：", obj[i]);
}

// 获取 map 中键值对的数目
Object.keys(obj).length;
Object.values(obj);
Object.entries(obj);

var engines = new Set(["Gecko", "Trident", "Webkit", "Webkit"]);
for (var e of engines) {
  console.log(e);
}

var es6 = new Map();
es6.set("edition", 6);
es6.set("committee", "TC39");
es6.set("standard", "ECMA-262");
for (var [name, value] of es6) {
  console.log(name + ": " + value);
}

const someList = [6, 3, 5];
// 0 6
// 1 3
// 2 5
someList.forEach((element, index) => {
  console.log(`${index} ${element}`);
});

const list1 = [1, 3, 5];
const list2 = [2, 4, 6];
// [[1, 2], [3, 4], [5, 6]]
const zippedList = list1.map((x, y) => {
  return [x, list2[y]];
});
zippedList.forEach((element) => {
  console.log(`${element[0]} ${element[1]}`);
});
```

```js
// in运算符的一个问题是，它不能识别哪些属性是对象自身的，哪些属性是继承的。
var obj = { p: 1 };
"p" in obj; // true
"toString" in obj; // true

const m = new Map();
m.set("edition", 6);
m.set(262, "standard");
m.set(undefined, "nah");
m.has("edition"); // true
m.has("years"); // false
m.has(262); // true
m.has(undefined); // true
```


js.md

```sh
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel)
['jack', 'guido', 'irv']
>>> sorted(tel)
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False

# dict() 构造函数可以直接从键值对序列里创建字典。
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098}

# 字典推导式可以从任意的键值表达式中创建字典
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

# 当关键字是简单字符串时，有时直接通过关键字参数来指定键值对更方便
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098}


some_variable = 2
some_dict = {(some_variable + 1): "three"}
# three
print(some_dict[3])
```

循环的技巧

```python
some_list = [6, 3, 5]
# 0 6
# 1 3
# 2 5
for i, item in enumerate(some_list):
    print(f"{i} {item}")
# If you're not using this in a for loop, use list()
# list(enumerate(some_list)) # [(0, 6), (1, 3), (2, 5)]


list_1 = [1, 3, 5]
list_2 = [2, 4, 6]
# 1 2
# 3 4
# 5 6
for x, y in zip(list_1, list_2):
    print(f"{x} {y}")
```

```sh
# 当在字典中循环时，用 items() 方法可将关键字和对应的值同时取出
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

# 当在序列中循环时，用 enumerate() 函数可以将索引位置和其对应的值同时取出
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

# 当同时在两个或更多序列中循环时，可以用 zip() 函数将其内元素一一匹配。
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

# 当逆向循环一个序列时，先正向定位序列，然后调用 reversed() 函数
>>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1

# 用 sorted() 函数，它可以在不改动原序列的基础上返回一个新的排好序的序列
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)
...
apple
banana
orange
pear

# 有时可能会想在循环时修改列表内容，一般来说改为创建一个新列表是比较简单且安全的
>>> import math
>>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
>>> filtered_data = []
>>> for value in raw_data:
...     if not math.isnan(value):
...         filtered_data.append(value)
...
>>> filtered_data
[56.2, 51.7, 55.3, 52.5, 47.8]
```


python.md

```rust
use std::collections::HashMap;

// 新建一个哈希 map
let mut scores = HashMap::new();

// 使用 insert 增加元素
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

// 覆盖一个值
scores.insert(String::from("Blue"), 25);

// 只在键没有对应值时插入
// entry 函数的返回值是一个枚举，Entry，
// 它代表了可能存在也可能不存在的值
// or_insert 方法在键对应的值存在时就返回这个值的可变引用，
// 如果不存在则将参数作为新值插入并返回新值的可变引用。
scores.entry(String::from("Yellow")).or_insert(50);
scores.entry(String::from("Blue")).or_insert(50);

// 访问哈希 map 中的值
// 因为 get 返回 Option<V>，所以结果被装进 Some；
// 如果某个键在哈希 map 中没有对应的值，get 会返回 None
let team_name = String::from("Blue");
let score = scores.get(&team_name);

// 遍历哈希 map
for (key, value) in &scores {
    println!("{}: {}", key, value);
}

// 根据旧值更新一个值
let text = "hello world wonderful world";
let mut map = HashMap::new();
for word in text.split_whitespace() {
    let count = map.entry(word).or_insert(0); // 没有key则插入，并初始化
    *count += 1; // 更新
}
println!("{:?}", map);

// 用队伍列表和分数列表创建哈希 map
let teams  = vec![String::from("Blue"), String::from("Yellow")];
let initial_scores = vec![10, 50];
// 这里 HashMap<_, _> 类型标注是必要的，
// 因为 collect 有可能当成多种不同的数据结构
let scores: HashMap<_, _> = teams.iter().zip(initial_scores.iter()).collect();
```


哈希表/字典