Go Struct

Introduction

Structs in Go are a way to group related data together. They allow you to create complex data types that aggregate multiple fields of different types. Structs are similar to classes in other programming languages but do not support inheritance. In this chapter, you will learn the basics of defining, initializing, and using structs in Go.

Defining a Struct

A struct is defined using the type keyword, followed by the name of the struct and the struct keyword. The fields of the struct are enclosed in curly braces {}.

Syntax:

type StructName struct {
    fieldName1 fieldType1
    fieldName2 fieldType2
    ...
}

Example

Example:

package main

import "fmt"

// Defining a struct
type Person struct {
    Name string
    Age  int
}

func main() {
    // Creating an instance of the struct
    var p Person
    p.Name = "Alice"
    p.Age = 30

    // Accessing fields
    fmt.Println("Name:", p.Name) // Output: Name: Alice
    fmt.Println("Age:", p.Age)   // Output: Age: 30
}

Initializing a Struct

There are several ways to initialize a struct in Go.

Using a Struct Literal

Example:

package main

import "fmt"

// Defining a struct
type Person struct {
    Name string
    Age  int
}

func main() {
    // Initializing a struct using a struct literal
    p := Person{Name: "Bob", Age: 25}
    fmt.Println(p) // Output: {Bob 25}
}

Using the new Function

The new function allocates memory for a new struct and returns a pointer to it.

Example:

package main

import "fmt"

// Defining a struct
type Person struct {
    Name string
    Age  int
}

func main() {
    // Initializing a struct using the new function
    p := new(Person)
    p.Name = "Charlie"
    p.Age = 40
    fmt.Println(*p) // Output: {Charlie 40}
}

Using Pointers to Structs

You can create pointers to structs and access their fields using the . operator.

Example:

package main

import "fmt"

// Defining a struct
type Person struct {
    Name string
    Age  int
}

func main() {
    // Creating a pointer to a struct
    p := &Person{Name: "Dave", Age: 35}
    fmt.Println(p)     // Output: &{Dave 35}
    fmt.Println(*p)    // Output: {Dave 35}
    fmt.Println(p.Name) // Output: Dave
    fmt.Println(p.Age)  // Output: 35
}

Anonymous Fields

Structs in Go can have anonymous fields, which are fields without names. These fields are identified by their type.

Example:

package main

import "fmt"

// Defining a struct with anonymous fields
type Person struct {
    string
    int
}

func main() {
    // Initializing a struct with anonymous fields
    p := Person{"Eve", 28}
    fmt.Println(p)      // Output: {Eve 28}
    fmt.Println(p.string) // Output: Eve
    fmt.Println(p.int)    // Output: 28
}

Nested Structs

Structs can be nested within other structs, allowing you to create more complex data structures.

Example:

package main

import "fmt"

// Defining nested structs
type Address struct {
    City    string
    ZipCode int
}

type Person struct {
    Name    string
    Age     int
    Address Address
}

func main() {
    // Initializing a struct with nested structs
    p := Person{
        Name: "Frank",
        Age:  45,
        Address: Address{
            City:    "New York",
            ZipCode: 10001,
        },
    }
    fmt.Println(p)
    // Output: {Frank 45 {New York 10001}}
}

Methods on Structs

You can define methods on structs, which are functions that have a receiver argument. The receiver can be a value or a pointer to the struct.

Example:

package main

import "fmt"

// Defining a struct
type Person struct {
    Name string
    Age  int
}

// Defining a method on the struct
func (p Person) Greet() {
    fmt.Printf("Hello, my name is %s and I am %d years old.\n", p.Name, p.Age)
}

func main() {
    p := Person{Name: "Grace", Age: 50}
    p.Greet()
    // Output: Hello, my name is Grace and I am 50 years old.
}

Conclusion

Structs in Go are a powerful way to group related data together. They allow you to create complex data types and provide a way to define methods on those types. By understanding how to define, initialize, and use structs, you can create more organized and maintainable Go programs. Structs are a fundamental building block in Go, making them essential to learn and master.