maps

package maps

import "maps"

Package maps 定义了对任何类型的 map 都有用的各种函数。

此包对非自反键（keys k where k != k），如浮点 NaN，没有特殊处理。

Index

func All(m Map) iter.Seq2[K, V]
func Clone(m M) M
func Collect(seq iter.Seq2[K, V]) map[K]V
func Copy(dst M1, src M2)
func DeleteFunc(m M, del func(K, V) bool)
func Equal(m1 M1, m2 M2) bool
func EqualFunc(m1 M1, m2 M2, eq func(V1, V2) bool) bool
func Insert(m Map, seq iter.Seq2[K, V])
func Keys(m Map) iter.Seq[K]
func Values(m Map) iter.Seq[V]

Functions

func All

func All[Map ~map[K]V, K comparable, V any](m Map) iter.Seq2[K, V]

All 返回对 m 中键值对的迭代器。迭代顺序未指定，不保证与下一次调用相同。

Example

package main

import (
	"fmt"
	"maps"
)

func main() {
	m1 := map[string]int{
		"one": 1,
		"two": 2,
	}
	m2 := map[string]int{
		"one": 10,
	}
	maps.Insert(m2, maps.All(m1))
	fmt.Println("m2 is:", m2)
}

Output:

m2 is: map[one:1 two:2]

func Clone

func Clone[M ~map[K]V, K comparable, V any](m M) M

Clone 返回 m 的副本。这是一个浅拷贝：新的键和值使用普通赋值进行设置。

Example

package main

import (
	"fmt"
	"maps"
)

func main() {
	m1 := map[string]int{
		"key": 1,
	}
	m2 := maps.Clone(m1)
	m2["key"] = 100
	fmt.Println(m1["key"])
	fmt.Println(m2["key"])

	m3 := map[string][]int{
		"key": {1, 2, 3},
	}
	m4 := maps.Clone(m3)
	fmt.Println(m4["key"][0])
	m4["key"][0] = 100
	fmt.Println(m3["key"][0])
	fmt.Println(m4["key"][0])

}

Output:

func Collect

func Collect[K comparable, V any](seq iter.Seq2[K, V]) map[K]V

Collect 将 seq 中的键值对收集到一个新 map 中并返回。

Example

package main

import (
	"fmt"
	"maps"
	"slices"
)

func main() {
	s1 := []string{"zero", "one", "two", "three"}
	m1 := maps.Collect(slices.All(s1))
	fmt.Println("m1 is:", m1)
}

Output:

m1 is: map[0:zero 1:one 2:two 3:three]

func Copy

func Copy[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2)

Copy 将 src 中的所有键/值对复制到 dst。当 src 中的键已存在于 dst 时， dst 中的值将被 src 中与该键关联的值覆盖。

Example

package main

import (
	"fmt"
	"maps"
)

func main() {
	m1 := map[string]int{
		"one": 1,
		"two": 2,
	}
	m2 := map[string]int{
		"one": 10,
	}

	maps.Copy(m2, m1)
	fmt.Println("m2 is:", m2)

	m2["one"] = 100
	fmt.Println("m1 is:", m1)
	fmt.Println("m2 is:", m2)

	m3 := map[string][]int{
		"one": {1, 2, 3},
		"two": {4, 5, 6},
	}
	m4 := map[string][]int{
		"one": {7, 8, 9},
	}

	maps.Copy(m4, m3)
	fmt.Println("m4 is:", m4)

	m4["one"][0] = 100
	fmt.Println("m3 is:", m3)
	fmt.Println("m4 is:", m4)

}

Output:

m2 is: map[one:1 two:2]
m1 is: map[one:1 two:2]
m2 is: map[one:100 two:2]
m4 is: map[one:[1 2 3] two:[4 5 6]]
m3 is: map[one:[100 2 3] two:[4 5 6]]
m4 is: map[one:[100 2 3] two:[4 5 6]]

func DeleteFunc

func DeleteFunc[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool)

DeleteFunc 从 m 中删除所有使 del 返回 true 的键/值对。

Example

package main

import (
	"fmt"
	"maps"
)

func main() {
	m := map[string]int{
		"one":   1,
		"two":   2,
		"three": 3,
		"four":  4,
	}
	maps.DeleteFunc(m, func(k string, v int) bool {
		return v%2 != 0 // delete odd values
	})
	fmt.Println(m)
}

Output:

map[four:4 two:2]

func Equal

func Equal[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool

Equal 报告两个 map 是否包含相同的键/值对。值使用 == 进行比较。

Example

package main

import (
	"fmt"
	"maps"
)

func main() {
	m1 := map[int]string{
		1:    "one",
		10:   "Ten",
		1000: "THOUSAND",
	}
	m2 := map[int]string{
		1:    "one",
		10:   "Ten",
		1000: "THOUSAND",
	}
	m3 := map[int]string{
		1:    "one",
		10:   "ten",
		1000: "thousand",
	}

	fmt.Println(maps.Equal(m1, m2))
	fmt.Println(maps.Equal(m1, m3))
}

Output:

true
false

func EqualFunc

func EqualFunc[M1 ~map[K]V1, M2 ~map[K]V2, K comparable, V1, V2 any](m1 M1, m2 M2, eq func(V1, V2) bool) bool

EqualFunc 类似于 Equal，但使用 eq 比较值。键仍然使用 == 比较。

Example

package main

import (
	"fmt"
	"maps"
	"strings"
)

func main() {
	m1 := map[int]string{
		1:    "one",
		10:   "Ten",
		1000: "THOUSAND",
	}
	m2 := map[int][]byte{
		1:    []byte("One"),
		10:   []byte("Ten"),
		1000: []byte("Thousand"),
	}
	eq := maps.EqualFunc(m1, m2, func(v1 string, v2 []byte) bool {
		return strings.EqualFold(v1, string(v2))
	})
	fmt.Println(eq)
}

Output:

true

func Insert

func Insert[Map ~map[K]V, K comparable, V any](m Map, seq iter.Seq2[K, V])

Insert 将 seq 中的键值对添加到 m。如果 seq 中的键已存在于 m 中，其值将被覆盖。

Example

package main

import (
	"fmt"
	"maps"
	"slices"
)

func main() {
	m1 := map[int]string{
		1000: "THOUSAND",
	}
	s1 := []string{"zero", "one", "two", "three"}
	maps.Insert(m1, slices.All(s1))
	fmt.Println("m1 is:", m1)
}

Output:

m1 is: map[0:zero 1:one 2:two 3:three 1000:THOUSAND]

func Keys

func Keys[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[K]

Keys 返回对 m 中键的迭代器。迭代顺序未指定，不保证与下一次调用相同。

Example

package main

import (
	"fmt"
	"maps"
	"slices"
)

func main() {
	m1 := map[int]string{
		1:    "one",
		10:   "Ten",
		1000: "THOUSAND",
	}
	keys := slices.Sorted(maps.Keys(m1))
	fmt.Println(keys)
}

Output:

[1 10 1000]

func Values

func Values[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[V]

Values 返回对 m 中值的迭代器。迭代顺序未指定，不保证与下一次调用相同。

Example

package main

import (
	"fmt"
	"maps"
	"slices"
)

func main() {
	m1 := map[int]string{
		1:    "one",
		10:   "Ten",
		1000: "THOUSAND",
	}
	values := slices.Sorted(maps.Values(m1))
	fmt.Println(values)
}

Output:

[THOUSAND Ten one]