Golang Defining Methods On Structs Complete Guide

1. Understanding Structs

First, you need to know what a struct in Go looks like. A struct is a data type that allows you to bundle multiple values into a single entity.

package main

import (
    "fmt"
)

// Define a struct named 'Person'
type Person struct {
    Name string
    Age  int
}

2. Defining Methods on Structs

A method is a function with a special receiver argument in front of the function name. This receiver allows the function to operate on an instance of the struct.

Let's define a method Introduce that operates on an instance of Person.

// Method to introduce the person
func (p Person) Introduce() {
    fmt.Printf("Hello, my name is %s and I am %d years old.\n", p.Name, p.Age)
}

3. Using Value Receiver Methods

When a method has a value receiver (func (p Person)), you can call this method on both value instances and pointer instances of the struct.

package main

import (
    "fmt"
)

// Define the struct
type Person struct {
    Name string
    Age  int
}

// Define a method using value receiver
func (p Person) Introduce() {
    fmt.Printf("Hello, my name is %s and I am %d years old.\n", p.Name, p.Age)
}

func main() {
    // Create an instance of Person
    person := Person{Name: "Alice", Age: 30}
    
    // Call the method on the instance
    person.Introduce()
    
    // Call the method on a pointer to an instance
    (&person).Introduce() // It's not necessary to use '&' here, Go automatically handles it
}

Output:

Hello, my name is Alice and I am 30 years old.
Hello, my name is Alice and I am 30 years old.

4. Using Pointer Receivers

Pointer receivers (func (p *Person)) are needed when you want to modify the struct instance. This means that the changes will reflect in the original struct.

package main

import (
    "fmt"
)

// Define the struct
type Person struct {
    Name string
    Age  int
}

// Define a method using pointer receiver
func (p *Person) CelebrateBirthday() {
    p.Age++
    fmt.Printf("Happy Birthday %s! You are now %d years old.\n", p.Name, p.Age)
}

func main() {
    // Create an instance of Person
    person := Person{Name: "Bob", Age: 25}
    
    // Call the method on the instance
    person.CelebrateBirthday()
    
    // Check if the person's age has changed
    fmt.Printf("%s is now %d years old.\n", person.Name, person.Age)
}

Output:

Happy Birthday Bob! You are now 26 years old.
Bob is now 26 years old.

5. Mixing Value and Pointer Receivers

You can have methods with both value and pointer receivers for the same struct. Here's how:

package main

import (
    "fmt"
)

// Define the struct
type Person struct {
    Name string
    Age  int
}

// Define a method using value receiver
func (p Person) Introduce() {
    fmt.Printf("Hello, my name is %s and I am %d years old.\n", p.Name, p.Age)
}

// Define a method using pointer receiver
func (p *Person) CelebrateBirthday() {
    p.Age++
    fmt.Printf("Happy Birthday %s! You are now %d years old.\n", p.Name, p.Age)
}

func main() {
    // Create an instance of Person
    person := Person{Name: "Charlie", Age: 29}
    
    // Call the method using value receiver
    person.Introduce()
    
    // Call the method using pointer receiver
    person.CelebrateBirthday()
    
    // The age change should reflect here
    person.Introduce()
}

Output:

Hello, my name is Charlie and I am 29 years old.
Happy Birthday Charlie! You are now 30 years old.
Hello, my name is Charlie and I am 30 years old.

6. Complete Example

Combining everything from the previous steps, let's look at a complete example:

package main

import (
    "fmt"
)

// Define the struct
type Person struct {
    Name string
    Age  int
}

// Define a method using value receiver
func (p Person) Introduce() {
    fmt.Printf("Hello, my name is %s and I am %d years old.\n", p.Name, p.Age)
}

// Define a method using pointer receiver
func (p *Person) CelebrateBirthday() {
    p.Age++
    fmt.Printf("Happy Birthday %s! You are now %d years old.\n", p.Name, p.Age)
}

func main() {
    // Create an instance of Person using a value
    person1 := Person{Name: "David", Age: 31}
    person1.Introduce()
    person1.CelebrateBirthday()
    person1.Introduce()

    // Create an instance of Person using a pointer
    person2 := &Person{Name: "Eve", Age: 28}
    person2.Introduce()
    person2.CelebrateBirthday()
    person2.Introduce()
}

Output: