在Go語言中，調用結構體方法需先定義結構體和綁定接收者的方法，使用點號訪問。定義結構體Rectangle後，可通過值接收者或指針接收者聲明方法；1. 使用值接收者如func (r Rectangle) Area() int，通過rect.Area()直接調用；2. 若需修改結構體，應使用指針接收者如func (r *Rectangle) SetWidth(...)，Go會自動處理指針與值的轉換；3. 嵌入結構體時，內嵌結構體的方法會被提升，可直接通過外層結構體調用；4. Go無需強制使用getter/setter，字段可直接訪問，除非需要邏輯控制。這些機制讓方法調用簡潔靈活。

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.

基本上就這些。

以上是如何在GO中的結構實例上調用方法？的詳細內容。更多資訊請關注PHP中文網其他相關文章！