Methods

Introduction

Go doesn't have classes, but it does let you attach functions directly to a type — these are called methods. A method is just a function with an extra parameter, called a receiver, that specifies which type it belongs to. Understanding the choice between value and pointer receivers is one of the more important decisions you'll make repeatedly in Go code.

Defining a Method

A method is declared like a regular function, but with a receiver argument in parentheses between the func keyword and the method name. The receiver names the type the method belongs to.

package main

import "fmt"

type Rectangle struct {
	Width, Height float64
}

// Area is a method on Rectangle, with receiver "r".
func (r Rectangle) Area() float64 {
	return r.Width * r.Height
}

func main() {
	rect := Rectangle{Width: 5, Height: 3}
	fmt.Println("Area:", rect.Area())
}

Value Receivers

A value receiver, written (r Rectangle), receives a copy of the struct it's called on. Changes made to the receiver inside the method have no effect on the original value — exactly like a regular value parameter.

package main

import "fmt"

type Rectangle struct {
	Width, Height float64
}

// Value receiver: operates on a copy, cannot mutate the original.
func (r Rectangle) Scale(factor float64) Rectangle {
	r.Width *= factor
	r.Height *= factor
	return r // return a new, scaled copy
}

func main() {
	rect := Rectangle{Width: 4, Height: 2}
	scaled := rect.Scale(2)

	fmt.Println("original:", rect)
	fmt.Println("scaled:  ", scaled)
}

Pointer Receivers

A pointer receiver, written (r *Rectangle), receives a pointer to the original struct. Changes made through the receiver inside the method directly mutate the caller's original value — this is the only way for a method to modify its receiver.

package main

import "fmt"

type Rectangle struct {
	Width, Height float64
}

// Pointer receiver: mutates the original struct directly.
func (r *Rectangle) ScaleInPlace(factor float64) {
	r.Width *= factor
	r.Height *= factor
}

func main() {
	rect := Rectangle{Width: 4, Height: 2}
	rect.ScaleInPlace(3)

	fmt.Println("mutated in place:", rect)
}

When to Use Each

A widely followed rule of thumb: if any method on a type needs a pointer receiver, use pointer receivers for all methods on that type, even the ones that don't strictly need to mutate anything. This keeps the type's method set consistent and avoids subtle bugs.

Go Handles the Conversion for You

You might expect to always need &rect to call a pointer-receiver method, or *ptr to call a value-receiver one. Go is more convenient than that: if you have an addressable value, Go automatically takes its address for you when calling a pointer-receiver method, and automatically dereferences a pointer when calling a value-receiver method.

package main

import "fmt"

type Counter struct {
	value int
}

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

func (c Counter) Value() int {
	return c.value
}

func main() {
	c := Counter{} // a plain value, not a pointer

	c.Increment() // Go automatically does (&c).Increment()
	c.Increment()

	fmt.Println(c.Value()) // 2
}

Methods on Non-Struct Types

Methods aren't limited to structs — you can define a method on any named type declared in your own package, including one based on a built-in type like int or string.

package main

import "fmt"

type Celsius float64

func (c Celsius) ToFahrenheit() float64 {
	return float64(c)*9/5 + 32
}

func main() {
	temp := Celsius(100)
	fmt.Printf("%.1f°C is %.1f°F\n", float64(temp), temp.ToFahrenheit())
}

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Methods let you attach behavior to your own types without needing classes or inheritance, and the value-versus-pointer receiver decision is one you'll make on nearly every type you define. Next, you'll learn about interfaces — how Go achieves polymorphism through implicit, structural typing rather than explicit "implements" declarations.