1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
<h1> Package maps </h1> <ul id="short-nav">
<li><code>import "maps"</code></li>
<li><a href="#pkg-overview" class="overviewLink">Overview</a></li>
<li><a href="#pkg-index" class="indexLink">Index</a></li>
<li><a href="#pkg-examples" class="examplesLink">Examples</a></li>
</ul> <h2 id="pkg-overview">Overview </h2> <p>Package maps defines various functions useful with maps of any type. </p> <h2 id="pkg-index">Index </h2> <ul id="manual-nav">
<li><a href="#Clone">func Clone[M ~map[K]V, K comparable, V any](m M) M</a></li>
<li><a href="#Copy">func Copy[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2)</a></li>
<li><a href="#DeleteFunc">func DeleteFunc[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool)</a></li>
<li><a href="#Equal">func Equal[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool</a></li>
<li><a href="#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</a></li>
</ul> <div id="pkg-examples"> <h3>Examples</h3> <dl> <dd><a class="exampleLink" href="#example_Clone">Clone</a></dd> <dd><a class="exampleLink" href="#example_Copy">Copy</a></dd> <dd><a class="exampleLink" href="#example_DeleteFunc">DeleteFunc</a></dd> <dd><a class="exampleLink" href="#example_Equal">Equal</a></dd> <dd><a class="exampleLink" href="#example_EqualFunc">EqualFunc</a></dd> </dl> </div> <h3>Package files</h3> <p> <span>maps.go</span> </p> <h2 id="Clone">func <span>Clone</span> </h2> <pre data-language="go">func Clone[M ~map[K]V, K comparable, V any](m M) M</pre> <p>Clone returns a copy of m. This is a shallow clone: the new keys and values are set using ordinary assignment. </p> <h4 id="example_Clone"> <span class="text">Example</span>
</h4> <p>Code:</p> <pre class="code" data-language="go">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])
</pre> <p>Output:</p> <pre class="output" data-language="go">1
100
1
100
100
</pre> <h2 id="Copy">func <span>Copy</span> </h2> <pre data-language="go">func Copy[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2)</pre> <p>Copy copies all key/value pairs in src adding them to dst. When a key in src is already present in dst, the value in dst will be overwritten by the value associated with the key in src. </p> <h4 id="example_Copy"> <span class="text">Example</span>
</h4> <p>Code:</p> <pre class="code" data-language="go">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)
</pre> <p>Output:</p> <pre class="output" data-language="go">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]]
</pre> <h2 id="DeleteFunc">func <span>DeleteFunc</span> </h2> <pre data-language="go">func DeleteFunc[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool)</pre> <p>DeleteFunc deletes any key/value pairs from m for which del returns true. </p> <h4 id="example_DeleteFunc"> <span class="text">Example</span>
</h4> <p>Code:</p> <pre class="code" data-language="go">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)
</pre> <p>Output:</p> <pre class="output" data-language="go">map[four:4 two:2]
</pre> <h2 id="Equal">func <span>Equal</span> </h2> <pre data-language="go">func Equal[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool</pre> <p>Equal reports whether two maps contain the same key/value pairs. Values are compared using ==. </p> <h4 id="example_Equal"> <span class="text">Example</span>
</h4> <p>Code:</p> <pre class="code" data-language="go">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))
</pre> <p>Output:</p> <pre class="output" data-language="go">true
false
</pre> <h2 id="EqualFunc">func <span>EqualFunc</span> </h2> <pre data-language="go">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</pre> <p>EqualFunc is like Equal, but compares values using eq. Keys are still compared with ==. </p> <h4 id="example_EqualFunc"> <span class="text">Example</span>
</h4> <p>Code:</p> <pre class="code" data-language="go">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.ToLower(v1) == strings.ToLower(string(v2))
})
fmt.Println(eq)
</pre> <p>Output:</p> <pre class="output" data-language="go">true
</pre><div class="_attribution">
<p class="_attribution-p">
© Google, Inc.<br>Licensed under the Creative Commons Attribution License 3.0.<br>
<a href="http://golang.org/pkg/maps/" class="_attribution-link">http://golang.org/pkg/maps/</a>
</p>
</div>
|
