En golang, existe-t-il un moyen intéressant d’obtenir une tranche de valeurs à partir d’une carte?

Si j’ai une carte m, y a-t-il un meilleur moyen d’obtenir une tranche des valeurs v alors

package main import ( "fmt" ) func main() { m := make(map[int]ssortingng) m[1] = "a" m[2] = "b" m[3] = "c" m[4] = "d" // Can this be done better? v := make([]ssortingng, len(m), len(m)) idx := 0 for _, value := range m { v[idx] = value idx++ } fmt.Println(v) } 

Y a-t-il une caractéristique intégrée d’une carte? Existe-t-il une fonction dans un package Go, ou est-ce le meilleur code à faire si nécessaire?

Malheureusement non. Il n’y a pas de moyen intégré pour le faire.

En guise de remarque, vous pouvez omettre l’argument de capacité dans la création de votre tranche:

 v := make([]ssortingng, len(m)) 

La capacité est supposée être la même que la longueur ici.

En complément du post de jimt:

Vous pouvez également utiliser append plutôt que d’assigner explicitement les valeurs à leurs index:

 m := make(map[int]ssortingng) m[1] = "a" m[2] = "b" m[3] = "c" m[4] = "d" v := make([]ssortingng, 0, len(m)) for _, value := range m { v = append(v, value) } 

Notez que la longueur est nulle (aucun élément présent pour le moment) mais la capacité (espace alloué) est initialisée avec le nombre d’éléments de m . Ceci est fait pour que append n’ait pas besoin d’allouer de la mémoire chaque fois que la capacité de la tranche v est épuisée.

Vous pouvez également make la tranche sans la valeur de capacité et laisser append allouer la mémoire pour elle-même.

A ma connaissance, go n’a pas de méthode de concaténation des chaînes / octets dans une chaîne résultante sans faire au moins deux copies.

Vous devez actuellement faire croître un octet puisque toutes les valeurs de chaîne sont const, ALORS vous devez utiliser la chaîne intégrée pour que le langage crée un object de chaîne «béni», pour lequel il copiera le tampon car quelque chose quelque part pourrait avoir une référence. à l’adresse sauvegardant l’octet [].

Si un octet est approprié, vous pouvez obtenir une très légère avance sur la fonction bytes.Join en effectuant une allocation et en faisant la copie vous-même.

 package main import ( "fmt" ) func main() { m := make(map[int]ssortingng) m[1] = "a" ; m[2] = "b" ; m[3] = "c" ; m[4] = "d" ip := 0 /* If the elements of m are not all of fixed length you must use a method like this; * in that case also consider: * bytes.Join() and/or * ssortingngs.Join() * They are likely preferable for maintainability over small performance change. for _, v := range m { ip += len(v) } */ ip = len(m) * 1 // length of elements in m r := make([]byte, ip, ip) ip = 0 for _, v := range m { ip += copy(r[ip:], v) } // r (return value) is currently a []byte, it mostly differs from 'ssortingng' // in that it can be grown and has a different default fmt method. fmt.Printf("%s\n", r) }