blocks|key|4669810|text|一种更好的方法是使用append|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4669811|keys+=+[]int{}
for+k+:=+range+mymap+{
++++keys+=+append(keys,+k)
}|code-block|syntax|javascript|4669812|除此之外，你就不走运了-Go不是一种表现力很强的语言。|4669813|entityMap^0|A|6|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

A nicer way to do this would be to use <code>append</code>:

<pre><code>keys = []int{}
for k := range mymap {
 keys = append(keys, k)
}
</code></pre>

Other than that, you’re out of luck—Go isn’t a very expressive language.

blocks|key|163714|text|例如,|type|unstyled|depth|inlineStyleRanges|entityRanges|data|163715|package+main

func+main()+{
++++mymap+:=+make(map[int]string)
++++keys+:=+make([]int,+0,+len(mymap))
++++for+k+:=+range+mymap+{
++++++++keys+=+append(keys,+k)
++++}
}|code-block|syntax|javascript|163716|为了在Go中高效，最大限度地减少内存分配非常重要。|163717|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

For example,

<pre><code>package main

func main() {
 mymap := make(map[int]string)
 keys := make([]int, 0, len(mymap))
 for k := range mymap {
 keys = append(keys, k)
 }
}
</code></pre>

To be efficient in Go, it's important to minimize memory allocations.

blocks|key|163755|text|这是一个古老的问题，但这是我的两个观点。PeterSO的答案略显简洁，但效率稍低。你已经知道它会有多大，所以你甚至不需要使用append：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|163756|keys+:=+make([]int,+len(mymap))

i+:=+0
for+k+:=+range+mymap+{
++++keys[i]+=+k
++++i%2B%2B
}|code-block|syntax|javascript|163757|在大多数情况下，这可能不会有太大的不同，但也不会有太多的工作，而且在我的测试中(使用一个具有1,000,000个随机int64键的映射，然后使用每个方法生成10次键的数组)，直接分配数组的成员比使用append快大约20%25。|offset|length|style|CODE|163758|尽管设置容量会消除重新分配，append仍然需要做额外的工作来检查您是否在每个append上达到了容量。|163759|entityMap^0|0|0|1M|5|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This is an old question, but here's my two cents. PeterSO's answer is slightly more concise, but slightly less efficient. You already know how big it's going to be so you don't even need to use append:

<pre><code>keys := make([]int, len(mymap))

i := 0
for k := range mymap {
 keys[i] = k
 i++
}
</code></pre>

In most situations it probably won't make much of a difference, but it's not much more work, and in my tests (using a map with 1,000,000 random <code>int64</code> keys and then generating the array of keys ten times with each method), it was about 20% faster to assign members of the array directly than to use append.

Although setting the capacity eliminates reallocations, append still has to do extra work to check if you've reached capacity on each append.

blocks|key|4669907|text|你也可以通过“reflect”包中的struct的MapKeys方法获取类型为[]Value的键数组：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4669908|package+main

import+(
++++"fmt"
++++"reflect"
)

func+main()+{
++++abc+:=+map[string]int{
++++++++"a":+1,
++++++++"b":+2,
++++++++"c":+3,
++++}

++++keys+:=+reflect.ValueOf(abc).MapKeys()

++++fmt.Println(keys)+//+[a+b+c]
}|code-block|syntax|javascript|4669909|entityMap^0|P|7|13|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

You also can take an array of keys with type <code>[]Value</code> by method <code>MapKeys</code> of struct <code>Value</code> from package "reflect":

<pre><code>package main

import (
 "fmt"
 "reflect"
)

func main() {
 abc := map[string]int{
 "a": 1,
 "b": 2,
 "c": 3,
 }

 keys := reflect.ValueOf(abc).MapKeys()

 fmt.Println(keys) // [a b c]
}
</code></pre>

blocks|key|163837|text|我对其他回答中描述的三种方法做了一个粗略的基准测试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|163838|显然，在拉取关键点之前预先分配切片比appending快，但令人惊讶的是，reflect.ValueOf(m).MapKeys()方法比后者慢得多：|offset|length|style|CODE|163839|❯+go+run+scratch.go
populating
filling+100000000+slots
done+in+56.630774791s
running+prealloc
took:+9.989049786s
running+append
took:+18.948676741s
running+reflect
took:+25.50070649s|code-block|syntax|javascript|163840|下面是代码：https://play.golang.org/p/Z8O6a2jyfTH+(在操场上运行它会中止声明它花费的时间太长，所以，好吧，在本地运行它。)|163841|entityMap|0|LINK|mutability|MUTABLE|url|https://play.golang.org/p/Z8O6a2jyfTH^0|0|I|6|11|S|0|0|6|11|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@$D|Y|E|Z|F|G]|$D|10|E|11|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|13|8|@]|9|@$D|14|E|15|1|16]]|A|$]]|$1|O|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

I made a sketchy benchmark on the three methods described in other responses.

Obviously pre-allocating the slice before pulling the keys is faster than <code>append</code>ing, but surprisingly, the <code>reflect.ValueOf(m).MapKeys()</code> method is significantly slower than the latter:

<pre><code>❯ go run scratch.go
populating
filling 100000000 slots
done in 56.630774791s
running prealloc
took: 9.989049786s
running append
took: 18.948676741s
running reflect
took: 25.50070649s
</code></pre>

Here's the code: <a href="https://play.golang.org/p/Z8O6a2jyfTH" rel="noreferrer">https://play.golang.org/p/Z8O6a2jyfTH</a>
(running it in the playground aborts claiming that it takes too long, so, well, run it locally.)

blocks|key|4669943|text|访问https://play.golang.org/p/dx6PTtuBXQW|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4669944|package+main

import+(
++++"fmt"
++++"sort"
)

func+main()+{
++++mapEg+:=+map[string]string{"c":"a","a":"c","b":"b"}
++++keys+:=+make([]string,+0,+len(mapEg))
++++for+k+:=+range+mapEg+{
++++++++keys+=+append(keys,+k)
++++}
++++sort.Strings(keys)
++++fmt.Println(keys)
}|code-block|syntax|javascript|4669945|entityMap|0|LINK|mutability|MUTABLE|url|https://play.golang.org/p/dx6PTtuBXQW^0|2|11|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Visit <a href="https://play.golang.org/p/dx6PTtuBXQW" rel="nofollow noreferrer">https://play.golang.org/p/dx6PTtuBXQW</a>

<pre><code>package main

import (
 "fmt"
 "sort"
)

func main() {
 mapEg := map[string]string{"c":"a","a":"c","b":"b"}
 keys := make([]string, 0, len(mapEg))
 for k := range mapEg {
 keys = append(keys, k)
 }
 sort.Strings(keys)
 fmt.Println(keys)
}
</code></pre>

blocks|key|4669996|text|最终，Go很快就会有泛型。如果这个提议(https://github.com/golang/go/issues/47649)进入泛型实现的第一个版本，我们就可以用maps.Keys获得任何映射的密钥|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4669997|//+Keys+returns+the+keys+of+the+map+m.
//+The+keys+will+be+an+indeterminate+order.
func+Keys[M+constraints.Map[K,+V],+K+comparable,+V+any](m+M)+[]K|code-block|syntax|javascript|4669998|示例使用非常简单|4669999|++++intMap+:=+map[int]int{1:+1,+2:+2}
++++intKeys+:=+maps.Keys(intMap)
++++//+intKeys+is+[]int
++++fmt.Println(intKeys)

++++strMap+:=+map[string]int{"alpha":+1,+"bravo":+2}
++++strKeys+:=+maps.Keys(strMap)
++++//+strKeys+is+[]string
++++fmt.Println(strKeys)|4670000|在golang.org/x/exp/maps中可以找到maps包。这是实验性的和Go之外的兼容性保证。他们的目标是将其移植到Go+1.19中的std库中|4670001|Ant+way，它在gotip游乐场https://gotipplay.golang.org/p/fkm9PrJYTly上工作|4670002|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/golang/go/issues/47649|1|https://gotipplay.golang.org/p/fkm9PrJYTly^0|29|9|K|15|0|0|0|0|0|1|L|R|4|0|I|16|1|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]]|E|$]]|$1|F|3|G|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|19|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1G|8|@]|D|@$9|1H|A|1I|1|1J]]|E|$]]|$1|S|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|11]]]]

Eventually Go will have generics, very soon. If this proposal (<a href="https://github.com/golang/go/issues/47649" rel="nofollow noreferrer">https://github.com/golang/go/issues/47649</a>) makes it into the first version of generics implementation, we can get the keys of any map with <code>maps.Keys</code>:
<pre><code>// Keys returns the keys of the map m.
// The keys will be an indeterminate order.
func Keys[M constraints.Map[K, V], K comparable, V any](m M) []K
</code></pre>
Example use is very simple
<pre><code> intMap := map[int]int{1: 1, 2: 2}
 intKeys := maps.Keys(intMap)
 // intKeys is []int
 fmt.Println(intKeys)

 strMap := map[string]int{&quot;alpha&quot;: 1, &quot;bravo&quot;: 2}
 strKeys := maps.Keys(strMap)
 // strKeys is []string
 fmt.Println(strKeys)
</code></pre>
<code>maps</code> package is found in <code>golang.org/x/exp/maps</code>. This is experimental and outside of Go compatibility guarantee. They aim to move it into the std lib in Go 1.19
Ant way, it works on gotip playground
<a href="https://gotipplay.golang.org/p/fkm9PrJYTly" rel="nofollow noreferrer">https://gotipplay.golang.org/p/fkm9PrJYTly</a>

Is there any simpler/nicer way of getting a slice of keys from a map in Go?

Currently I am iterating over the map and copying the keys to a slice:

<pre class="lang-golang prettyprint-override"><code>i := 0
keys := make([]int, len(mymap))
for k := range mymap {
 keys[i] = k
 i++
}
</code></pre>

Getting a slice of keys from a map

有没有更简单/更好的方法来从Go中的map中获取一段键？目前，我正在迭代map并将键复制到一个切片中：i := 0keys := make([]int, len(mymap))for k := range mymap {    keys[i] = k    i++}

问从映射中获取一段键
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从映射中获取一段键EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从映射中获取一段键
EN