How do I call a method on a struct instance in Go?

In Go language, calling a structure method requires first defining the structure and the method that binds the receiver, and accessing it using a point number. After defining the structure Rectangle, the method can be declared through the value receiver or the pointer receiver; 1. Use the value receiver such as func (r Rectangle) Area() int, and it is called directly through rect.Area(); 2. If you need to modify the structure, use the pointer receiver such as func (r *Rectangle) SetWidth(...), and Go will automatically handle the conversion of pointers and values; 3. When embedding the structure, the method of embedded structure will be promoted and can be called directly through the outer structure; 4. Go does not need to force getter/setter, and fields can be accessed directly unless logical control is required. These mechanisms make method calls concise and flexible.

In Go, calling a method on a struct instance is straightforward — you use dot notation, just like accessing fields. The key is understanding how methods are defined with receivers tied to specific types.

Define the Struct and Method

First, define a struct type, then declare a method with a receiver of that type:

 type Rectangle struct {
    Width, Height int
}

func (r Rectangle) Area() int {
    return r.Width * r.Height
}

Here, Area is a method on Rectangle . The (r Rectangle) part means it's a value receiver — the method gets a copy of the Rectangle instance it's called on.

To call it:

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

This works because Go automatically handles pointer vs. value receivers for you — more on that below.

Use Pointer Receivers When You Need to Modify the Instance

If your method needs to modify the struct, use a pointer receiver:

 func (r *Rectangle) SetWidth(newWidth int) {
    r.Width = newWidth
}

Then call it like this:

 rect := &Rectangle{Width: 3, Height: 4}
rect.SetWidth(5)
fmt.Println(rect.Width) // Output: 5

A few things to note:

• If you have a pointer to a struct, Go lets you call both value and pointer methods.
• If you have a value, you can only call value methods unless Go automatically takes its address.

So if you write:

 rectVal := Rectangle{3, 4}
rectVal.SetWidth(5) // still works!

Go will automatically convert rectVal to a pointer when calling SetWidth , so you don't have to worry about matching types in most cases.

Call Methods on Embedded Structs

Go supports embedding structs inside other structs, and their methods are promoted:

 type Inner struct {
    Value int
}

func (i Inner) PrintValue() {
    fmt.Println(i.Value)
}

type Outer struct {
    Inner // embedded
}

Now you can call the method directly on the outer struct:

 o := Outer{Inner{Value: 10}}
o.PrintValue() // Output: 10

This avoids having to write o.Inner.PrintValue() every time.

Keep It Simple: No Need for Getters or Setters

Unlike some languages, Go doesn't require getters and setters. Since all fields are public if capitalized, you can access them directly unless you need logic around setting a value.

For example:

 // Just assign directly
rect.Width = 6

// Only use a method if validation is needed
func (r *Rectangle) SetWidthSafe(w int) {
    if w < 0 {
        panic("width must be non-negative")
    }
    r.Width = w
}

Calling this is no different than any other method:

 rect := &Rectangle{}
rect.SetWidthSafe(5)

Calling a method on a struct in Go is simple once you understand receivers. Whether you're working with value or pointer receivers, embedded types, or direct field access, Go gives you flexibility without extra boilerplate.

Basically that's it.

The above is the detailed content of How do I call a method on a struct instance in Go?. For more information, please follow other related articles on the PHP Chinese website!