package main

import "fmt"

func main() {
    //create a map
    m := map[int64]int64{512: 8, 513: 9, 234: 9, 392: 0}

    //create a slice to hold required values
    s := make([][]int64, 0)

    //range over map `m` to append to slice `s`
    for k, v := range m {

        // append each element, with a new slice []int64{k, v}
        s = append(s, []int64{k, v})
    }

    fmt.Println(s)
}

// MapToSlice to convert map[k]v to []struct{field1: k, field2: v.abc, field3: v.def}
func MapToSlice[E comparable, T any, A any](hashmap map[E]T, new func(E, T) A) []A {
    var slice []A
    for k, v := range hashmap {
        slice = append(slice, new(k, v))
    }
    return slice
}

Playground：https://go.dev/play/p/1sssP0lYb17

Go 1.18

现在可以编写一个泛型函数来提取所有键值对，即Map条目，具有任何键和值类型。
注意事项：

• Map迭代仍然是无序的--使用泛型并不能改变这一点。
• Map键must be comparable的约束

type Pair[K, V any] struct {
    First  K
    Second V
}

func Entries[M ~map[K]V, K comparable, V any](m M) []Pair[K, V] {
    entries := make([]Pair[K, V], 0)
    for k, v := range m {
        entries = append(entries, Pair[K, V]{k, v})
    }
    return entries
}

这里的类型Pair用于在返回值中保持类型安全。如果你真的 * 必须 * 返回一个切片的切片，那么它只能是[][]any（或[][2]any），以容纳不同的类型。
如果map键和值的类型相同，当然你仍然可以使用Pair，但你也可以使用上面的类型安全变体：

func Entries[T comparable](m map[T]T) [][2]T {
    entries := make([][2]T, 0)
    for k, v := range m {
        entries = append(entries, [2]T{k, v})
    }
    return entries
}

同样，T必须是comparable或更严格的，才能作为Map键工作。
Playground：https://go.dev/play/p/RwCGmp7MHKW