Go语言中若类型某方法需指针接收器，是否需全部改为指针接收器？

Hey there! Let's work through this confusion step by step—Go's method receiver rules can feel counterintuitive at first, but once you grasp the method set mechanics, it all clicks.

先搞懂方法集的基础规则 #

First, let's recap how method sets work for value and pointer types:

• For a type T, its method set includes all methods with value receivers (func (t T) ...). Go will let you call pointer-receiver methods on a T instance by automatically taking its address, but T itself doesn't technically "own" those pointer methods.
• For a pointer type *T, its method set includes all methods with both value and pointer receivers—Go handles automatic dereferencing here, so you can call value methods on a pointer without extra work.

为什么官方强调「一致性原则」？ #

如果某类型的部分方法必须使用指针接收器，其余方法也应采用指针接收器，以确保无论该类型如何使用，方法集始终一致

This rule exists to prevent frustrating bugs and inconsistencies. Let's use your scenario to illustrate:

Suppose you have a type T that needs to implement two interfaces:

// 需要修改实例状态，必须用指针接收器
type MutableInterface interface {
    UpdateData(newVal string)
}

// 只读操作，理论上值接收器也能工作
type ReadOnlyInterface interface {
    GetData() string
}

type T struct {
    data string
}

错误示范：混合值和指针接收器

If you mix receivers like this:

// 值接收器：T的方法集包含这个方法
func (t T) GetData() string {
    return t.data
}

// 指针接收器：只有*T的方法集包含这个方法
func (t *T) UpdateData(newVal string) {
    t.data = newVal
}

Now you run into problems:

• You can pass a T instance to a function expecting ReadOnlyInterface (since T has GetData), but you can't pass that same T instance to a function expecting MutableInterface (since T doesn't have UpdateData in its method set).
• If you have a function that expects both interfaces, like func Process(m MutableInterface, r ReadOnlyInterface), you can only pass &T—passing T will throw a compile error because T doesn't satisfy MutableInterface.

正确做法：统一用指针接收器

If you switch all methods to use pointer receivers:

func (t *T) GetData() string {
    return t.data
}

func (t *T) UpdateData(newVal string) {
    t.data = newVal
}

Now:

• Both *T and T instances can be used with both interfaces (Go automatically takes the address of T when you call pointer methods on it).
• There's no ambiguity about how to use T—everyone reading your code knows to work with pointers, avoiding unexpected behavior.
• You won't hit compile errors when passing instances between functions expecting different interfaces that T implements.

例外情况：不可变类型 #

The only time you can safely stick to value receivers across all methods is if your type is immutable (like int, string, or a custom type that never modifies its internal state). In that case, value receivers are fine because there's no need for pointer semantics.

But as soon as one method needs to modify the instance (or you're dealing with a large struct where copying is inefficient), go all-in on pointer receivers. It'll save you headaches down the line.

内容的提问来源于stack exchange，提问作者norshtein