Forem: marson parulian

Go Method: Pointer Over Value Receiver Type

marson parulian — Thu, 11 Aug 2022 06:06:00 +0000

Avoid Using Value Receiver Type in Golang Structs Methods

About this article

This article assumes the readers already know basic knowledge of struct, methods, and goroutine in Go programming language.

The main purpose of this article is as reminder for myself about the use of value/pointer receiver type in struct methods (Go programming language).
I decided to write about this, even though this is a very simple thing,
after I spend more then 1 hour to debug an issue caused by the use of value receiver type in struct methods.

In an example below I will show the issue caused by the use of value receiver but without showing any warnings.

Receiver Types In Struct Methods

In Golang we define methods for a struct similar to methods in object-oriented programming language.
The difference with OO language is in Golang there are 2 types of of receiver : value and pointer receiver types.

Pointer receiver type will copy the pointer of the 'object/struct' in memory. This is the same with methods in OO programming language where any changes made in the methods will change the actual 'object/struct' in memory.
Example of pointer receiver type is as below :

// Define a structtype Book struct {
    Title string
}

    // A pointer receiver type method. 
// Marked with the asterisk (*) sign.
func(b *Book) ChangeTitle(title string) {
  b.Title = title
}

Value receiver type will copy the 'object/struct' data. Any changes made to the object/struct' in methods will not change the actual 'object/struct' in memory.
Example of value receiver type is below :

// Value receiver type. 
// Marked with no asterisk (*) sign, in the struct receiver. 
func (b Book) ChangeTitle(title string) {
    b.Title = title
}

In Golang we only use the value receiver if the method do not need to make any changes to the struct data.
However that is not true for all cases. In this article I will show an example where we need to use pointer receiver in a 'read-only' method.

Value Pointer Type

Example of `ineffective assignment` Warning

package main

import (
    "fmt"
)

type book struct {
    title string
}

// Change the title of a book
func (b book) changeTitle(title string) {
    b.title = title
}

type library struct {
    books []book
}

func (lib library) addABook(book book) {
    lib.books = append(lib.books, book)
}

func main() {
    lib := library{}

    fmt.Println(lib)

    b := book{title: "Three little pigs"}
    b.changeTitle("Blue Birds")
    lib.addABook(b)

    fmt.Println(lib)
}

The Go language server (vscode extension), gopls, will show ineffective-assignment warning to the assignment in changeTitle and addABook methods.
This is very helpful to prevent any bugs in case we forgot to use pointer receiver type.

Example in `goroutine` implementation

There is also other condition where pointer receiver is needed, but value receiver is used, yet no warnings are shown.
This situation arise with the use of goroutines, like in the code below :

import (
    "fmt"
    "time"
)

type book struct {
    title string
}

type library struct {
    books []book
}

func (lib *library) addABook(book book) {
    fmt.Printf("Add book '%s'\n", book.title)
    lib.books = append(lib.books, book)
}

// Method below is mimicking time consuming operation.
// Method below is a Value receiver type.
func (lib library) timeConsumingOperation() {
    // `Sleep` to mimick ` time-consuming operation.
    time.Sleep(5 * time.Millisecond)

    // Check the number of books
    fmt.Printf("Value receiver type. Found %d books.\n", len(lib.books))
}
func main() {
    lib := library{}

    // Goroutine mimicking a time consuming operation.
    go lib.timeConsumingOperation()

    // Add 2 books
    go lib.addABook(book{title: "Rain Rain Go Away"})
    go lib.addABook(book{title: "Rainbow After Rain"})

    // `Sleep` to make sure all goroutines are completed
    time.Sleep(2 * time.Second)

    fmt.Printf("Actual number of books : %d books.\n", len(lib.books))
}

Running code above will produce a false result.
The Library in the timeConsumingOperation will have the outdated version
(since the methods were run as goroutine).

Add book 'Rainbow After Rain'
Add book 'Rain Rain Go Away'
Value receiver type. Found 0 books.
Actual number of books : 2 books.

Pointer Receiver Type

The use of pointer receiver type in struct methods is mandatory if we want data integrity.
Of course there are smaller number of cases where we need to use value receiver type.
Modification of earlier example, with pointer receiver type on the timeConsumingOperation, can be seen below (added an asterisk(*)).

func (lib *library) timeConsumingOperation() {

Using pointer type in timeConsumingOperation will
points the lib to the same data in the memory, assuring data integrity.
Running the modified code will produce :

Add book 'Rainbow After Rain'
Add book 'Rain Rain Go Away'
Value receiver type. Found 2 books.
Actual number of books : 2 books.

Conclusion

Using pointer receiver in methods, instead of value receiver types, will assure data integrity.
I suggest that we should , maybe except in few cases, to always use pointer receiver types to avoid potential bugs
that are not catched by tools like the case above.

Here is a link of Code xample repository in Github.com.

Hope this article can be useful and thanks for reading

Begin Golang : "time"

marson parulian — Wed, 10 Aug 2022 03:31:00 +0000

This article is a part of Begin Go series: containing my experience learning Go language. Any feedback would be very appreciated.

Parsing time `string`

In order to complete exercise from exercism's go track, I stumbled on a problem when parsing time string.
I tried to parse 7/13/2020 20:32:00 but I keep getting time with empty value : 0001-01-01 00:00:00 +0000 UTC.

Custom `Layout`

In Go language, we format and parse time with the pattern-based Layout which has type string. You can read the article in gobyexample.com

This is the code I used to parse the string above :

date := "7/13/2020 20:32:00"
t, _ := time.Parse("01/02/2006 15:04:05", date)
fmt.Print(t)
// 0001-01-01 00:00:00 +0000 UTC

With or without leading zero

My mistake that I used leading zero to parse the date and month when I should not used the leading zeros. The parse was successful after I change my code to :

t, _ := time.Parse("1/02/2006 15:04:05", date)

The misuse of leading zero for date, month, etc could lead to potential bugs. So make sure to always consider whether we should use the leading zero or not in Layout to format / parse time.

Remembering The `Layout` Time Representation

Go has different time representation to format time compared to other languages. Other languages usually use time representation like HH or m to represent month or hour.

Go time representations are as below :

Representation	Representing
`1` or `01`	month
`2` or `02`	date
`15`	hour
`04`	minute
`05`	second
`2006`	year
`07:00`	time offset (time zone)

The question is should we have to lookup for those time representations everytime we use time ? Or maybe there is other way to remember those symbols ?

Looking at the table above, we can see a pattern that matches a well known time format with 1 exception. Code block below will show how I could remember the time representation :

// Well known time format
"Jan 02 2016 15:04:05+07:00"
// Move back the year, right before time offset / time zone.
"Jan 02 15:04:05 2016 +07:00"
// Changing to number presentation, 
// will show a pattern of an incrementing numbers
"01 02 03:04:05 2016 +07:00"

References

Time format and parsing on gobyexamples

Attribution

Go Gopher character is created by Renee French