How can I get the string representation of a struct?

For my application, it does not matter if the string is human readable or not.

If it's a "one way" serialization (for debugging or logging or whatever) then fmt.Printf("%#v", var) is very nice. (Update: to put the output into a string instead of printing it, use str := fmt.Sprintf("%#v", var).

If size matters you can use %v, but I like %#v because it will also include the field names and the name of the struct type.

A third variation is %+v which will include the field names, but not the struct type.

They are all documented at the top of the fmt documentation.

If you need two-way serialization JSON, Gob or XML are the easiest/built-in options in Go, see the encoding packages.

One popular way of encoding structs into strings is using JSON.

You have certain limitations such as not getting all the information (such as the specific type of each field), only serializing exported fields, and not handling recursive values. But it is a simple standard way of serializing data.

Working example:

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))
}

Give this output:

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

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

you can also add a function with that struct receiver.

// 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)
}

So printing this struct field will return a string.

fmt.Println(urls.URLS)

Attaching a String() function to a named struct allows us to convert a struct to a string.

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!

Using json or fmt.Sprintf, I make a benchmark,

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 is using json.Marshal @Matheus Santana

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

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

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

The result is, json.Marshal is better performance.