Why Method call behavior in Go? - Purpose & Use Cases

The Big Idea

What if you could make your code smarter by letting objects do things themselves?

The Scenario

Imagine you have a list of objects, and you want to perform an action on each one by writing separate code for each object manually.

For example, calling a function on each item without a clear, consistent way to do it.

The Problem

Manually calling functions on each object is slow and repetitive.

It's easy to make mistakes, like calling the wrong function or forgetting to update all calls when the behavior changes.

This approach doesn't scale well as the number of objects grows.

The Solution

Method call behavior lets you attach functions directly to types, so you can call methods on objects naturally.

This means you write the behavior once, and every object of that type can use it consistently.

It makes your code cleaner, easier to read, and less error-prone.

Before vs After

✗ Before

func printName(p Person) {
    fmt.Println(p.name)
}
printName(person1)
printName(person2)

✓ After

func (p Person) PrintName() {
    fmt.Println(p.name)
}
person1.PrintName()
person2.PrintName()

What It Enables

It enables writing clear, reusable, and organized code where data and behavior live together naturally.

Real Life Example

Think of a game where each character can attack. Instead of writing separate attack functions for each character, you define an attack method once, and every character can use it.

Key Takeaways

Manual calls are repetitive and error-prone.

Methods attach behavior directly to data types.

This makes code cleaner, reusable, and easier to maintain.