How to Create and Use Structs in Go

Table of Contents

  1. Overview
  2. Prerequisites
  3. Creating a Struct
  4. Initializing a Struct
  5. Accessing Struct Fields
  6. Modifying Struct Fields
  7. Struct Methods
  8. Conclusion

Overview

In Go (Golang), structs are a way to define custom complex data types that group together related data. They allow you to create your own composite data structures, similar to classes in object-oriented programming languages. This tutorial will guide you through the process of creating and using structs in Go. By the end of this tutorial, you will understand how to define and initialize structs, access and modify their fields, and use struct methods.

Prerequisites

To follow along with this tutorial, you should have:

  • Basic knowledge of the Go programming language
  • Go language compiler (version 1.16 or higher) installed on your machine
  • Text editor or integrated development environment (IDE) set up for Go development

Creating a Struct

To create a struct in Go, you use the type keyword followed by the name of the struct and the definition of its fields. Each field has a name and a type, separated by a space. For example, let’s create a struct called Person with name and age as fields:

type Person struct {
    name string
    age  int
}

In the above example, we defined a struct named Person with two fields: name of type string and age of type int.

Initializing a Struct

Before you can use a struct, you need to initialize it. In Go, you can initialize a struct using the following syntax:

person := Person{"John Doe", 30}

In the above example, we created a new Person struct and assigned it to the person variable. We provided the values for the name and age fields within curly braces {}.

Another way to initialize a struct is by specifying the field names:

person := Person{
    name: "John Doe",
    age:  30,
}

This syntax allows you to specify the field names and their corresponding values explicitly.

Accessing Struct Fields

To access the fields of a struct, you use the dot (.) operator followed by the field name. For example:

fmt.Println("Name:", person.name)
fmt.Println("Age:", person.age)

In the above example, we accessed the name and age fields of the person struct and printed their values.

Modifying Struct Fields

Struct fields can be modified by assigning new values to them. For example, let’s change the age field of our person struct:

person.age = 31

In the above example, we updated the age field of the person struct to 31.

Struct Methods

In Go, structs can have methods associated with them. A method is a function that operates on a specific struct type. To define a method for a struct, you use the func keyword followed by the name of the method, the receiver type (the struct the method belongs to), and the method’s parameters and return type.

func (p Person) sayHello() {
    fmt.Println("Hello, my name is", p.name)
}

In the above example, we defined a method named sayHello for the Person struct. The method takes no parameters and doesn’t return any value. It simply prints a message using the name field of the Person struct.

To call a struct method, you use the dot (.) operator followed by the method name:

person.sayHello()

In the above example, we called the sayHello method on the person struct.

Conclusion

In this tutorial, you learned how to create structs in Go, initialize them, access and modify their fields, and define and use struct methods. Structs are powerful data structures that allow you to organize related data and define behavior associated with that data. Go’s struct capabilities make it easy to create complex data types and build modular and reusable code.

Experiment with different struct definitions, initialization, and method declarations to explore the full potential of structs in Go. Happy coding!

Published:

Related Articles