A struct in Go is a user-defined data type that groups related fields to model real-world entities. 1. It is defined using the type keyword followed by the struct name and a list of fields with their types. 2. Structs can contain fields of different data types, including other structs. 3. When not initialized, fields take zero values (e.g., "" for strings, 0 for ints). 4. Structs are value types, meaning assignments copy the entire struct. 5. Anonymous structs can be created for one-off groupings without a named type. 6. Methods can be attached using a receiver, enabling object-like behavior. 7. Struct tags (e.g., json:"name") provide metadata for serialization with packages like encoding/json. Structs are essential for organizing structured data efficiently in Go and work seamlessly with the standard library.

A struct in Go (Golang) is a user-defined data type that allows you to group together related data fields under a single name. It’s like a blueprint for creating objects that can hold different kinds of data.

Think of a struct as a container that holds multiple pieces of information (called fields) that describe something — for example, a person, a book, or a coordinate point.

Why Use Structs?

Go doesn’t have classes like other languages, but structs fill a similar role by letting you model real-world entities. They’re especially useful when you want to represent structured data in a clean, organized way.

For example, instead of having separate variables like name, age, and email, you can group them into a Person struct.

How to Define and Use a Struct

Here’s a simple example:

package main

import "fmt"

// Define a struct type
type Person struct {
    Name string
    Age  int
    Email string
}

func main() {
    // Create an instance of Person
    p := Person{
        Name:  "Alice",
        Age:   30,
        Email: "alice@example.com",
    }

    fmt.Println(p)           // {Alice 30 alice@example.com}
    fmt.Println(p.Name)      // Alice
}

In this example:

• Person is the struct type.
• Name, Age, and Email are its fields.
• p is a value (instance) of type Person.

Key Features of Structs

• Fields can be of different types: You can mix strings, ints, booleans, slices, even other structs.
• Zero value: If you don’t initialize a struct, Go gives each field its zero value (e.g., "" for string, 0 for int).
• Structs are value types: When you assign one struct to another, it’s copied, not referenced.
• Anonymous structs: You can create structs without naming the type, useful for one-off data groupings.

Example of an anonymous struct:

user := struct {
    Username string
    Active   bool
}{
    Username: "bob",
    Active:   true,
}

Structs and Methods

You can also define methods on structs, which makes them behave a bit like objects in OOP:

func (p Person) Greet() {
    fmt.Printf("Hi, I'm %s and I'm %d years old.\n", p.Name, p.Age)
}

// Later in main:
p.Greet() // Output: Hi, I'm Alice and I'm 30 years old.

The (p Person) part is called a receiver, and it attaches the function to the Person type.

Struct Tags (for JSON, DB, etc.)

Structs often use tags to control how fields are serialized. For example, when converting to JSON:

type User struct {
    Name  string `json:"name"`
    Email string `json:"email"`
}

These tags don’t affect Go code directly but are used by packages like encoding/json.

Basically, structs are the go-to way to organize and model data in Go. They’re simple, efficient, and work seamlessly with Go’s standard library.

The above is the detailed content of What is a struct in Golang?. For more information, please follow other related articles on the PHP Chinese website!