Go is a simple and powerful programming language, and one of its most important features for organizing related data is the struct.

A struct allows you to group multiple values of different data types into a single custom type.

For example, instead of storing a user’s name, age, and email in separate variables, you can combine them inside one struct.

type User struct {
    Name  string
    Age   int
    Email string
}

Now a single User value can contain all the related information for one user.

In this guide, you will learn what structs are in Go, how to create them, initialize them, access and update fields, use structs with functions, slices, maps, pointers, nested structs, and more.

---

What Is a Struct in Go?

A struct in Go is a user-defined data type that groups related values together.

Each value inside a struct is called a field.

For example:

type Student struct {
    Name  string
    Age   int
    Grade float64
}

Here:

• Student is the struct type.
• Name is a string field.
• Age is an int field.
• Grade is a float64 field.

A struct is useful when multiple pieces of information belong to the same object or entity.

For example, a student may have:

• Name
• Age
• Roll number
• Grade
• Email

Instead of managing all these values separately, you can group them inside one struct.

---

Why Are Structs Used in Go?

Structs help organize application data in a clear and structured way.

Suppose you store user information using separate variables:

name := "Ankit"
age := 24
email := "ankit@example.com"

This works for one user, but it becomes difficult to manage when you have many users.

A struct makes the relationship between these values clear.

type User struct {
    Name  string
    Age   int
    Email string
}

Now you can create a complete user:

user := User{
    Name:  "Ankit",
    Age:   24,
    Email: "ankit@example.com",
}

Structs are commonly used for:

• Users
• Products
• Employees
• Students
• Orders
• API responses
• Database records
• Application settings
• Configuration data

---

Go Struct Syntax

The basic syntax for defining a struct is:

type StructName struct {
    Field1 DataType
    Field2 DataType
    Field3 DataType
}

Example:

type Product struct {
    Name  string
    Price float64
    Stock int
}

Here, Product becomes a new custom type.

You can now create variables of type Product.

---

Creating Your First Struct in Go

Let’s create a simple student struct.

package main

import "fmt"

type Student struct {
    Name string
    Age  int
}

func main() {
    student := Student{
        Name: "Ankit",
        Age:  24,
    }

    fmt.Println(student)
}

Output:

{Ankit 24}

The variable student contains both the name and age.

---

Accessing Struct Fields

Struct fields are accessed using the dot . operator.

Example:

student.Name
student.Age

Complete example:

package main

import "fmt"

type Student struct {
    Name string
    Age  int
}

func main() {
    student := Student{
        Name: "Ankit",
        Age:  24,
    }

    fmt.Println(student.Name)
    fmt.Println(student.Age)
}

Output:

Ankit
24

---

Updating Struct Fields

You can update struct fields using the dot operator.

Example:

student.Age = 25

Complete example:

package main

import "fmt"

type Student struct {
    Name string
    Age  int
}

func main() {
    student := Student{
        Name: "Ankit",
        Age:  24,
    }

    fmt.Println("Before:", student.Age)

    student.Age = 25

    fmt.Println("After:", student.Age)
}

Output:

Before: 24
After: 25

---

Different Ways to Initialize a Struct

Go provides multiple ways to create struct values.

1. Initialize Using Field Names

This is the most readable approach.

user := User{
    Name:  "Ankit",
    Age:   24,
    Email: "ankit@example.com",
}

This style is recommended because each value clearly shows which field it belongs to.

---

2. Initialize Without Field Names

You can also initialize fields based on their declared order.

user := User{
    "Ankit",
    24,
    "ankit@example.com",
}

Example:

type User struct {
    Name  string
    Age   int
    Email string
}

Then:

user := User{"Ankit", 24, "ankit@example.com"}

This works, but it is usually less readable.

It can also become difficult to maintain if the struct fields change.

Using field names is generally clearer.

---

Creating an Empty Struct Value

You can create a struct without providing any values.

var user User

Go automatically gives every field its zero value.

Consider:

type User struct {
    Name   string
    Age    int
    Active bool
}

Then:

var user User

fmt.Println(user)

Output:

{ 0 false}

The fields receive their zero values:

Type	Zero Value
string	""
int	0
float64	0
bool	false
pointer	nil

You can assign values later:

user.Name = "Ankit"
user.Age = 24
user.Active = true

---

Partial Struct Initialization

When using field names, you do not need to provide every field.

Example:

type User struct {
    Name   string
    Age    int
    Email  string
    Active bool
}

You can create:

user := User{
    Name: "Ankit",
    Age:  24,
}

The remaining fields automatically receive zero values.

So:

fmt.Println(user.Email)
fmt.Println(user.Active)

will return:

false

---

Struct with Different Data Types

A struct can contain different types of values.

Example:

type Product struct {
    Name      string
    Price     float64
    Quantity  int
    Available bool
}

Create a product:

product := Product{
    Name:      "Laptop",
    Price:     65000.50,
    Quantity:  10,
    Available: true,
}

Access the values:

fmt.Println(product.Name)
fmt.Println(product.Price)
fmt.Println(product.Quantity)
fmt.Println(product.Available)

---

Using Structs with Functions

Structs can be passed to functions just like other Go values.

Example:

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

func printUser(user User) {
    fmt.Println("Name:", user.Name)
    fmt.Println("Age:", user.Age)
}

func main() {
    user := User{
        Name: "Ankit",
        Age:  24,
    }

    printUser(user)
}

Output:

Name: Ankit
Age: 24

---

Returning a Struct from a Function

Functions can also return struct values.

Example:

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

func createUser() User {
    return User{
        Name: "Ankit",
        Age:  24,
    }
}

func main() {
    user := createUser()

    fmt.Println(user.Name)
    fmt.Println(user.Age)
}

Output:

Ankit
24

This pattern is commonly used when creating or loading data.

---

Passing Structs by Value

By default, passing a struct to a function creates a copy of that struct value.

Example:

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

func updateAge(user User) {
    user.Age = 30
}

func main() {
    user := User{
        Name: "Ankit",
        Age:  24,
    }

    updateAge(user)

    fmt.Println(user.Age)
}

Output:

24

The original value does not change because the function receives a copy.

---

Using Pointers with Structs

If you want a function to modify the original struct, pass a pointer.

Example:

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

func updateAge(user *User) {
    user.Age = 30
}

func main() {
    user := User{
        Name: "Ankit",
        Age:  24,
    }

    updateAge(&user)

    fmt.Println(user.Age)
}

Output:

30

Here:

&user

passes the memory address of user.

The function accepts:

user *User

which means a pointer to a User.

Go allows you to access struct fields through a pointer using the same dot syntax:

user.Age

You do not normally need to write:

(*user).Age

Go automatically handles this field access.

---

Creating a Struct Pointer

You can directly create a pointer to a struct.

Example:

user := &User{
    Name: "Ankit",
    Age:  24,
}

Then:

fmt.Println(user.Name)
fmt.Println(user.Age)

works normally.

---

Anonymous Structs in Go

You can create a struct without defining a named struct type.

This is called an anonymous struct.

Example:

package main

import "fmt"

func main() {
    user := struct {
        Name string
        Age  int
    }{
        Name: "Ankit",
        Age:  24,
    }

    fmt.Println(user.Name)
    fmt.Println(user.Age)
}

Anonymous structs can be useful for small temporary data structures.

However, if you need to reuse the same structure many times, creating a named struct type is usually better.

---

Nested Structs in Go

A struct can contain another struct.

This is called a nested struct.

Example:

type Address struct {
    City    string
    Country string
}

type User struct {
    Name    string
    Age     int
    Address Address
}

Create a value:

user := User{
    Name: "Ankit",
    Age:  24,
    Address: Address{
        City:    "Jaipur",
        Country: "India",
    },
}

Access nested fields:

fmt.Println(user.Address.City)
fmt.Println(user.Address.Country)

Output:

Jaipur
India

Nested structs are useful when part of an object’s data has its own structure.

---

Embedded Structs in Go

Go also supports struct embedding.

Instead of naming the nested field explicitly:

type User struct {
    Name    string
    Address Address
}

you can embed the type:

type User struct {
    Name string
    Address
}

Example:

package main

import "fmt"

type Address struct {
    City    string
    Country string
}

type User struct {
    Name string
    Address
}

func main() {
    user := User{
        Name: "Ankit",
        Address: Address{
            City:    "Jaipur",
            Country: "India",
        },
    }

    fmt.Println(user.Name)
    fmt.Println(user.City)
    fmt.Println(user.Country)
}

Output:

Ankit
Jaipur
India

Because Address is embedded, its fields can be promoted and accessed directly through user.

Struct embedding is Go’s way of composing types without traditional class inheritance.

---

Slice of Structs in Go

A slice can contain multiple struct values.

This is extremely common in Go applications.

Example:

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

func main() {
    users := []User{
        {
            Name: "Ankit",
            Age:  24,
        },
        {
            Name: "Rahul",
            Age:  26,
        },
        {
            Name: "Priya",
            Age:  23,
        },
    }

    fmt.Println(users)
}

You can access individual users:

fmt.Println(users[0].Name)

Output:

Ankit

---

Looping Through a Slice of Structs

Use range to iterate through a slice of structs.

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

func main() {
    users := []User{
        {Name: "Ankit", Age: 24},
        {Name: "Rahul", Age: 26},
        {Name: "Priya", Age: 23},
    }

    for _, user := range users {
        fmt.Println(user.Name, user.Age)
    }
}

Output:

Ankit 24
Rahul 26
Priya 23

This pattern is common when displaying database records, API results, or lists of application objects.

---

Map of Structs in Go

Maps can also store structs as values.

Example:

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

func main() {
    users := map[int]User{
        101: {
            Name: "Ankit",
            Age:  24,
        },
        102: {
            Name: "Rahul",
            Age:  26,
        },
    }

    fmt.Println(users[101])
    fmt.Println(users[101].Name)
}

Output:

{Ankit 24}
Ankit

This is useful when each struct can be identified by a unique key such as a user ID.

---

Comparing Structs in Go

Struct values can be compared using == when all their fields are comparable.

Example:

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

func main() {
    user1 := User{
        Name: "Ankit",
        Age:  24,
    }

    user2 := User{
        Name: "Ankit",
        Age:  24,
    }

    fmt.Println(user1 == user2)
}

Output:

true

The comparison checks each field.

If one field differs:

user2.Age = 25

Then:

fmt.Println(user1 == user2)

Output:

false

However, if a struct contains a non-comparable field such as a slice or map, the struct itself cannot be compared using ==.

---

Copying Structs

When you assign one struct variable to another, Go copies the struct value.

Example:

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

func main() {
    user1 := User{
        Name: "Ankit",
        Age:  24,
    }

    user2 := user1

    user2.Age = 30

    fmt.Println(user1.Age)
    fmt.Println(user2.Age)
}

Output:

24
30

Changing user2.Age does not change user1.Age.

This is different from assigning maps, which refer to shared underlying map data.

---

Structs with Methods

You can define methods on struct types.

A method is similar to a function, but it belongs to a specific type.

Example:

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

func (u User) greet() {
    fmt.Println("Hello, my name is", u.Name)
}

func main() {
    user := User{
        Name: "Ankit",
        Age:  24,
    }

    user.greet()
}

Output:

Hello, my name is Ankit

Here:

func (u User) greet()

means that greet() is a method with a User receiver.

You can call it using:

user.greet()

---

Pointer Receiver Methods

If a method needs to modify the struct, use a pointer receiver.

Example:

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

func (u *User) updateAge(age int) {
    u.Age = age
}

func main() {
    user := User{
        Name: "Ankit",
        Age:  24,
    }

    user.updateAge(30)

    fmt.Println(user.Age)
}

Output:

30

A pointer receiver lets the method modify the original value.

---

Struct Tags in Go

Struct fields can have optional metadata called struct tags.

A very common use is JSON encoding and decoding.

Example:

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

The tags:

json:"name"
json:"age"
json:"email"

tell JSON-related code what field names to use.

For example, this struct:

User{
    Name:  "Ankit",
    Age:   24,
    Email: "ankit@example.com",
}

can be represented in JSON as:

{
  "name": "Ankit",
  "age": 24,
  "email": "ankit@example.com"
}

Struct tags are commonly used with:

• JSON
• Databases
• Validation libraries
• Configuration tools

---

Exported and Unexported Struct Fields

Go uses capitalization to control visibility.

A field beginning with an uppercase letter is exported.

Example:

type User struct {
    Name string
    Age  int
}

Name and Age can be accessed from other packages.

A lowercase field is unexported:

type User struct {
    name string
    age  int
}

These fields are only directly accessible within the same package.

This becomes especially important when working with JSON libraries and other packages.

---

Practical Example: Product Struct

Let’s create a simple product model.

package main

import "fmt"

type Product struct {
    ID        int
    Name      string
    Price     float64
    Quantity  int
    Available bool
}

func main() {
    product := Product{
        ID:        101,
        Name:      "Laptop",
        Price:     65000,
        Quantity:  5,
        Available: true,
    }

    fmt.Println("Product ID:", product.ID)
    fmt.Println("Name:", product.Name)
    fmt.Println("Price:", product.Price)
    fmt.Println("Quantity:", product.Quantity)
    fmt.Println("Available:", product.Available)
}

Output:

Product ID: 101
Name: Laptop
Price: 65000
Quantity: 5
Available: true

---

Practical Example: Employee Management

Structs are especially useful when handling multiple records.

package main

import "fmt"

type Employee struct {
    ID     int
    Name   string
    Salary float64
}

func main() {
    employees := []Employee{
        {
            ID:     101,
            Name:   "Ankit",
            Salary: 50000,
        },
        {
            ID:     102,
            Name:   "Rahul",
            Salary: 55000,
        },
        {
            ID:     103,
            Name:   "Priya",
            Salary: 60000,
        },
    }

    for _, employee := range employees {
        fmt.Println(
            employee.ID,
            employee.Name,
            employee.Salary,
        )
    }
}

Output:

101 Ankit 50000
102 Rahul 55000
103 Priya 60000

---

Struct vs Map in Go

Beginners often wonder whether to use a struct or a map.

Both store related information, but they are designed for different situations.

Feature	Struct	Map
Fields/keys	Defined fields	Dynamic keys
Types	Fields can have different types	Values usually share one declared type
Structure	Fixed	Dynamic
Field access	user.Name	user["name"]
Compile-time checking	Strong	Less structured
Best for	Known data models	Dynamic key-value data

For example, use a struct for a user:

type User struct {
    Name  string
    Age   int
    Email string
}

Because you already know what fields a user should contain.

Use a map when the keys are dynamic:

settings := map[string]string{
    "theme":    "dark",
    "language": "en",
}

---

Struct vs Class

Go does not use traditional classes like Java, C++, or C#.

Instead, Go combines:

• Structs
• Methods
• Interfaces
• Composition

A struct stores data:

type User struct {
    Name string
}

A method provides behavior:

func (u User) greet() {
    fmt.Println("Hello", u.Name)
}

Together, they allow Go programs to model entities without requiring class-based inheritance.

---

Common Mistakes with Go Structs

1. Forgetting Field Names

This works:

user := User{"Ankit", 24}

But it depends on field order.

This is usually clearer:

user := User{
    Name: "Ankit",
    Age:  24,
}

---

2. Expecting a Function to Modify a Struct Passed by Value

This will not modify the original:

func update(user User) {
    user.Age = 30
}

Use a pointer instead:

func update(user *User) {
    user.Age = 30
}

---

3. Using Lowercase Fields When Data Must Be Exported

For example:

type User struct {
    name string
}

The name field is unexported.

For data that needs to be accessed by other packages, use:

type User struct {
    Name string
}

---

4. Using a Map When the Data Structure Is Known

This works:

user := map[string]interface{}{
    "name": "Ankit",
    "age":  24,
}

But when the fields are known, a struct is usually clearer and safer:

type User struct {
    Name string
    Age  int
}

---

When Should You Use Structs in Go?

Structs are a good choice whenever several related values represent one object.

For example:

User

type User struct {
    ID    int
    Name  string
    Email string
}

Product

type Product struct {
    ID    int
    Name  string
    Price float64
}

Student

type Student struct {
    Name  string
    Age   int
    Grade float64
}

Order

type Order struct {
    ID     int
    Amount float64
    Status string
}

Address

type Address struct {
    City    string
    State   string
    Country string
}

Structs are one of the main ways Go applications model real-world data.

---

Best Practices for Go Structs

When working with structs, follow these basic practices:

1. Use descriptive struct and field names.
2. Use named fields when creating struct values for better readability.
3. Capitalize fields that must be exported to other packages.
4. Use pointers when functions or methods need to modify the original struct.
5. Use nested structs when related information has its own clear structure.
6. Prefer structs over generic maps when the data structure is already known.
7. Use slices of structs for collections of structured records.
8. Use struct tags when working with JSON, databases, or similar tools.

---

Frequently Asked Questions

What is a struct in Go?

A struct is a custom data type that groups multiple related fields into one value.

Example:

type User struct {
    Name string
    Age  int
}

---

How do you create a struct in Go?

Define it with the type and struct keywords:

type Product struct {
    Name  string
    Price float64
}

Then create a value:

product := Product{
    Name:  "Laptop",
    Price: 65000,
}

---

How do you access struct fields?

Use the dot operator:

fmt.Println(product.Name)

---

How do you update a struct field?

Assign a new value:

product.Price = 70000

---

Can a struct contain another struct?

Yes.

Example:

type User struct {
    Name    string
    Address Address
}

---

Can a slice contain structs?

Yes.

users := []User{
    {Name: "Ankit", Age: 24},
    {Name: "Rahul", Age: 26},
}

---

Can a map contain structs?

Yes.

users := map[int]User{
    1: {Name: "Ankit", Age: 24},
}

---

Are structs copied in Go?

Yes. Structs are value types.

When one struct is assigned to another, its value is copied.

user2 := user1

Changing a simple field in user2 does not automatically change the same field in user1.

---

What is a struct pointer?

A struct pointer stores the address of a struct.

Example:

user := &User{
    Name: "Ankit",
    Age:  24,
}

Pointers are especially useful when you want functions or methods to modify the original struct.

---

What is the difference between a struct and a map?

A struct has a predefined set of fields and is best for structured data.

A map uses dynamic keys and is better for key-value data where the keys may vary.

---

Conclusion

Structs are one of the most important features to understand when learning Go.

They allow you to combine multiple related values into a single custom data type.

The basic syntax is:

type User struct {
    Name string
    Age  int
}

Create a value:

user := User{
    Name: "Ankit",
    Age:  24,
}

Access fields:

fmt.Println(user.Name)

Update fields:

user.Age = 25

Pass structs to functions:

func printUser(user User) {
    fmt.Println(user.Name)
}

Use pointers when you need to modify the original:

func updateUser(user *User) {
    user.Age = 30
}

Once you understand structs, you can model users, products, orders, employees, API responses, database records, configurations, and many other types of structured data in Go applications.