golang struct tutorial

Are you ready to unlock the true power of Golang structs? In this comprehensive guide, we’ll explore the world of structs in Go, a feature that sets this language apart and makes it a favorite among developers. With a combination of simplicity and flexibility, structs will help you write clean, organized, and efficient code. Let’s dive in and start building your Golang mastery!

Introduction to structs in Go

A struct is a composite data type that groups together variables with different data types under a single name. It is similar to a class in other languages but without inheritance or other object-oriented features. Structs in Go are widely used for organizing and managing data, making them a fundamental part of the language.

In Go, structs serve as the primary means to create custom data types that can model real-world entities or concepts. They help in encapsulating related data together, promoting better code organization and maintainability. For example, you can define a Person struct to represent a person with their name and age, or a Rectangle struct to represent a geometric shape with its length and width.

The importance of structs in Go lies in their ability to provide a clean and efficient way to manage complex data. With structs, you can define custom types that accurately represent the problem domain, making the code more readable and easier to reason about. Furthermore, structs allow you to create methods that operate on the data, encapsulating behavior within the data type.

How to define and instantiate structs

Defining a struct is simple. First, use the type keyword, followed by the name of the struct, and then the struct keyword. Inside the curly braces, define the fields and their respective data types. For example:

type Person struct {
    Name string
    Age  int

To create an instance of the struct, use the following syntax:

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

You can also instantiate a struct using the new keyword, which returns a pointer to the struct:

personPtr := new(Person)
personPtr.Name = "Bob"
personPtr.Age = 25

Working with struct fields, methods, and embedding

Once you’ve defined a struct, you can access its fields and methods, and even embed other structs inside it.

Struct Fields

Once you’ve defined a struct, you can access its fields using the dot notation:

fmt.Println(person.Name) // Output: Alice

You can also modify the value of a field:

person.Age = 31


Methods are functions associated with a struct, allowing you to perform operations on the struct instance. To define a method, you need a receiver, which is a variable of the struct type that the method is associated with. The receiver is typically defined before the method name.

func (p Person) GetAge() int {
    return p.Age

You can also define methods with pointer receivers to modify the struct instance:

func (p *Person) SetAge(age int) {
    p.Age = age


Struct embedding allows you to include one struct within another, promoting code reuse and a form of composition. To embed a struct, simply declare a field with the type of the struct you want to embed:

type Address struct {
    Street string
    City   string
    State  string
    Zip    string

type Person struct {
    Name    string
    Age     int
    Address Address

You can access the embedded struct fields using dot notation:

person := Person{
    Name: "Alice",
    Age:  30,
    Address: Address{
        Street: "123 Main St",
        City:   "New York",
        State:  "NY",
        Zip:    "10001",

fmt.Println(person.Address.City) // Output: New York

Comparing, nesting, and exporting structs

Comparing structs

You can compare structs for equality using the == operator, as long as all the fields within the structs are comparable. The comparison will return true if all fields have equal values.

type Point struct {
    X, Y int

p1 := Point{1, 2}
p2 := Point{1, 2}
fmt.Println(p1 == p2) // Output: true

Nested structs

You can define structs within other structs, creating a hierarchy of data structures. This can be useful for organizing complex data models.

type Author struct {
    Name  string
    Email string

type Book struct {
    Title  string
    Author Author

book := Book{
    Title: "My Book",
    Author: Author{
        Name:  "John Doe",
        Email: "[email protected]",

Exporting and unexporting fields

In Go, field names that start with an uppercase letter are exported and can be accessed from outside the package. In contrast, field names that start with a lowercase letter are unexported and can only be accessed within the same package.

// Exported field
type Person struct {
    Name string // Can be accessed from outside the package

// Unexported field
type person struct {
    name string // Can only be accessed within the same package

Anonymous structs and their uses

Go also supports anonymous structs, which are structs without a name. These are useful when you need a one-off struct that doesn’t need to be reused. To create an anonymous struct, simply omit the name and use the struct keyword directly:

point := struct {
    X, Y int
}{1, 2}

You can access fields in an anonymous struct using dot notation, similar to named structs:

fmt.Println(point.X) // Output: 1

Struct tags and their applications

Struct tags are metadata that can be added to struct fields. They are used by external packages to provide additional information about the field, such as JSON field names or validation rules. Struct tags are defined as string literals within backticks after the field’s data type:

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`

To read struct tags, you’ll need to use the reflect package:

import "reflect"

func main() {
    t := reflect.TypeOf(Person{})
    field, _ := t.FieldByName("Name")
    fmt.Println(field.Tag) // Output: json:"name"

Struct tags are commonly used with packages such as encoding/json for JSON serialization and github.com/go-playground/validator for validation.

Passing structs to functions

You can pass structs as arguments to functions, either by value or by reference (using pointers). When passing by value, a copy of the struct is created, while passing by reference allows the function to modify the original struct.

func incrementAgeByValue(p Person) {

func incrementAgeByReference(p *Person) {

When using these functions, remember that passing by value will not modify the original struct, while passing by reference will:

person := Person{Name: "Alice", Age: 30}
fmt.Println(person.Age) // Output: 30

fmt.Println(person.Age) // Output: 31

Best practices for using structs in Go

Now that you understand the basics of structs in Go, it’s essential to follow best practices when using them in your code. Some of these include:

  1. Choose appropriate field names: Use descriptive and meaningful field names to make your code more readable and easier to understand. Export fields that need to be accessible from other packages, and keep fields unexported when their access should be restricted.
  2. Use methods wisely: Define methods to encapsulate behavior related to the struct. This makes your code more modular and easier to maintain. When needed, use pointer receivers to modify the struct’s fields.
  3. Leverage struct embedding: Use struct embedding to create reusable and composable data structures. This promotes code reuse and simplifies data modeling.
  4. Use struct tags: Utilize struct tags for metadata and to work with external packages. This allows you to leverage powerful functionality provided by packages like encoding/json and github.com/go-playground/validator.
  5. Be mindful of value vs. reference: When passing structs to functions, consider whether you want to create a copy (pass by value) or modify the original struct (pass by reference).

To further enhance your Go programming skills, consider reading these articles:


Congratulations! You’ve now ventured through the exciting world of Golang structs and are well-equipped to harness their power in your projects. By understanding how to define, instantiate, and work with structs, you’ll be able to create more organized and efficient code. As you continue your journey in Go programming, always remember to follow best practices and never stop exploring new features and techniques.

Keep pushing the boundaries of your Golang knowledge, and don’t hesitate to refer back to this guide or explore the additional resources provided.

Similar Posts

Leave a Reply

Your email address will not be published. Required fields are marked *