Method call behavior in Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a method in Go?

A method in Go is a function with a special receiver argument. The receiver appears in its own argument list between the func keyword and the method name. Methods allow you to define behavior on types.

intermediate

What is the difference between a value receiver and a pointer receiver in Go methods?

A value receiver gets a copy of the value, so changes inside the method do not affect the original. A pointer receiver gets the address, so changes inside the method can modify the original value.

intermediate

How does Go decide which method to call when both pointer and value receivers exist?

Go automatically takes the address (&) of addressable values for pointer receiver methods and dereferences (*) pointers for value receiver methods, selecting the matching method based on the receiver expression type after conversion.

intermediate

What happens if you call a method with a pointer receiver on a value variable?

Go automatically takes the address of the value variable to call the pointer receiver method, so the call works as if you passed a pointer.

intermediate

Why might you choose a pointer receiver over a value receiver for a method?

You choose a pointer receiver to avoid copying large structs, to modify the original value, or to ensure consistency if some methods require pointers.

In Go, which receiver type allows a method to modify the original struct?

A Pointer receiver

B Value receiver

C Interface receiver

D Constant receiver

Pointer receivers get the address of the struct, so methods can modify the original value.

What happens if you call a value receiver method on a pointer variable in Go?

A It causes a compile error

B The method is ignored

C Go automatically dereferences the pointer

D You must manually dereference the pointer

Go automatically dereferences pointers when calling value receiver methods.

Which of these is true about method calls in Go?

A Methods with value receivers require explicit pointer dereferencing

B Methods with pointer receivers can be called on values without pointers

C Methods with value receivers can only be called on values

D Methods with pointer receivers can only be called on pointers

Go allows calling methods with pointer receivers on values by automatically taking the address.

Why might Go automatically take the address of a value when calling a method?

A To optimize memory usage

B To convert values to interfaces

C To prevent method calls on values

D To allow calling pointer receiver methods on values

Go helps by automatically taking the address so pointer receiver methods can be called on values.

Which receiver type copies the struct when calling a method?

A Value receiver

B Pointer receiver

C Interface receiver

D Reference receiver

Value receivers get a copy of the struct, so the original is not changed.

Explain how Go handles method calls differently for pointer receivers versus value receivers.

Think about how Go treats the receiver when calling the method.

Describe when and why you would use a pointer receiver for a method in Go.

Consider performance and data modification needs.

Practice

1. In Go, what happens when you call a method with a value receiver on a variable?

easy

A. The method can only read but not access the variable's fields.

B. The method works on a copy of the variable, so original data is not changed.

C. The method call causes a compile-time error.

D. The method directly modifies the original variable.

Solution

1. Step 1: Understand value receiver behavior

   Methods with value receivers get a copy of the variable, not the original.

2. Step 2: Effect on original variable

   Since the method works on a copy, changes inside the method do not affect the original variable.

3. Final Answer:

   The method works on a copy of the variable, so original data is not changed. -> Option B

4. Quick Check:

   Value receiver = copy, no original change [OK]

Hint: Value receivers work on copies, so original stays unchanged [OK]

Common Mistakes:

• Thinking value receivers modify original data
• Confusing pointer and value receivers
• Assuming method call causes error

2. Which of the following is the correct syntax to define a method with a pointer receiver in Go?

easy

A. func (p *Person) UpdateName(newName string) {}

B. func (p Person*) UpdateName(newName string) {}

C. func (p Person) *UpdateName(newName string) {}

D. func *Person (p) UpdateName(newName string) {}

Solution

1. Step 1: Recall pointer receiver syntax

   Pointer receivers are declared as (variable *Type) before method name.

2. Step 2: Match correct syntax

   func (p *Person) UpdateName(newName string) {} matches the correct syntax: func (p *Person) MethodName(params) {}.

3. Final Answer:

   func (p *Person) UpdateName(newName string) {} -> Option A

4. Quick Check:

   Pointer receiver syntax = (p *Type) [OK]

Hint: Pointer receiver syntax: (var *Type) before method name [OK]

Common Mistakes:

• Placing * after type name incorrectly
• Using * before method name
• Confusing pointer receiver with pointer return type

3. What will be the output of this Go program?

package main
import "fmt"
type Counter struct { count int }
func (c Counter) Increment() { c.count++ }
func (c *Counter) IncrementPtr() { c.count++ }
func main() {
  c := Counter{count: 5}
  c.Increment()
  fmt.Println(c.count)
  c.IncrementPtr()
  fmt.Println(c.count)
}

medium

A. 6\n7

B. 5\n5

C. 6\n6

D. 5\n6

Solution

1. Step 1: Analyze Increment method call

   Increment has a value receiver, so c.count++ modifies a copy, original c.count remains 5.

2. Step 2: Analyze IncrementPtr method call

   IncrementPtr has a pointer receiver, so c.count++ modifies original c.count, changing it from 5 to 6.

3. Final Answer:

   5\n6 -> Option D

4. Quick Check:

   Value receiver no change, pointer receiver changes original [OK]

Hint: Value receiver copies; pointer receiver modifies original [OK]

Common Mistakes:

• Assuming value receiver changes original
• Confusing method call effects
• Ignoring pointer receiver behavior

4. Identify the error in this Go code snippet:

type Item struct { value int }
func (i Item) SetValue(v int) { i.value = v }
func main() {
  item := Item{value: 10}
  item.SetValue(20)
  fmt.Println(item.value)
}

medium

A. SetValue method uses a value receiver, so item.value is not updated.

B. Missing pointer receiver causes compile error.

C. fmt package is not imported, causing error.

D. SetValue method should return the new value.

Solution

1. Step 1: Check method receiver type

   SetValue uses a value receiver, so it works on a copy of item.

2. Step 2: Effect on original item

   Changes inside SetValue do not affect original item.value, so it remains 10.

3. Final Answer:

   SetValue method uses a value receiver, so item.value is not updated. -> Option A

4. Quick Check:

   Value receiver means no original update [OK]

Hint: Value receiver methods can't update original struct fields [OK]

Common Mistakes:

• Assuming pointer receiver is mandatory for compilation
• Thinking method return needed to update value
• Ignoring import fmt requirement (not shown here)

5. Given this Go code, what will be the output?

package main
import "fmt"
type Number struct { n int }
func (num Number) Double() Number { num.n *= 2; return num }
func (num *Number) Triple() { num.n *= 3 }
func main() {
  x := Number{n: 2}
  y := x.Double()
  y.Triple()
  fmt.Println(x.n, y.n)
}

hard

A. 4 6

B. 2 6

C. 2 12

D. 4 12

Solution

1. Step 1: Call x.Double()

   Double has a value receiver, so it works on a copy of x, doubles n from 2 to 4, and returns it as y.

2. Step 2: Call y.Triple()

   Triple has a pointer receiver, so it modifies y.n in place, tripling 4 to 12.

3. Step 3: Print values

   x.n remains 2 (unchanged), y.n is 12 after doubling then tripling.

4. Final Answer:

   2 12 -> Option C

5. Quick Check:

   Value receiver returns copy doubled, pointer receiver modifies copy [OK]

Hint: Value receiver returns copy; pointer receiver modifies that copy [OK]

Common Mistakes:

• Assuming x.n changes after Double()
• Confusing which variable is modified by Triple()
• Ignoring return value from Double()