go by example json marshal and unmarshal

In Go, the encoding/json package is used to handle the serialization and deserialization of JSON. 1. Structural fields need to be accessed capitalized in the first letter. Set the key name through json:"name". Omitempty omits fields when the value is zero. json:"-" ignores fields; 2. Use json.Marshal to convert structure, map or slice to JSON string, and use json.Unmarshal to parse JSON data into variables; 3. When deserializing to interface{}, the number defaults to float64 type and needs to be converted through type assertions; 4. Nested structures can be serialized normally, and the embedded structure will be expanded; 5. Always check for errors in Marshal and Unmarshal. Common problems include JSON format errors, type mismatch, and non-exported fields. Correctly using struct tags and data structures can flexibly handle various JSON scenarios.

In the Go language, encoding/json package provides support for serialization (marshal) and deserialization (unmarshal) of JSON data. Here are a few common examples to demonstrate how to use json.Marshal and json.Unmarshal .

✅ Marshal and Unmarshal of basic structures

 package main

import (
    "encoding/json"
    "fmt"
    "log"
)

type Person struct {
    Name string `json:"name"`
    Age int `json:"age"`
    Email string `json:"email,omitempty"`
}

func main() {
    // Example 1: Marshal structure → JSON
    p := Person{
        Name: "Alice",
        Age: 30,
        Email: "alice@example.com",
    }

    data, err := json.Marshal(p)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Marshal result: %s\n", data)

    // Example 2: Unmarshal JSON → Structure jsonData := `{"name":"Bob","age":25,"email":"bob@example.com"}`
    var p2 Person
    err = json.Unmarshal([]byte(jsonData), &p2)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Unmarshal result: %v\n", p2)
}

Output:

 Marshal result: {"name":"Alice","age":30,"email":"alice@example.com"}
Unmarshal result: {Name:Bob Age:25 Email:bob@example.com}

Notice:

• json:"name" specifies the key name of the field in JSON.
• omitempty means that if the field is a zero value (such as empty string, 0, nil, etc.), it is omitted during serialization.

✅ Marshal and Unmarshal that handle maps

 // Marshal map → JSON
m := map[string]interface{}{
    "name": "Charlie",
    "age": 35,
    "tags": []string{"go", "dev"},
}
data, _ := json.Marshal(m)
fmt.Printf("Map to JSON: %s\n", data)

// Unmarshal JSON → map
var m2 map[string]interface{}
jsonData := `{"name":"David","age":28,"active":true}`
json.Unmarshal([]byte(jsonData), &m2)
fmt.Printf("JSON to map: %v\n", m2)

// Note: The number in the map resolves to float64 by default
if age, ok := m2["age"].(float64); ok {
    fmt.Println("Age:", int(age))
}

Output:

 Map to JSON: {"age":35,"name":"Charlie","tags":["go","dev"]}
JSON to map: map[age:28 name:David active:true]
Age: 28

⚠️ Note: When json.Unmarshal parses to interface{} , the number is float64 by default, and type assertion is required.

✅ Process slices and arrays

 people := []Person{
    {Name: "Alice", Age: 30},
    {Name: "Bob", Age: 25},
}

// Marshal slice
data, _ = json.Marshal(people)
fmt.Printf("Slice to JSON: %s\n", data)

// Unmarshal JSON array → slice
jsonData := `[{"name":"Eve","age":22},{"name":"Frank","age":33}]`
var people2 []Person
json.Unmarshal([]byte(jsonData), &people2)
fmt.Printf("JSON to slice: %v\n", people2)

Output:

 Slice to JSON: [{"name":"Alice","age":30},{"name":"Bob","age":25}]
JSON to slice: [{Name:Eve Age:22 Email:} {Name:Frank Age:33 Email:}]

✅ Ignore empty fields (using omitempty)

 p := Person{
    Name: "Grace",
    Age: 0, // Zero value// Leave blank in Email}

data, _ = json.Marshal(p)
fmt.Printf("With omitempty: %s\n", data)

Output:

 With omitempty: {"name":"Grace"}

Because Age is 0 (the zero value of int), but no omitempty , it will still output.
Email has omitempty and is empty, so it is omitted.

If you want to omit even the zero value, you can write it like this:

 Age int `json:"age,omitempty"`

✅ Nested structure and custom field names

 type Address struct {
    City string `json:"city"`
    Zip string `json:"zip"`
}

type User struct {
    Person `json:"person"` // Inline structure Address Address `json:"address"`
    Password string `json:"-"` // Not involved in serialization}

u := User{
    Person: Person{Name: "Helen", Age: 29},
    Address: Address{City: "Beijing", Zip: "100000"},
    Password: "secret123",
}

data, _ := json.Marshal(u)
fmt.Printf("Nested struct: %s\n", data)

Output:

 Nested struct: {"person":{"name":"Helen","age":29},"address":{"city":"Beijing","zip":"100000"}}

• The embedded structure will be expanded.
• json:"-" means that the field will not be serialized or deserialized.

✅ Error handling suggestions

When using json.Marshal and json.Unmarshal , always check for errors :

 data, err := json.Marshal(someValue)
if err != nil {
    log.Printf("Marshal error: %v", err)
    Return
}

err = json.Unmarshal(jsonData, &target)
if err != nil {
    log.Printf("Unmarshal error: %v", err)
    Return
}

Common errors include:

• The JSON format is illegal
• Type mismatch (as expected number but get string)
• Fields cannot be exported (struct fields must be capitalized to be accessed by json packages)

Summary: Key points

• Structure fields must be capitalized in the first letter to be accessed by json package.
• Use json:"fieldName" to customize the key name.
• omitempty can omit empty value fields.
• json:"-" Ignore fields.
• map[string]interface{} and []interface{} can be used for dynamic structures, but pay attention to type assertions.
• The number is float64 by default in interface{} .

Basically that's it. In actual development, combining struct tag and reasonable data structures can flexibly handle most JSON scenarios.

The above is the detailed content of go by example json marshal and unmarshal. For more information, please follow other related articles on the PHP Chinese website!