Go struct

A struct is used to store variables of different data types. For example,

Suppose we want to store the name and age of a person. We can create two variables: name and age and store value.

However, suppose we want to store the same information of multiple people.

In this case, creating variables for a person might be a tedious task. We can create a struct that stores the name and age to overcome this.

And, we can use this same struct for every person.

Declare Go Struct

The syntax to declare a struct in Go is:

 type StructureName struct { // structure definition }

Here,

1. struct - keyword used to define a structure
2. StructName - the name of the structure

Let's see an example,

 type Person struct { name string age int }

Here, we have declared a struct named Person. Inside the curly braces {}, the struct contains two variables name and age.

Struct instances

A struct definition is just a blueprint. To use a struct, we need to create an instance of it. For example,

 type Person struct { name string age int } 
// create an instance of struct var person1 Person

Here, we have created an instance person1 followed by the name of the struct Person.

Now, we can use the person1 instance to access and define the struct properties.

 // define the value of name and age person1 = Person("John", 25)

We can also directly define a struct while creating an instance of the struct. For example,

 person1 := Person("John", 25)

Here, John will be assigned to the name variable and 25 will be assigned to the age variable of the Person struct.

Example: Golang struct

 package main import "fmt" func main() { // declare a struct type Person struct { name string age int } 
 // assign value to struct while creating an instance person1 := Person{ "John", 25}
 fmt.Println(person1) // define an instance var person2 Person // assign value to struct variables 
 person2 = Person { name: "Sara", age: 29, }
 fmt.Println(person2) }

Output

 {John 25} {Sara 29}

Access a struct in Golang

We can access individual elements of a struct using the struct instances. For example,

 // Program to access the individual elements of struct package main import "fmt" func main() { // declare a struct type Rectangle struct { length int breadth int } // declare instance rect1 and defining the struct rect := Rectangle{22, 12} 
 // access the length of the struct fmt.Println("Length:", rect.length) // access the breadth of the struct fmt.Println("Breadth:", rect.breadth)
 area := rect.length * rect.breadth fmt.Println("Area:", area) }

Output

 Length: 22 Breadth: 12 Area: 264

Here, we have used the . (dot) symbol to access the property of a struct.

• rect.length - access the value of the length variable from the struct
• rect.breadth - access the value of the breadth variable from the struct

Function inside a Struct in Go

Go also allows us to create a function inside a struct. It treats function as a field of struct. For example,

 // Program to use function as a field of struct package main import "fmt" 
// initialize the function Rectangle type Rectangle func(int, int) int
 // create structure type rectanglePara struct { length int breadth int color string 
 // function as a field of struct rect Rectangle
 } func main() { // assign values to struct variables result := rectanglePara{ length: 10, breadth: 20, color: "Red", 
 rect: func(length int, breadth int) int { return length * breadth },
 } fmt.Println("Color of Rectangle: ", result.color) 
 fmt.Println("Area of Rectangle: ", result.rect(result.length, result.breadth))
 }

Output

 Color of Rectangle: Red Area of Rectangle: 200

In the above example, we have defined a function Rectangle as a field of struct rectanglePara and used the function to find the area of a rectangle.