Implement the Stringer Interface in Go

In Go, the fmt package provides a powerful way to format and print values. One of its core features is the Stringer interface, which allows custom types to define their own string representation. This challenge will guide you through implementing this interface for a custom data structure. Understanding and implementing the Stringer interface is crucial for writing clean, readable, and idiomatic Go code, especially when debugging or logging.

Problem Description

Your task is to create a Go program that defines a custom type and then implements the Stringer interface for that type. The Stringer interface is defined as follows:

type Stringer interface {
    String() string
}

You will need to:

1. Define a custom struct: Create a struct that holds some meaningful data. For this challenge, let's call it Person and have it contain Name (string) and Age (int) fields.
2. Implement the String() method: Write a String() method for your Person struct. This method should return a human-readable string representation of the Person object. The format should be consistent and informative.
3. Demonstrate usage: In your main function, create an instance of your Person struct and print it using fmt.Println(). The fmt package will automatically detect and use your String() method if it's implemented.

Expected Behavior: When a Person object is passed to fmt.Println(), it should print the string returned by its String() method, not the default struct representation.

Edge Cases to Consider:

• What if a Person's name is an empty string?
• What if a Person's age is zero or negative? (While unlikely for age, consider how your string representation handles such values).

Examples

Example 1:

Input:
person := Person{Name: "Alice", Age: 30}

Output:
Name: Alice, Age: 30

Explanation:
The String() method for Person is called, returning the formatted string.

Example 2:

Input:
person := Person{Name: "", Age: 5}

Output:
Name: , Age: 5

Explanation:
Even with an empty name, the String() method should produce a valid output.

Example 3:

Input:
person := Person{Name: "Bob", Age: 0}

Output:
Name: Bob, Age: 0

Explanation:
The String() method handles zero values gracefully.

Constraints

• The Person struct must have fields named Name (string) and Age (int).
• The String() method must be associated with the Person struct (i.e., it should be a method receiver).
• The String() method must return a string.
• The output format for a Person should clearly display both Name and Age.
• Your solution should be a single Go file.

Notes

• You can use fmt.Sprintf within your String() method to construct the output string.
• Think about what makes a string representation "human-readable" and "informative" for a Person object.
• The fmt package handles the magic of calling the String() method when it encounters a Stringer. You don't need to explicitly call person.String().