Go语言读取JSON文件并构建嵌套结构及追加自定义数据的实现咨询

Hey there! Since you're new to Go, let's walk through this problem step by step—building nested structs where one comes from a JSON file, the other is custom, then outputting the result to stdout. I'll include a complete example and point out common pitfalls to watch out for.

Step 1: Define Your Core Struct (From JSON) #

First, you need to define a struct that matches the structure of your JSON file. Use Go's json struct tags to map JSON fields to your struct fields (remember: JSON is case-sensitive, and Go struct fields need to be uppercase to be exported for the encoding/json package).

For example, if your JSON file (data.json) looks like this:

{
  "product_id": 123,
  "name": "Wireless Headphones",
  "price": 99.99,
  "in_stock": true
}

Your core struct would look like this:

// Product represents the core data from our JSON file
type Product struct {
    ProductID int     `json:"product_id"`
    Name      string  `json:"name"`
    Price     float64 `json:"price"`
    InStock   bool    `json:"in_stock"`
}

Step 2: Define Your Custom Nested Struct #

Next, create your custom struct that nests the core Product struct. You can embed it directly or include it as a named field—either works, depending on your needs.

Here's an example of a custom order struct that includes the product:

// Order is our custom struct that nests the core Product data
type Order struct {
    OrderID   int     // Custom field we define
    Customer  string  // Another custom field
    Item      Product // Nested core struct from JSON
    OrderDate string  // Custom date field
}

Step 3: Read & Parse the JSON File #

Now, let's write code to read the JSON file and parse it into our Product struct. We'll use the os package to open the file, io.ReadAll to read its contents, and encoding/json to unmarshal the JSON into our struct.

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "os"
)

// ... (include the Product and Order structs here)

func main() {
    // Step 1: Open the JSON file
    file, err := os.Open("data.json")
    if err != nil {
        fmt.Printf("Failed to open file: %v\n", err)
        return
    }
    defer file.Close() // Make sure we close the file when done

    // Step 2: Read the file contents
    jsonData, err := io.ReadAll(file)
    if err != nil {
        fmt.Printf("Failed to read file: %v\n", err)
        return
    }

    // Step 3: Parse JSON into our Product struct
    var product Product
    err = json.Unmarshal(jsonData, &product)
    if err != nil {
        fmt.Printf("Failed to parse JSON: %v\n", err)
        return
    }

Step 4: Assemble the Nested Struct & Output to Stdout #

Now that we have our parsed Product data, we can create an instance of our custom Order struct, fill in the custom fields, and then print it to stdout. You can print it as a formatted string or re-serialize it back to JSON for a clean output.

// Step 4: Create our custom Order with nested Product
    order := Order{
        OrderID:   456,
        Customer:  "John Doe",
        Item:      product, // Nest the parsed Product data
        OrderDate: "2024-05-20",
    }

    // Option 1: Print as a formatted string using fmt
    fmt.Println("Order Details:")
    fmt.Printf("Order ID: %d\n", order.OrderID)
    fmt.Printf("Customer: %s\n", order.Customer)
    fmt.Printf("Product: %s (ID: %d, Price: $%.2f)\n", order.Item.Name, order.Item.ProductID, order.Item.Price)
    fmt.Printf("In Stock: %t\n", order.Item.InStock)
    fmt.Printf("Order Date: %s\n", order.OrderDate)

    // Option 2: Print as pretty-printed JSON (often cleaner for nested data)
    fmt.Println("\nOrder as JSON:")
    orderJSON, err := json.MarshalIndent(order, "", "  ")
    if err != nil {
        fmt.Printf("Failed to marshal order to JSON: %v\n", err)
        return
    }
    fmt.Println(string(orderJSON))
}

Common Pitfalls to Avoid #

• Unexported Struct Fields: Make sure all struct fields you want to parse from JSON or output are uppercase (exported). Lowercase fields are private to the package and won't be processed by encoding/json.
• JSON Tag Mismatches: Double-check that your json:"field_name" tags exactly match the keys in your JSON file (case-sensitive!).
• File Path Issues: If your JSON file isn't in the same directory as your Go binary, use an absolute path or make sure you're running the program from the correct working directory.
• Error Handling: Don't skip error checks! Every file operation and JSON parsing step can fail, so always handle those errors gracefully.

When you run this code, you'll see both the formatted string and pretty-printed JSON output in your terminal (stdout).

内容的提问来源于stack exchange，提问作者expert.free