Methods in Golang

Go methods are like functions but with a key difference: they have a receiver argument, which allows access to the receiver's properties. The receiver can be a struct or non-struct type, but both must be in the same package. Methods cannot be created for types defined in other packages, including built-in types like int or string; otherwise, the compiler will raise an error.

Example:

package main

import "fmt"

// Defining a struct
type person struct {
    name string
    age  int
}

// Defining a method with struct receiver
func (p person) display() {
    fmt.Println("Name:", p.name)
    fmt.Println("Age:", p.age)
}

func main() {
    // Creating an instance of the struct
    a := person{name: "a", age: 25}
    
    // Calling the method
    a.display()
}

Name: a
Age: 25

Syntax

func(receiver_name Type)  method_name(parameter_list) (return_type) { 
// Code
}

• Receiver: Can be accessed within the method.

Methods with Struct Type Receiver

In Go, you can define a method where the receiver is of a struct type. The receiver is accessible inside the method. The previous example showcases this approach with a struct type receiver.

Methods with Non-Struct Type Receiver

Go also allows methods with non-struct type receivers, as long as the receiver's type and method definition are present in the same package. You cannot define a method with a receiver type from another package (e.g., int, string).

Example:

Using the same example above, we can demonstrate a method with a non-struct receiver:

package main

import "fmt"

// Creating a custom type based on int
type number int

// Defining a method with a non-struct receiver
func (n number) square() number {
    return n * n
}

func main() {
    a := number(4)
    b := a.square()

    fmt.Println("Square of", a, "is", b)
}

Square of 4 is 16

Methods with Pointer Receiver

In Go, methods can have pointer receivers. This allows changes made in the method to reflect in the caller, which is not possible with value receivers.

Syntax:

func (p *Type) method_name(...Type) Type {    // Code}

Example:

package main

import "fmt"

// Defining a struct
type person struct {
    name string
}

// Method with pointer receiver to modify data
func (p *person) changeName(newName string) {
    p.name = newName
}

func main() {
    a := person{name: "a"}
    
    fmt.Println("Before:", a.name)
    
    // Calling the method to change the name
    a.changeName("b")
    
    fmt.Println("After:", a.name)
}

Before: a
After: b

Methods Accepting Both Pointer and Value

Unlike functions, Go methods can accept both value and pointer receivers. You can pass either a pointer or a value, and the method will handle it accordingly.

Example:

package main
import "fmt"

type person struct {
    name string
}
// Method with pointer receiver
func (p *person) updateName(newName string) {
    p.name = newName
}

// Method with value receiver
func (p person) showName() {
    fmt.Println("Name:", p.name)
}

func main() {
    a := person{name: "a"}
    
    // Calling pointer method with value
    a.updateName("b")
    fmt.Println("After pointer method:", a.name)
    
    // Calling value method with pointer
    (&a).showName()
}

After pointer method: b
Name: b

Difference Between Method and Function