Use structs with proper JSON tags for predictable data to ensure fast, safe parsing with compile-time type safety. 2. Avoid map[string]interface{} due to reflection overhead and runtime type assertions unless dealing with truly dynamic JSON. 3. Use json.RawMessage for deferred or selective parsing to save CPU and memory by parsing conditionally. 4. Stream large JSON with json.Decoder and json.Encoder to process data incrementally and reduce memory usage. 5. Pre-allocate slices and reuse buffers to minimize allocations and reduce garbage collection pressure. 6. Handle unknown fields with Decoder.DisallowUnknownFields() to enforce strict validation in APIs. Efficient JSON handling in Go relies on using structs, streaming for large data, delaying parsing when possible, and minimizing allocations to improve performance and maintainability.

When working with JSON in Go, efficiency and clarity are key—especially in services that handle large payloads or high throughput. Go’s encoding/json package provides robust tools for parsing and manipulating JSON, but knowing how to use it effectively can make a big difference in performance and code maintainability.

Here’s how to work with JSON efficiently in Go.

1. Use Structs with Proper Tags for Predictable Data

If you know the structure of your JSON, define a Go struct with json tags. This is faster and safer than using map[string]interface{}.

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email,omitempty"`
}

• json:"name" maps the field to the JSON key.
• omitempty omits the field from output if it's empty (zero value).

Parsing becomes straightforward:

var user User
err := json.Unmarshal(data, &user)
if err != nil {
    log.Fatal(err)
}

? Why it's efficient: Direct memory allocation, compile-time type safety, and no runtime type assertions.

2. Avoid map[string]interface{} When Possible

While convenient, untyped maps are slow and error-prone:

var data map[string]interface{}
json.Unmarshal(rawJSON, &data)
name := data["name"].(string) // Panic if type is wrong

? Problems:

• Reflection overhead during parsing.
• Type assertions required.
• No compile-time checks.

Only use map[string]interface{} for truly dynamic or unknown JSON (e.g., configuration with variable keys).

For semi-structured data, consider using json.RawMessage to defer parsing.

3. Use json.RawMessage for Deferred or Selective Parsing

json.RawMessage lets you store raw JSON data as a byte slice, delaying parsing until needed.

type Message struct {
    Type      string          `json:"type"`
    Payload   json.RawMessage `json:"payload"`
}

var msg Message
json.Unmarshal(data, &msg)

// Now parse payload based on type
switch msg.Type {
case "user":
    var user User
    json.Unmarshal(msg.Payload, &user)
case "event":
    var event Event
    json.Unmarshal(msg.Payload, &event)
}

? Efficiency win: Avoids parsing unused or conditional data upfront.

4. Stream Large JSON with json.Decoder and json.Encoder

For large JSON files or HTTP streams, use json.Decoder and json.Encoder to avoid loading everything into memory.

Reading from a file or HTTP body:

decoder := json.NewDecoder(r.Body)
for {
    var user User
    if err := decoder.Decode(&user); err == io.EOF {
        break
    } else if err != nil {
        log.Fatal(err)
    }
    // Process user one at a time
}

Writing streaming JSON:

encoder := json.NewEncoder(w)
for _, user := range users {
    encoder.Encode(user) // Writes directly to output
}

? Ideal for large datasets, APIs, or log processors.

5. Pre-allocate Slices and Reuse Buffers

If parsing many JSON objects, reduce allocations:

• Pre-allocate slices when size is known.
• Reuse *json.Decoder and buffers in loops.

Example:

users := make([]User, 0, 1000) // Pre-allocate capacity

For high-performance scenarios, consider pooling buffers:

var bufPool = sync.Pool{
    New: func() interface{} { return new(bytes.Buffer) },
}

Though json.Unmarshal is usually fast enough, reducing GC pressure matters at scale.

6. Handle Unknown Fields Gracefully

By default, unknown JSON fields are ignored. To catch them (e.g., for validation), use Decoder.DisallowUnknownFields():

decoder := json.NewDecoder(r.Body)
decoder.DisallowUnknownFields()
err := decoder.Decode(&user)
// Returns error if JSON contains unexpected keys

Useful in APIs to reject malformed or malicious input.

Summary

Efficient JSON handling in Go isn’t about avoiding the standard library—it’s about using it wisely. Stick to structs when possible, stream when needed, and delay parsing selectively.

Basically, know your data shape, minimize allocations, and let the encoding/json package do the heavy lifting—just guide it well.

The above is the detailed content of Efficient JSON Parsing and Manipulation in Go. For more information, please follow other related articles on the PHP Chinese website!