Value receivers in Go - Step-by-Step Execution

Concept Flow - Value receivers

Define struct

↓

Define method with value receiver

↓

Create instance of struct

↓

Call method on instance

↓

Method receives a COPY of instance

↓

Modify copy inside method

↓

Original instance remains unchanged

↓

Method returns or prints result

Value receivers get a copy of the struct, so changes inside the method do not affect the original instance.

Execution Sample

Go

package main
import "fmt"
type Counter struct { count int }
func (c Counter) Increment() {
    c.count++
    fmt.Println("Inside method:", c.count)
}
func main() {
    c := Counter{count: 0}
    c.Increment()
    fmt.Println("After method call:", c.count)
}

This code shows a method with a value receiver that increments a count, but the original count stays the same.

Execution Table

Step	Variable	Value Before	Action	Value After	Output
1	c	Counter{count:0}	Call Increment method (value receiver)	Counter{count:0} (copy)
2	c.count (copy)	0	Increment count inside method	1	Inside method: 1
3	c (original)	Counter{count:0}	Method ends, copy discarded	Counter{count:0}
4	c.count (original)	0	Print count after method call	0	After method call: 0

💡 Method ends, copy of struct discarded, original struct unchanged

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
c (original)	Counter{count:0}	Counter{count:0}	Counter{count:0}	Counter{count:0}
c.count (copy inside method)	N/A	1	N/A	N/A

Key Moments - 2 Insights

Why does the original count not change after calling Increment?

Because the method uses a value receiver, it works on a copy of the struct, so changes inside the method do not affect the original variable (see execution_table step 3).

Is the 'c' inside the method the same as the 'c' in main?

No, inside the method 'c' is a copy of the original struct, so modifying it does not change the original (see variable_tracker showing separate values).

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what is the value of c.count inside the method after increment?

A 2

B 0

C 1

D Undefined

💡 Hint

Check the 'Value After' and 'Output' columns at step 2 in execution_table.

At which step does the original struct remain unchanged?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Value After' for 'c (original)' in execution_table step 3.

If the method used a pointer receiver instead, what would happen to c.count after the method call?

A It would become 1

B It would remain 0

C It would become 2

D It would cause an error

💡 Hint

Think about how pointer receivers allow methods to modify the original struct, unlike value receivers.

Concept Snapshot

Value receivers get a copy of the struct.
Methods with value receivers cannot change the original struct.
Changes inside the method affect only the copy.
Use value receivers for read-only methods.
Use pointer receivers to modify the original.

Full Transcript

In Go, methods can have value receivers, which means the method works on a copy of the struct. When you call a method with a value receiver, Go copies the struct and the method uses that copy. Any changes made inside the method affect only the copy, not the original struct. For example, if you have a Counter struct with a count field and a method Increment with a value receiver, calling Increment increases the count inside the copy, but the original count remains unchanged. This is shown in the execution table where the copy's count changes to 1 inside the method, but after the method ends, the original count is still 0. Beginners often get confused because they expect the original struct to change, but value receivers always work on copies. To modify the original struct, you need to use pointer receivers instead. This concept helps you decide when to use value or pointer receivers in your Go programs.

Practice

1. What does a value receiver method in Go do when called on a struct?

easy

A. It requires a pointer to the struct to work.

B. It modifies the original struct directly.

C. It works on a copy of the struct, leaving the original unchanged.

D. It only works with built-in types, not structs.

Solution

1. Step 1: Understand value receiver behavior

   Value receivers get a copy of the struct, so changes inside the method do not affect the original.

2. Step 2: Compare with pointer receivers

   Pointer receivers work on the original struct, but value receivers do not.

3. Final Answer:

   It works on a copy of the struct, leaving the original unchanged. -> Option C

4. Quick Check:

   Value receiver = copy, no original change [OK]

Hint: Value receivers copy data; original stays safe [OK]

Common Mistakes:

• Thinking value receivers modify the original struct
• Confusing value and pointer receivers
• Assuming value receivers require pointers

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

easy

A. func greet(p Person) {}

B. func (p Person) greet() {}

C. func (p *Person) greet() {}

D. func greet(*Person) {}

Solution

1. Step 1: Identify method receiver syntax

   Methods with receivers use the syntax: func (receiver Type) methodName() {}.

2. Step 2: Distinguish value vs pointer receiver

   Value receiver uses the type directly (e.g., Person), pointer receiver uses *Person.

3. Final Answer:

   func (p Person) greet() {} -> Option B

4. Quick Check:

   Value receiver syntax = func (p Type) method() [OK]

Hint: Value receiver uses type, pointer uses *type [OK]

Common Mistakes:

• Using pointer syntax for value receiver
• Defining method without receiver
• Confusing function parameter with method receiver

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 main() {
    c := Counter{count: 5}
    c.increment()
    fmt.Println(c.count)
}

medium

A. 5

B. 6

C. 0

D. Compilation error

Solution

1. Step 1: Analyze increment method with value receiver

   The increment method uses a value receiver, so it works on a copy of Counter, not the original.

2. Step 2: Check effect on original Counter

   Incrementing c.count inside the method changes only the copy; original c.count remains 5.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   Value receiver method does not change original value [OK]

Hint: Value receiver methods don't change original struct [OK]

Common Mistakes:

• Assuming increment changes original count
• Confusing value and pointer receivers
• Expecting output 6 instead of 5

4. Identify the problem in this Go code snippet and fix it:

type Point struct { x, y int }
func (p Point) move(dx, dy int) {
    p.x += dx
    p.y += dy
}
func main() {
    pt := Point{1, 2}
    pt.move(3, 4)
    fmt.Println(pt)
}

medium

A. Use global variables instead of struct fields

B. Return new Point from move method

C. No fix needed; code works as intended

D. Change method receiver to pointer: func (p *Point) move(dx, dy int)

Solution

1. Step 1: Understand why move method doesn't update original

   Method uses value receiver, so changes affect only a copy, not original Point.

2. Step 2: Fix by using pointer receiver

   Changing receiver to *Point allows method to modify original struct fields.

3. Final Answer:

   Change method receiver to pointer: func (p *Point) move(dx, dy int) -> Option D

4. Quick Check:

   Pointer receiver needed to modify original struct [OK]

Hint: Use pointer receiver to modify struct fields [OK]

Common Mistakes:

• Not using pointer receiver for modifying methods
• Trying to fix by returning new struct without assignment
• Ignoring that value receiver copies struct

5. You have a struct Book with a method Display() using a value receiver. You want to add a method UpdateTitle(newTitle string) that changes the title. Which is the best approach?

hard

A. Define UpdateTitle with a pointer receiver to modify the original Book.

B. Define UpdateTitle with a value receiver and assign the new title inside it.

C. Keep both methods with value receivers for consistency.

D. Make Display use a pointer receiver instead of value receiver.

Solution

1. Step 1: Understand method receiver choice for updating data

   To change the original struct, methods must use pointer receivers.

2. Step 2: Decide best practice for mixed methods

   It's fine to have Display use value receiver (read-only), and UpdateTitle use pointer receiver (modifies data).

3. Final Answer:

   Define UpdateTitle with a pointer receiver to modify the original Book. -> Option A

4. Quick Check:

   Modify method uses pointer receiver; read-only can use value [OK]

Hint: Use pointer receiver for methods that change data [OK]

Common Mistakes:

• Using value receiver for methods that modify struct
• Changing all methods to pointer receivers unnecessarily
• Confusing method consistency with receiver type