JSON Marshalling in Go: Struct to JSON

This challenge focuses on converting a Go struct into a JSON string. JSON (JavaScript Object Notation) is a widely used data format for data interchange, and the ability to marshal Go data structures into JSON is a fundamental skill for many Go developers. This exercise will test your understanding of Go's encoding/json package and how to handle struct fields during JSON serialization.

Problem Description

You are tasked with creating a Go function that takes a struct as input and marshals it into a JSON string. The struct will contain various data types (string, integer, boolean, float64, and potentially nested structs). Your function should handle the conversion gracefully, producing a valid JSON string representation of the input struct. The function should return the JSON string and an error if any occurred during the marshaling process.

Key Requirements:

• The function must accept a struct as input.
• The function must use the encoding/json package to marshal the struct into a JSON string.
• The function must return the JSON string and an error.
• The function should handle potential errors during marshaling and return a non-nil error in case of failure.
• The JSON output should be properly formatted (e.g., with appropriate indentation for readability, though this is not strictly required for correctness).

Expected Behavior:

The function should successfully convert the input struct into a JSON string. If the struct contains fields with specific tags (e.g., - to omit a field, or custom tags for renaming), these tags should be respected during the marshaling process. If any error occurs during marshaling (e.g., invalid data type, unsupported field), the function should return an error.

Edge Cases to Consider:

• Nil values in the struct. How should these be represented in JSON (e.g., as null or omitted)?
• Struct fields with the - tag (to omit the field from the JSON output).
• Struct fields with custom tags for renaming.
• Nested structs.
• Error handling when marshaling fails.

Examples

Example 1:

Input:
type Address struct {
    Street string `json:"street"`
    City   string `json:"city"`
}

type Person struct {
    Name    string `json:"name"`
    Age     int    `json:"age"`
    Address Address `json:"address"`
    IsActive bool `json:"active"`
}

person := Person{
    Name:    "Alice",
    Age:     30,
    Address: Address{
        Street: "123 Main St",
        City:   "Anytown",
    },
    IsActive: true,
}

Output:
`{"name":"Alice","age":30,"address":{"street":"123 Main St","city":"Anytown"},"active":true}`
Explanation: The Person struct is successfully marshaled into a JSON string, including the nested Address struct.

Example 2:

Input:
type Product struct {
    ID        int    `json:"id"`
    Name      string `json:"name"`
    Price     float64 `json:"price"`
    Discount  float64 `json:"-"` // Omit Discount field
}

product := Product{
    ID:        1,
    Name:      "Laptop",
    Price:     1200.00,
    Discount:  0.10,
}

Output:
`{"id":1,"name":"Laptop","price":1200}`
Explanation: The Product struct is marshaled, but the Discount field is omitted because of the `-` tag.

Example 3: (Edge Case - Nil Value)

Input:
type Employee struct {
    ID      int    `json:"id"`
    Name    string `json:"name"`
    Manager *string `json:"manager,omitempty"` // Optional manager field
}

employee := Employee{
    ID:      101,
    Name:    "Bob",
    Manager: nil,
}

Output:
`{"id":101,"name":"Bob"}`
Explanation: The Manager field is nil, and the `omitempty` tag ensures it's omitted from the JSON output.

Constraints

• The input struct can contain fields of type string, int, bool, float64, and nested structs.
• Struct fields can have json tags for renaming or omitting fields.
• The function must handle errors gracefully and return a non-nil error if marshaling fails.
• The JSON output should be a valid JSON string.
• The function should be efficient enough to handle reasonably sized structs (e.g., up to 100 fields).

Notes

• The encoding/json package provides the Marshal function for converting a struct to a JSON byte slice. You'll need to convert the byte slice to a string.
• Consider using the omitempty tag to exclude fields with zero values from the JSON output.
• Error handling is crucial. Always check the error returned by json.Marshal and return it appropriately.
• Think about how to handle nil pointers within your structs. The omitempty tag is helpful here.
• While pretty-printing (indenting) the JSON is not required, it can improve readability for debugging purposes. You can use json.MarshalIndent for this.