GoHow-ToBeginner · 3 min read

How to Use Anonymous Struct in Go: Syntax and Examples

In Go, you can use anonymous structs by declaring a struct type without a name directly where you need it. This is useful for quick, one-off data grouping without creating a named type.

📐

Syntax

An anonymous struct is declared by using the struct keyword followed by the fields inside curly braces, without giving it a name. You can create variables of this struct type directly.

Example parts:

struct { Field1 type1; Field2 type2 }: Defines the structure fields and their types.
Variable declaration with this struct type, e.g., var x struct { Name string; Age int }.
Initialization with values using composite literal syntax.

var person struct {
    Name string
    Age  int
}

person.Name = "Alice"
person.Age = 30

💻

Example

This example shows how to declare, initialize, and use an anonymous struct in Go. It prints the values stored in the struct fields.

package main

import "fmt"

func main() {
    // Declare and initialize an anonymous struct
    user := struct {
        Username string
        Email    string
        Age      int
    }{
        Username: "johndoe",
        Email:    "john@example.com",
        Age:      25,
    }

    // Access and print the fields
    fmt.Println("Username:", user.Username)
    fmt.Println("Email:", user.Email)
    fmt.Println("Age:", user.Age)
}

Output

Username: johndoe Email: john@example.com Age: 25

⚠️

Common Pitfalls

Common mistakes when using anonymous structs include:

Trying to reuse the anonymous struct type in multiple places without defining a named struct, which leads to type incompatibility.
Forgetting to initialize the struct fields before use, causing zero values to appear unexpectedly.
Using anonymous structs for complex data models where named structs improve readability and maintainability.

package main

import "fmt"

func main() {
    // Wrong: Trying to assign one anonymous struct to another with same fields but different types
    a := struct { Name string }{Name: "Alice"}
    b := struct { Name string }{Name: "Bob"}

    // This causes a compile error: cannot use b (type struct { Name string }) as type struct { Name string } in assignment
    // a = b

    // Right: Use a named struct type to allow assignment
    type Person struct {
        Name string
    }

    p1 := Person{Name: "Alice"}
    p2 := Person{Name: "Bob"}
    p1 = p2
    fmt.Println(p1.Name) // Output: Bob
}

Output

Bob

📊

Quick Reference

Tips for using anonymous structs in Go:

Use anonymous structs for quick, one-time data grouping.
Named structs are better for reuse and clarity.
Anonymous structs can be initialized inline with composite literals.
Anonymous structs with the same fields but declared separately are different types.

✅

Key Takeaways

Anonymous structs let you create quick, unnamed data groups without defining a new type.

Each anonymous struct declaration creates a unique type, even if fields match another anonymous struct.

Use named structs when you need to reuse the same structure type across your code.

Initialize anonymous structs with composite literals for easy setup.

Avoid assigning one anonymous struct to another unless they share the exact same named type.