Methods in Golang

• on 9 Aug 2023
• By psid
• Golang

Methods in Golang

In Go, a method is a function that is associated with a specific type, known as its receiver type. Methods are a way to define behaviors for custom types, and they enable you to attach functions to your own defined data types.

Here are some key points about methods in Go:

• A method is declared with a receiver type before the method name. The receiver type can be any named type or a pointer to a named type.
• Methods can only be defined for types declared in the same package as the method. However, you can define methods for built-in types via type aliasing.
• Methods can have value receivers (non-pointer) or pointer receivers. Choosing between them depends on whether you want to modify the original value or not.
• Value receivers receive a copy of the value, while pointer receivers receive a reference to the value, allowing modification of the original value.
• Methods with pointer receivers are more common when you want to modify the value, as they avoid copying the entire value.

Example of a method in Go:

package main

import (
	"fmt"
)

type Rectangle struct {
	Width  float64
	Height float64
}

func (r Rectangle) Area() float64 {
	return r.Width * r.Height
}

func (r *Rectangle) Scale(factor float64) {
	r.Width *= factor
	r.Height *= factor
}

func main() {
	rect := Rectangle{Width: 5, Height: 3}
	fmt.Println("Area:", rect.Area()) // Calling the method
	rect.Scale(2)
	fmt.Println("Scaled Area:", rect.Area())
}

Output :

Area: 15
Scaled Area: 30

In this example, we define a Rectangle struct type. We then define two methods associated with the Rectangle type:

• The Area method has a value receiver (r Rectangle) and calculates the area of the rectangle.
• The Scale method has a pointer receiver (r *Rectangle) and scales the dimensions of the rectangle by a given factor.

In the main function, we create a Rectangle instance, call its Area method to calculate the area, and then use the Scale method to modify its dimensions.

Methods are a powerful way to add functionality to your custom types and encapsulate behaviors within them. They make your code more organized and readable by keeping related operations close to the data they operate on.

Method with struct type receiver

Certainly! Here’s a more detailed example that demonstrates methods with a struct type receiver:

package main

import "fmt"

type Circle struct {
	Radius float64
}

// Method with a value receiver
func (c Circle) Area() float64 {
	return 3.14 * c.Radius * c.Radius
}

// Method with a pointer receiver
func (c *Circle) Scale(factor float64) {
	c.Radius *= factor
}

func main() {
	// Creating a Circle instance
	circle := Circle{Radius: 5}

	// Calling the Area method
	area := circle.Area()
	fmt.Printf("Area of the circle: %.2f\n", area)

	// Calling the Scale method
	circle.Scale(2)
	fmt.Printf("Scaled radius: %.2f\n", circle.Radius)
}

Output:

Area of the circle: 78.50
Scaled radius: 10.00

In this example, we have a Circle struct type with a single field Radius. We define two methods associated with the Circle type:

1. The Area method has a value receiver (c Circle) and calculates the area of the circle using the formula πr².
2. The Scale method has a pointer receiver (c *Circle) and scales the radius of the circle by a given factor.

In the main function, we create a Circle instance with an initial radius of 5. We call its Area method to calculate the area and print the result. Then, we call the Scale method to double the radius of the circle and print the scaled radius.

Methods with struct type receivers allow you to work directly with the values of the struct or modify the struct’s fields through a pointer receiver.

Method with Non-Struct Type Receiver

Methods in Go can also be defined for non-struct types. Here’s an example using a custom non-struct type, an integer, to demonstrate methods:

package main

import (
	"fmt"
	"math"
)

type MyInt int

// Method with a value receiver
func (num MyInt) IsEven() bool {
	return num%2 == 0
}

// Method with a pointer receiver
func (num *MyInt) Double() {
	*num *= 2
}

func main() {
	num := MyInt(5)

	// Calling the IsEven method
	fmt.Println("Is the number even?", num.IsEven())

	// Calling the Double method
	num.Double()
	fmt.Println("Doubled number:", num)
}

Output :

Is the number even? false
Doubled number: 10

In this example, we define a custom type MyInt based on the built-in int type. We then define two methods associated with the MyInt type:

1. The IsEven method has a value receiver (num MyInt) and checks whether the number is even by performing a modulo operation.
2. The Double method has a pointer receiver (num *MyInt) and doubles the value of the number using a pointer.

In the main function, we create a MyInt instance with the value 5. We call its IsEven method to check if it’s even and print the result. Then, we call the Double method to double the value and print the modified number.

Methods can enhance the functionality of any custom type, including non-struct types, by associating behaviors directly with those types.

Methods with Pointer Receiver

Here’s an example that focuses specifically on methods with pointer receivers:

package main

import (
	"fmt"
)

type Rectangle struct {
	Width  float64
	Height float64
}

// Method with a pointer receiver
func (r *Rectangle) SetDimensions(width, height float64) {
	r.Width = width
	r.Height = height
}

// Method with a pointer receiver
func (r *Rectangle) Area() float64 {
	return r.Width * r.Height
}

func main() {
	rect := &Rectangle{Width: 5, Height: 3}

	// Calling the SetDimensions method
	rect.SetDimensions(8, 6)
	fmt.Printf("Dimensions after SetDimensions: %.2f x %.2f\n", rect.Width, rect.Height)

	// Calling the Area method
	area := rect.Area()
	fmt.Printf("Area of the rectangle: %.2f\n", area)
}

Output :

Dimensions after SetDimensions: 8.00 x 6.00
Area of the rectangle: 48.00

In this example, we define a Rectangle struct type with Width and Height fields. We then define two methods associated with the Rectangle type, both using pointer receivers:

1. The SetDimensions method takes new width and height values and updates the fields of the Rectangle. Since it uses a pointer receiver, the changes are reflected in the original Rectangle.
2. The Area method calculates and returns the area of the rectangle using the Width and Height fields. This method also uses a pointer receiver to access the fields.

In the main function, we create a pointer to a Rectangle instance using &Rectangle{Width: 5, Height: 3}. We then call the SetDimensions method to change the dimensions and print the updated values. Finally, we call the Area method to calculate and print the area of the modified rectangle.

Using pointer receivers in methods allows you to modify the original values of the receiver type directly, making them particularly useful for methods that change the state of the receiver.

Method Can Accept both Pointer and Value

In Go, a method can be defined to accept either a pointer receiver or a value receiver. This flexibility allows you to work with both the value itself and a reference to the value, depending on your use case. By having methods that accept both types of receivers, you can choose the appropriate approach based on whether you want to modify the original value or not.

Here’s an example that demonstrates a method that accepts both pointer and value receivers:

package main

import (
	"fmt"
)

type Rectangle struct {
	Width  float64
	Height float64
}

// Method with both value and pointer receivers
func (r Rectangle) AreaValueReceiver() float64 {
	return r.Width * r.Height
}

func (r *Rectangle) AreaPointerReceiver() float64 {
	return r.Width * r.Height
}

func main() {
	rect := Rectangle{Width: 5, Height: 3}

	// Calling the method with a value receiver
	areaValue := rect.AreaValueReceiver()
	fmt.Printf("Area (Value Receiver): %.2f\n", areaValue)

	// Calling the method with a pointer receiver
	areaPointer := rect.AreaPointerReceiver()
	fmt.Printf("Area (Pointer Receiver): %.2f\n", areaPointer)

	// Calling the method with a pointer to the rectangle
	areaPointerDirect := (&rect).AreaPointerReceiver()
	fmt.Printf("Area (Pointer Receiver, Direct): %.2f\n", areaPointerDirect)
}

Output :

Area (Value Receiver): 15.00
Area (Pointer Receiver): 15.00
Area (Pointer Receiver, Direct): 15.00

In this example, we define a Rectangle struct type with Width and Height fields. We then define two methods associated with the Rectangle type:

1. The AreaValueReceiver method has a value receiver (r Rectangle) and calculates the area of the rectangle using the fields.
2. The AreaPointerReceiver method has a pointer receiver (r *Rectangle) and also calculates the area of the rectangle using the fields.

In the main function, we create a Rectangle instance and call both methods on it. We demonstrate that you can call the AreaPointerReceiver method using the original value, or by obtaining a pointer to the rectangle and calling the method on the pointer directly.

By providing both types of receivers for a method, you give yourself the flexibility to choose the right approach for your specific use case, whether it involves modifying the original value or not.

Difference Between Method and Function

In Go, both methods and functions are used to define blocks of code that can be executed. However, they have some key differences in terms of their purpose, usage, and syntax:

1. Receiver:

• Function: Functions are standalone blocks of code that are not associated with any specific type. They take arguments and can return values, but they don’t operate on any particular data structure.
• Method: Methods are functions that are associated with a specific type (receiver). They can access and modify the data fields of that type. Methods are essentially functions that are “bound” to a type, allowing you to define behaviors that are specific to that type.

2. Syntax:

• Function: Functions are defined using the func keyword followed by the function name, parameter list, return type (if any), and the function body.
• Method: Methods are defined in a similar way to functions, but they include a receiver parameter before the method name. The receiver specifies the type the method is associated with.

3. Usage:

• Function: Functions are used for general-purpose code that doesn’t need to be tied to a specific data structure. They can be called independently from any type.
• Method: Methods are used to define behavior that is directly related to the data and operations of a specific type. They are called using an instance of the type they are associated with.

4. Example:

// Function
func add(a, b int) int {
    return a + b
}

// Method
type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

5. Calling:

• Function: Functions are called directly by their name followed by parentheses, passing the required arguments.
• Method: Methods are called using an instance of the type they are associated with, followed by a dot and the method name, like instance.Method().

6. Scope:

• Function: Functions are defined globally or within a package and can be accessed from anywhere within the package.
• Method: Methods are defined within the scope of the type they are associated with and can only be called on instances of that type.

In summary, functions are standalone blocks of code, while methods are functions associated with specific types that can access and manipulate data fields of those types. Methods provide a way to define behaviors that are closely tied to the data they operate on, making code more organized and expressive.