Why methods are used in Go - See It in Action

Why methods are used

📖 Scenario: Imagine you have a simple program that keeps track of a book's details. You want to organize the code so that actions related to the book, like showing its title or updating its page count, are grouped together. This makes the program easier to understand and use.

🎯 Goal: You will create a Go program that defines a Book type and uses methods to show the book's title and update its page count. This will help you see why methods are useful to group actions with the data they belong to.

📋 What You'll Learn

Create a struct called Book with fields title (string) and pages (int).

Create a method called ShowTitle for Book that prints the book's title.

Create a method called UpdatePages for Book that changes the page count.

Create a main function to create a Book instance, call ShowTitle, update pages, and then print the new page count.

💡 Why This Matters

🌍 Real World

In real programs, methods help keep data and the actions on that data together, like a book knowing how to show its title or update its pages.

💼 Career

Understanding methods is key for writing clean, organized code in Go, which is important for many software development jobs.

1

Create the Book struct

Create a struct called Book with two fields: title of type string and pages of type int.

Go

// Define the Book struct with title and pages fields
// Your code here

Hint

Use the type keyword to define a struct. Inside curly braces, list the fields with their types.

2

Add the ShowTitle method

Add a method called ShowTitle with a receiver of type *Book that prints the book's title using fmt.Println. Import fmt package if needed.

Go

package main

import "fmt"

// Add ShowTitle method for *Book receiver
// Your code here

Hint

Define a method with func (b *Book) ShowTitle(). Use fmt.Println to print b.title.

3

Add the UpdatePages method

Add a method called UpdatePages with a receiver of type *Book that takes an int parameter called newPages and updates the pages field of the book.

Go

package main

import "fmt"

// Add UpdatePages method for *Book receiver
// Your code here

Hint

Define a method with func (b *Book) UpdatePages(newPages int). Inside, set b.pages = newPages.

4

Use the methods in main

In the main function, create a Book variable called myBook with title "Go Basics" and pages 100. Call myBook.ShowTitle(), then call myBook.UpdatePages(150), and finally print the updated pages using fmt.Println(myBook.pages).

Go

package main

import "fmt"

func main() {
    // Create myBook variable
    // Call ShowTitle method
    // Call UpdatePages method with 150
    // Print updated pages
    // Your code here
}

Hint

Use myBook := Book{title: "Go Basics", pages: 100} to create the book. Call methods with myBook.ShowTitle() and myBook.UpdatePages(150). Print pages with fmt.Println(myBook.pages).

Practice

1. Why do we use methods in Go programming language?

easy

A. To avoid using variables in the program

B. To write code that runs faster than functions

C. To associate functions with specific data types for better organization

D. To create global variables automatically

Solution

1. Step 1: Understand the purpose of methods

   Methods are functions tied to a specific data type, helping organize code logically.

2. Step 2: Compare methods with other options

   Options A, B, and D describe unrelated or incorrect uses of methods.

3. Final Answer:

   To associate functions with specific data types for better organization -> Option C

4. Quick Check:

   Methods connect actions to types = C [OK]

Hint: Methods link functions to types for clear code structure [OK]

Common Mistakes:

• Thinking methods make code run faster
• Confusing methods with variables
• Believing methods create global variables

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 UpdateName(p Person*, newName string) {}

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

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

Solution

1. Step 1: Recall Go method syntax with pointer receiver

   The receiver is declared inside parentheses before the method name, with *Type for pointer.

2. Step 2: Check each option

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

3. Final Answer:

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

4. Quick Check:

   Pointer receiver syntax = D [OK]

Hint: Pointer receiver syntax: func (p *Type) method() {} [OK]

Common Mistakes:

• Placing * outside parentheses
• Using * in parameter list incorrectly
• Missing parentheses around receiver

3. What will be the output of the following Go code?

package main
import "fmt"

type Counter struct {
    value int
}

func (c *Counter) Increment() {
    c.value++
}

func main() {
    c := Counter{value: 5}
    c.Increment()
    fmt.Println(c.value)
}

medium

A. 6

B. 5

C. 0

D. Compilation error

Solution

1. Step 1: Understand pointer receiver effect

   The Increment method uses a pointer receiver, so it modifies the original Counter's value.

2. Step 2: Trace the code execution

   Initial value is 5, Increment adds 1, so value becomes 6, which is printed.

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Pointer receiver changes value = 6 [OK]

Hint: Pointer receiver methods modify original data, so value changes [OK]

Common Mistakes:

• Thinking value stays 5 because method looks like a copy
• Assuming no output due to missing import
• Confusing pointer and value receivers

4. Identify the error in this Go method definition and fix it:

type Rectangle struct {
    width, height int
}

func (r Rectangle) Scale(factor int) {
    r.width = r.width * factor
    r.height = r.height * factor
}

medium

A. Change method name to lowercase: func (r Rectangle) scale(factor int) {}

B. Add return type: func (r Rectangle) Scale(factor int) Rectangle {}

C. Remove receiver: func Scale(factor int) {}

D. Change receiver to pointer: func (r *Rectangle) Scale(factor int) {}

Solution

1. Step 1: Understand why Scale does not change Rectangle

   The receiver is a value copy, so changes inside Scale do not affect original Rectangle.

2. Step 2: Fix by using pointer receiver

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

3. Final Answer:

   Change receiver to pointer: func (r *Rectangle) Scale(factor int) {} -> Option D

4. Quick Check:

   Pointer receiver needed to modify data = A [OK]

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

Common Mistakes:

• Using value receiver when modification is needed
• Adding return type unnecessarily
• Changing method name case without reason

5. You want to create a method that updates a user's email in a struct and also logs the change. Which approach best uses methods to achieve this in Go?

hard

A. Define a value receiver method that returns a new struct with updated email and logs externally

B. Define a pointer receiver method to update email and call a separate logging function inside it

C. Use a global function to update email and logging without methods

D. Define a method without receiver that updates email and logs

Solution

1. Step 1: Understand method purpose and data modification

   Updating email requires changing the original struct, so pointer receiver is needed.

2. Step 2: Combine update and logging logically

   Method with pointer receiver can update email and call logging function internally for reuse and clarity.

3. Final Answer:

   Define a pointer receiver method to update email and call a separate logging function inside it -> Option B

4. Quick Check:

   Pointer receiver + internal logging = A [OK]

Hint: Use pointer receiver method to update and log together [OK]

Common Mistakes:

• Using value receiver and expecting original to change
• Separating update and logging outside methods unnecessarily
• Avoiding methods and using only global functions