Tour of go, function vs method

Generally speaking, there are two way to manipulate a typed variable

• function
• method

  type vertex struct {
      a int
      b int
  }
  

1. function with value parameter

   func f(v vertex) int {
       return v.a;
   }
   

   a copy of v is passed to function, and only a value is allowed when calling the function

2. function with pointer parameter

   func f(v *vertex) int {
       return v.a
   }
   

   pointer (reference) is passed to function
   only pointer is allowed when calling this function

   v := vertex{3, 4}
   f(&v) // OK
   f(v)  // compile error
   

   this is easy to understand if you know about C, but things get bit tricky dealing with methods

A method is a kind of special function bind to a specific type, with the data type called receiver. Just treat that receiver as a special parameter. So you can call this method by writing receiver.method(...parameters), common in many Object-Oriented languages

5. method with value receiver

   Syntax:

   func (v vertex) f(s int) {
       v.a = v.a * s
   }
   

   a copy of v is passed to method
   both value and pointer is allowed when calling the method,
   and nothing in origin data will change

   Example:

   v := vertex{1,2}
   v.f(2) // OK
   fmt.Println(v) // {1 2}
   p := &v
   p.f(2) // OK, equal to "(*p).f()"
   fmt.Println(p) {1 2}
   

6. method with pointer receiver
   Syntax:

   func (v *vertex) f(s int) {
       v.a = v.a * s
   }
   

   pointer of v is passed to method
   both value and pointer is allowed when calling this method,
   and both case may change the content of the original data

   Example:

   v := vertex{1,2}
   v.f(2) // OK equal to "(&v).f(2)
   fmt.Println(v) // {2 4}
   p := &v
   p.f(2) // OK
   fmt.Println(p) {4 8}
   

Another Note about interface

if a type implement an interface, calling the implemented method is not flexible any more, only the type (pointer receiver or value receiver) is allowed when calling.