Apps Artificial Intelligence CSS DevOps Go JavaScript Laravel Linux MongoDB MySQL PHP Python Rust Svelte Vue

Pretty-Printing JSON in Go with MarshalIndent

2 min read .
Updated on
Pretty-Printing JSON in Go with MarshalIndent

Compact JSON is efficient for transport, but long documents can be difficult to inspect when everything appears on one line. Go’s standard encoding/json package includes json.MarshalIndent for producing human-readable JSON with line breaks and indentation.

Pretty-printed JSON is useful for debugging, generated configuration, logs intended for people, and command-line output.

1. Use json.MarshalIndent

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	data := map[string]any{
		"name": "Alice",
		"age":  30,
		"address": map[string]string{
			"street": "123 Main St",
			"city":   "Wonderland",
		},
		"hobbies": []string{"reading", "hiking", "coding"},
	}

	prettyJSON, err := json.MarshalIndent(data, "", "    ")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	fmt.Println(string(prettyJSON))
}

MarshalIndent accepts three arguments:

  1. The value to encode.
  2. A prefix added to each output line, often "".
  3. The indentation string, such as two spaces, four spaces, or a tab.

For example, two-space indentation looks like this:

prettyJSON, err := json.MarshalIndent(data, "", "  ")

2. Always Handle Encoding Errors

JSON encoding can fail. Unsupported values include channels, functions, complex numbers, and data containing cycles.

prettyJSON, err := json.MarshalIndent(data, "", "    ")
if err != nil {
    return fmt.Errorf("marshal JSON: %w", err)
}

Returning or wrapping the error is usually more useful in library and application code than merely printing it.

3. Pretty-Print JSON from a File

If a file already contains JSON, you can decode and re-encode it:

fileContent, err := os.ReadFile("data.json")
if err != nil {
    log.Fatalf("read file: %v", err)
}

var data any
if err := json.Unmarshal(fileContent, &data); err != nil {
    log.Fatalf("decode JSON: %v", err)
}

prettyJSON, err := json.MarshalIndent(data, "", "    ")
if err != nil {
    log.Fatalf("encode JSON: %v", err)
}

fmt.Println(string(prettyJSON))

For the specific job of formatting existing JSON bytes, json.Indent can avoid decoding into generic Go values:

var out bytes.Buffer
if err := json.Indent(&out, fileContent, "", "  "); err != nil {
    log.Fatal(err)
}
fmt.Print(out.String())

4. Pretty JSON in an HTTP Response

For debugging or developer-facing endpoints, you can marshal an indented response manually:

func handler(w http.ResponseWriter, r *http.Request) {
	data := map[string]any{
		"status": "success",
		"data": map[string]string{
			"message": "Hello, World!",
		},
	}

	prettyJSON, err := json.MarshalIndent(data, "", "    ")
	if err != nil {
		http.Error(w, "could not encode response", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	_, _ = w.Write(prettyJSON)
}

For production APIs, compact JSON is usually preferable because indentation increases response size. Pretty output is most useful when humans are expected to inspect the response directly.

Encoder.SetIndent for Streaming Output

When writing directly to an io.Writer, json.Encoder can be more convenient:

encoder := json.NewEncoder(os.Stdout)
encoder.SetIndent("", "  ")

if err := encoder.Encode(data); err != nil {
    log.Fatal(err)
}

This avoids creating the complete encoded byte slice first and automatically writes a trailing newline.

Conclusion

Use json.MarshalIndent when you need an indented JSON byte slice, json.Indent when formatting existing JSON bytes, and json.Encoder.SetIndent when writing JSON directly to a stream. Keep compact output for bandwidth-sensitive APIs, and reserve pretty printing for places where readability matters.

Golang JSON

Related Posts

Arrays and Slices in Go: Add, Delete, Search, Update, Sort, and Filter
Updated on
Arrays and Slices in Go: Add, Delete, Search, Update, Sort, and Filter
Go arrays and slices are straightforward once you understand their different roles. Arrays have a fixed length that is part of their type, while slices are flexible views over an underlying array and are the collection type used most often in application code. The following examples use a slice of structs: Copy type Person struct { Name string Age int } people := []Person{ {Name: "Alice", Age: 30}, {Name: "Bob", Age: 25}, {Name: "John", Age: 20}, {Name: "Zara", Age: 35}, } 1. Add an Element Use append:
Golang Array Slice
Build a CRUD API with Go, Gin, MySQL, and GORM
Updated on
Build a CRUD API with Go, Gin, MySQL, and GORM
This tutorial builds a small CRUD API with Go, the Gin web framework, MySQL, and GORM. It also uses godotenv for local development configuration. 1. Create the Project Copy mkdir myapp cd myapp go mod init myapp 2. Install Dependencies Copy go get github.com/gin-gonic/gin go get gorm.io/gorm go get gorm.io/driver/mysql go get github.com/joho/godotenv Run go mod tidy after adding your imports so the module file reflects the dependencies actually used by the application.
Golang Gin MySQL GORM
Deploy a Go Web Server with systemd on Linux
Updated on
Deploy a Go Web Server with systemd on Linux
When developing a small Go web server, it is common to run it manually with go run main.go. The problem is that the process stops when the terminal closes, and it will not automatically return after a server reboot. A better production setup is to run the application as a systemd service. That gives you automatic startup, monitoring, service management, and optional restart behavior after failures. 1. Create a Simple Go Web Server Start with a minimal HTTP server:
Golang systemd
Easy Ways to Convert an Integer to a String in Go
Updated on
Easy Ways to Convert an Integer to a String in Go
Converting an integer to a string is common when building output, logs, identifiers, URLs, or serialized data. Go provides several standard-library options depending on whether you need a simple decimal conversion or more control over formatting. 1. strconv.Itoa() For an int in base 10, strconv.Itoa is usually the clearest choice: Copy package main import ( "fmt" "strconv" ) func main() { num := 42 str := strconv.Itoa(num) fmt.Println("String value:", str) } Itoa is equivalent to formatting the int as a base-10 integer.
Golang
Efficient String Concatenation in Go
Updated on
Efficient String Concatenation in Go
String concatenation appears everywhere in Go programs: generating text, building paths, formatting reports, or assembling protocol messages. The best technique depends on how many pieces you are joining and how the data is already structured. 1. The + Operator For a small, fixed number of strings, + is clear and perfectly reasonable: Copy str1 := "Hello, " str2 := "world!" result := str1 + str2 Avoid repeatedly growing a string with + inside a large loop, because each result is a new immutable string and repeated copying can become expensive.
Golang
Generate Random Strings in Go
Updated on
Generate Random Strings in Go
Random strings are useful for temporary identifiers, test data, filenames, invitation codes, and security-sensitive tokens. Go offers different random-number sources, and choosing the correct one matters. 1. math/rand for Non-Security Uses For simulations, test fixtures, randomized UI behavior, or other cases where predictability is not a security problem, math/rand is appropriate. With modern Go, create an explicit generator when you need independent pseudo-random state: Copy package main import ( "fmt" "math/rand" ) const alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" func GenerateRandomString(r *rand.Rand, length int) string { result := make([]byte, length) for i := range result { result[i] = alphabet[r.Intn(len(alphabet))] } return string(result) } func main() { r := rand.New(rand.NewSource(42)) fmt.Println(GenerateRandomString(r, 10)) } A fixed seed is useful for reproducible tests. Do not use math/rand for secrets, session tokens, password-reset tokens, or other authentication material.
Golang
chevron-up