Structures in Golang

A structure or struct in Golang is a user-defined type that allows to group/combine items of possibly different types into a single type. Any real-world entity which has some set of properties/fields can be represented as a struct. This concept is generally compared with the classes in object-oriented programming. It can be termed as a lightweight class that does not support inheritance but supports composition. For Example, an address has a name, street, city, state, Pincode. It makes sense to group these three properties into a single structure address as shown below.

Declaring a structure:

 type Address struct {
      name string 
      street string
      city string
      state string
      Pincode int
}

In the above, the type keyword introduces a new type. It is followed by the name of the type (Address) and the keyword struct to illustrate that we’re defining a struct. The struct contains a list of various fields inside the curly braces. Each field has a name and a type. 

Note: We can also make them compact by combining the various fields of the same type as shown in the below example:

type Address struct {
    name, street, city, state string
    Pincode int
}

To Define a structure: The syntax for declaring a structure:

var a Address

The above code creates a variable of a type Address which is by default set to zero. For a struct, zero means all the fields are set to their corresponding zero value. So the fields name, street, city, state are set to “”, and Pincode is set to 0. You can also initialize a variable of a struct type using a struct literal as shown below:

var a = Address{"Akshay", "PremNagar", "Dehradun", "Uttarakhand", 252636}

Note:

• Always pass the field values in the same order in which they are declared in the struct. Also, you can’t initialize only a subset of fields with the above syntax.
• Go also supports the name: value syntax for initializing a struct (the order of fields is irrelevant when using this syntax). And this allows you to initialize only a subset of fields. All the uninitialized fields are set to their corresponding zero value. Example:

var a = Address{Name:”Akshay”, street:”PremNagar”, state:”Uttarakhand”, Pincode:252636} //city:””

Go

// Golang program to show how to
// declare and define the struct

package main

import "fmt"

// Defining a struct type
type Address struct {
    Name    string
    city    string
    Pincode int
}

func main() {

    // Declaring a variable of a `struct` type
    // All the struct fields are initialized
    // with their zero value
    var a Address
    fmt.Println(a)

    // Declaring and initializing a
    // struct using a struct literal
    a1 := Address{"Akshay", "Dehradun", 3623572}

    fmt.Println("Address1: ", a1)

    // Naming fields while
    // initializing a struct
    a2 := Address{Name: "Anikaa", city: "Ballia",
                                 Pincode: 277001}

    fmt.Println("Address2: ", a2)

    // Uninitialized fields are set to
    // their corresponding zero-value
    a3 := Address{Name: "Delhi"}
    fmt.Println("Address3: ", a3)
}

Output:

{  0}
Address1:  {Akshay Dehradun 3623572}
Address2:  {Anikaa Ballia 277001}
Address3:  {Delhi  0}

How to access fields of a struct?

To access individual fields of a struct you have to use dot (.) operator. 

Example:

Go

// Golang program to show how to
// access the fields of struct
package main

import "fmt"

// defining the struct
type Car struct {
    Name, Model, Color string
    WeightInKg         float64
}

// Main Function
func main() {
    c := Car{Name: "Ferrari", Model: "GTC4",
            Color: "Red", WeightInKg: 1920}

    // Accessing struct fields
    // using the dot operator
    fmt.Println("Car Name: ", c.Name)
    fmt.Println("Car Color: ", c.Color)

    // Assigning a new value
    // to a struct field
    c.Color = "Black"

    // Displaying the result
    fmt.Println("Car: ", c)
}

Output:

Car Name:  Ferrari
Car Color:  Red
Car:  {Ferrari GTC4 Black 1920}

Pointers to a struct

Pointers in Go programming language or Golang is a variable which is used to store the memory address of another variable. You can also create a pointer to a struct as shown in the below example: 

Go

// Golang program to illustrate
// the pointer to struct
package main

import "fmt"

// defining a structure
type Employee struct {
    firstName, lastName string
    age, salary int
}

func main() {

    // passing the address of struct variable
    // emp8 is a pointer to the Employee struct
    emp8 := &Employee{"Sam", "Anderson", 55, 6000}

    // (*emp8).firstName is the syntax to access
    // the firstName field of the emp8 struct
    fmt.Println("First Name:", (*emp8).firstName)
    fmt.Println("Age:", (*emp8).age)
}

Output:

First Name: Sam
Age: 55

The Golang gives us the option to use emp8.firstName instead of the explicit dereference (*emp8).firstName to access the firstName field. Example to show this is following: 

Go

// Golang program to illustrate
// the pointer to struct
package main

import "fmt"

// Defining a structure
type Employee struct {
    firstName, lastName string
    age, salary         int
}

// Main Function
func main() {

    // taking pointer to struct
    emp8 := &Employee{"Sam", "Anderson", 55, 6000}

    // emp8.firstName is used to access
    // the field firstName
    fmt.Println("First Name: ", emp8.firstName)
    fmt.Println("Age: ", emp8.age)
}

Output:

First Name:  Sam
Age:  55

In Go, a structure is a composite data type that groups together zero or more values of different types. Structures are defined using the type keyword, followed by the name of the new type, and the keyword struct. Here’s an example:

In this example, we define a new type Person that has three fields: Name of type string, Age of type int, and Address of type string. We can then create new instances of the Person type and set the values of its fields:

Go

func main() {
    person := Person{
        Name:    "John Doe",
        Age:     30,
        Address: "123 Main St",
    }
    fmt.Println(person)
}

1. Output:

{John Doe 30 123 Main St}

Advantages of using structures in Go:

1. Encapsulation: Structures allow you to encapsulate related data together, making it easier to manage and modify the data.
2. Code organization: Structures help to organize code in a logical way, which makes it easier to read and maintain.
3. Flexibility: Structures allow you to define custom types with their own behavior, making it easier to work with complex data.
4. Type safety: Structures provide type safety by allowing you to define the type of each field, which helps to prevent errors caused by assigning the wrong type of value.
5. Efficiency: Structures in Go are very efficient, both in terms of memory usage and performance.

Disadvantages of using structures in Go:

1. Complexity: Structures can make code more complex, especially if the structures have a large number of fields or methods.
2. Boilerplate code: When defining large structures with many fields, it can be time-consuming to write out all of the field names and types.
3. Inheritance: Go does not support inheritance, which can make it more difficult to work with large hierarchies of related data.
4. Immutability: Go structures are mutable by default, which can make it more difficult to enforce immutability in your code.
5. Overall, the advantages of using structures in Go typically outweigh the disadvantages, as they provide a powerful tool for managing and working with complex data. However, as with any programming technique, it’s important to use structures judiciously and be aware of their limitations.

Here are some important points about structures in Go:

1. Structures are composite data types that allow you to group together related data of different types.
2. In Go, structures are defined using the type keyword, followed by the name of the new type, and the keyword struct.
3. Structures can have fields that are of any type, including other structures.
4. Fields can be accessed using the dot . operator.
5. Structures in Go can also have methods associated with them.
6. Methods can be defined on structures using the receiver syntax.
7. Structures can be used to create custom types that encapsulate related data and behavior.
8. Go structures are mutable by default, but you can create immutable structures by using pointers or methods that return a new instance of the structure.
9. Structures in Go are very efficient in terms of both memory usage and performance.
10. Go does not support inheritance, but you can use composition to achieve similar results.

Overall, structures in Go are a powerful tool for managing and working with complex data. By grouping related data together and associating behavior with it, you can create custom types that are more expressive and easier to work with.