Methods in Go are functions with a receiver, allowing them to be associated with a specific type, such as a struct, enabling type-specific behavior. 2. Unlike functions, methods have a receiver, use dot notation for invocation on instances, can use value or pointer receivers to control modification and copying, and promote encapsulation by keeping logic tied to types. 3. Use methods when logic belongs to a type, such as implementing behavior or interfaces, and use functions for generic, standalone, or utility operations. 4. A real-world analogy is that methods represent actions performed by an instance, like file.Read(), while functions represent independent operations, like os.Open(). In summary, methods attach behavior to types and are central to Go’s object-oriented style, favoring composition, so if an operation feels like something a type does, it should be a method.

In Go, methods are functions that have a receiver—a special parameter that associates the function with a specific type. This allows you to define behavior for a particular type, similar to how objects have methods in object-oriented languages.

1. What Are Methods in Go?

A method is just like a function, but it belongs to a type. The receiver can be a struct, a basic type, or even a pointer to a type. Here's a simple example:

type Rectangle struct {
    Width  float64
    Height float64
}

// Method with a value receiver
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

Here, Area is a method of Rectangle. The (r Rectangle) part is the receiver declaration.

You call it like this:

rect := Rectangle{Width: 3, Height: 4}
fmt.Println(rect.Area()) // Output: 12

2. Methods vs Functions: Key Differences

While both methods and functions perform reusable logic, there are important differences:

? 1. Receiver vs No Receiver

• Functions don’t have a receiver.
• Methods have a receiver, which ties them to a type.

// Function (no receiver)
func CalculateArea(w, h float64) float64 {
    return w * h
}

// Method (has a receiver)
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

The method feels more natural when working with data types, especially structs.

? 2. Syntax and Invocation

• Functions are called directly: CalculateArea(3, 4)
• Methods are called on instances: rect.Area()

This makes methods feel more intuitive when modeling domain logic.

? 3. Value vs Pointer Receivers

Methods can have either value receivers or pointer receivers:

// Value receiver (works on a copy)
func (r Rectangle) Area() float64 { ... }

// Pointer receiver (can modify the original)
func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

Pointer receivers are used when you want to modify the receiver or avoid copying large structs.

Functions can't do this directly—they’d need to take a pointer as an explicit argument.

? 4. Encapsulation and Type Behavior

Methods allow you to define behavior that’s logically tied to a type, promoting cleaner, more organized code.

For example, validation, formatting, or business rules can live with the type:

func (r Rectangle) IsValid() bool {
    return r.Width > 0 && r.Height > 0
}

With functions, you'd scatter such logic around.

3. When to Use Methods vs Functions

Use methods when:

• The logic is closely tied to a type.
• You're modeling behavior of a data structure.
• You want to implement an interface (e.g., Stringer, error).

Use functions when:

• The operation is generic or applies to multiple types.
• It doesn’t naturally belong to one type.
• You're writing utility or helper logic.

For example, a function like Max(a, b int) doesn't need to belong to a type.

4. A Real-World Analogy

Think of a File type:

• file.Read() → makes sense as a method (behavior of a file)
• os.Open("path") → makes sense as a function (creates a file, not tied to an instance)

So:

• Methods = actions on or by an instance.
• Functions = standalone operations.

Bottom line:
Methods are functions with a receiver, letting you attach behavior to types. They’re central to Go’s approach to object-oriented design—simple, explicit, and based on composition rather than inheritance.

It’s not about which is better, but which fits the context. Use methods to give your types behavior, and functions for general-purpose logic.

Basically, if it feels like something the type does, make it a method.

The above is the detailed content of What are methods in Go and how are they different from functions?. For more information, please follow other related articles on the PHP Chinese website!