Comment obtenir la représentation en chaîne d'une structure ?

Question

Pour mon application, il importe peu que la chaîne soit lisible par l'homme ou non.

Answer 1

S'il s'agit d'une sérialisation "à sens unique" (pour le débogage ou l'enregistrement ou autre) alors fmt.Printf("%#v", var) est très agréable (mise à jour : pour mettre la sortie dans une chaîne de caractères au lieu de l'imprimer, utilisez str := fmt.Sprintf("%#v", var) .

Si la taille est importante, vous pouvez utiliser %v mais j'aime %#v car il comprendra également les noms des champs et le nom du type de structure.

Une troisième variante est %+v qui inclura les noms des champs, mais pas le type de structure.

Ils sont tous documentés en haut de la page d'accueil du site. documentation fmt .

Si vous avez besoin d'une sérialisation bidirectionnelle, JSON, Gob ou XML sont les options les plus simples et les plus intégrées dans Go, voir la section paquets d'encodage .

Answer 2

Une façon populaire d'encoder des structs en chaînes de caractères est d'utiliser JSON .

Vous avez certaines limitations telles que le fait de ne pas obtenir toutes les informations (comme le type spécifique de chaque champ), de ne sérialiser que les champs exportés et de ne pas gérer les valeurs récursives. Mais il s'agit d'un moyen standard simple de sérialiser les données.

Exemple de travail :

package main

import (
    "fmt"
    "encoding/json"
)

type s struct {
    Int       int
    String    string
    ByteSlice []byte
}

func main() {
    a := &s{42, "Hello World!", []byte{0,1,2,3,4}}

    out, err := json.Marshal(a)
    if err != nil {
        panic (err)
    }

    fmt.Println(string(out))
}

Donnez cette sortie :

{"Int":42,"String":"Hello World!","ByteSlice":"AAECAwQ="}

https://play.golang.org/p/sx-xdSxAOG

Answer 3

Attacher une fonction String() à une structure nommée nous permet de convertir une structure en une chaîne.

package main

import "fmt"

type foo struct {
    bar string
}

func (f foo) String() string {
    return fmt.Sprintf("Foo Says: %s", f.bar)
}

func main() {
    fmt.Println(foo{"Hello World!"})
}

output:
Foo Says: Hello World!

Answer 4

Vous pouvez également ajouter une fonction avec ce récepteur struct.

// URL : Sitemap Xml
type URL struct {
    Loc string `xml:"loc"`
}

// URLSET : Sitemap XML
type URLSET struct {
    URLS []URL `xml:"url"`
}

// converting the struct to String format. 
func (u URL) String() string {
    return fmt.Sprintf(u.Loc)
}

Ainsi, l'impression de ce champ struct renverra une chaîne de caractères.

fmt.Println(urls.URLS)

Answer 5

Utilisation de json o fmt.Sprintf je fais un repère,

BenchmarkStructJson-8            1000000          1773 ns/op
BenchmarkStructSprintSharp-8      200000          6139 ns/op
BenchmarkStructSprint-8           500000          2763 ns/op
BenchmarkStructSprintPlus-8       300000          4373 ns/op

BenchmarkStructJson utilise json.Marshal @Matheus Santana

BenchmarkStructSprintSharp : `fmt.Sprintf("%#v", &a) @Ask Bjørn Hansen

BenchmarkStructSprint : `fmt.Sprintf("%v", &a)

BenchmarkStructSprintPlus : `fmt.Sprintf("%+v", &a)

Le résultat est, json.Marshal est une meilleure performance.