Go Structs and Methods: An Introduction

Lesson Overview

Hello, there! Today, we’ll dive into Go's core data type: structs . Structs in Go, along with struct methods, serve a role similar to classes in object-oriented programming. We'll explore structs, how they encapsulate data, and how we can manipulate this data using methods.

Go Structs Refresher

To fully grasp Go's structs, think of them as blueprints for creating complex data types by grouping different pieces of related information. Unlike arrays or slices, which hold data of the same type, structs allow you to mix various data types. This powerful feature is why they're akin to custom records or tailored objects, making them very versatile in developing sophisticated programs. In addition to organizing your data, structs are instrumental in modularizing your code and breaking down complex programs into manageable pieces. This enhances code reusability and readability, providing a clear way to model real-life entities—just like how a GameCharacter may have fields for attributes like health and strength.

Defining Go Structs

In Go, to define a struct, use the type keyword followed by the struct name and its fields. For instance, considering the GameCharacter example: Go package main import "fmt" // GameCharacter struct definition type GameCharacter struct {name string health int strength int} package main import "fmt" // GameCharacter struct definition type GameCharacter struct {name string health int strength int}

Struct Fields

Fields in Go structs hold data related to each struct instance, like the name, health, and strength in the GameCharacter struct. Initialize fields by passing values as a composite literal or explicitly setting them after creation. Go package main import "fmt" // GameCharacter struct with fields type GameCharacter struct {name string health int strength int} func main() {// Initialize fields using composite literal character := GameCharacter{name: "Hero", health: 100, strength: 20} fmt.Println(character.name) // prints: Hero fmt.Println(character.health) // prints: 100 fmt.Println(character.strength) // prints: 20 // Update field values character.health = 90 fmt.Println(character.health) // prints: 90} package main import "fmt" // GameCharacter struct with fields type GameCharacter struct {name string health int strength int} func main() {// Initialize fields using composite literal character := GameCharacter{name: "Hero", health: 100, strength: 20} fmt.Println(character.name) // prints: Hero fmt.Println(character.health) // prints: 100 fmt.Println(character.strength) // prints: 20 // Update field values character.health = 90 fmt.Println(character.health) // prints: 90} Accessing struct fields involves the dot (.) operator, and initialization occurs using composite literals or individual assignments.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Understanding Methods: Receiver Functions

Differently from other OOP languages, in Go methods are simply functions with a receiver argument. Receiver functions in Go feature the special receiver parameter, which specifies the struct type a function is associated with. This receiver must be defined between the func keyword and the method name. It's analogous to the self parameter in Python or this in Java/C++; however, differently from such languages the receiver comes in two flavors:

Value Receiver (g GameCharacter): This creates a copy of the data, not modifying the original.
Pointer Receiver (g *GameCharacter): Allows direct modification of the original struct instance and passes memory addresses, making it more memory efficient.

package main

import "fmt"

// GameCharacter struct definition
type GameCharacter struct {
    name     string
    health   int
    strength int
}

// The attack method allows one character to reduce another's health
func (g *GameCharacter) attack(other *GameCharacter) {
    other.health -= g.strength
}

func main() {
    character1 := GameCharacter{name: "Hero", health: 100, strength: 20}
    character2 := GameCharacter{name: "Villain", health: 80, strength: 15}

    fmt.Println(character2.health) // prints: 80
    character1.attack(&character2)  // Hero attacks Villain
    fmt.Println(character2.health) // prints: 60
}

package main

import "fmt"

// GameCharacter struct definition
type GameCharacter struct {
    name     string
    health   int
    strength int
}

// The attack method allows one character to reduce another's health
func (g *GameCharacter) attack(other *GameCharacter) {
    other.health -= g.strength
}

func main() {
    character1 := GameCharacter{name: "Hero", health: 100, strength: 20}
    character2 := GameCharacter{name: "Villain", health: 80, strength: 15}

    fmt.Println(character2.health) // prints: 80
    character1.attack(&character2)  // Hero attacks Villain
    fmt.Println(character2.health) // prints: 60
}

In this example, we associate a method called attack to the GameCharacter struct, providing it with with the ability to attack another character. It utilizes a pointer receiver, allowing us to modify the original other character's health field by reducing it based on the attacking character's strength. By using a pointer receiver (g *GameCharacter), we directly manipulate the memory of the other instance, ensuring the changes are reflected externally.

Practical Example: Handling a Bank Account

Now, let's implement a BankAccount struct to demonstrate modeling a real-world entity, showcasing attributes like the account holder's name and balance, and methods for depositing and withdrawing funds.

package main

import (
    "fmt"
)

// BankAccount struct with fields
type BankAccount struct {
    holderName string
    balance    float64
}

// Method to deposit money into the account
func (b *BankAccount) deposit(amount float64) {
    if amount > 0 {
        b.balance += amount
        fmt.Printf("%.2f deposited. New balance: %.2f\n", amount, b.balance)
    } else {
        fmt.Println("Deposit amount must be positive.")
    }
}

// Method to withdraw money from the account
func (b *BankAccount) withdraw(amount float64) {
    if amount > 0 && amount <= b.balance {
        b.balance -= amount
        fmt.Printf("%.2f withdrawn. Remaining balance: %.2f\n", amount, b.balance)
    } else {
        fmt.Println("Insufficient balance for the withdrawal or amount is not positive.")
    }
}

func main() {
    account := BankAccount{holderName: "Alex", balance: 1000}

    // Perform some transactions
    account.deposit(500)
    account.withdraw(200)
    fmt.Printf("Final balance in %s's account: %.2f\n", account.holderName, account.balance)
}

package main

import (
    "fmt"
)

// BankAccount struct with fields
type BankAccount struct {
    holderName string
    balance    float64
}

// Method to deposit money into the account
func (b *BankAccount) deposit(amount float64) {
    if amount > 0 {
        b.balance += amount
        fmt.Printf("%.2f deposited. New balance: %.2f\n", amount, b.balance)
    } else {
        fmt.Println("Deposit amount must be positive.")
    }
}

// Method to withdraw money from the account
func (b *BankAccount) withdraw(amount float64) {
    if amount > 0 && amount <= b.balance {
        b.balance -= amount
        fmt.Printf("%.2f withdrawn. Remaining balance: %.2f\n", amount, b.balance)
    } else {
        fmt.Println("Insufficient balance for the withdrawal or amount is not positive.")
    }
}

func main() {
    account := BankAccount{holderName: "Alex", balance: 1000}

    // Perform some transactions
    account.deposit(500)
    account.withdraw(200)
    fmt.Printf("Final balance in %s's account: %.2f\n", account.holderName, account.balance)
}

In the above code snippet, the BankAccount struct effectively models a real-world bank account with fields like holderName and balance. The provided method deposit accepts a positive amount and updates the balance accordingly. Similarly, the withdraw method deducts a valid amount from the balance, demonstrating pointer receivers in action for modifying the struct's internal state. This example illustrates encapsulation of behaviour within the struct by combining data representation with methods for operations relevant to the entity being modeled.