Go语言type-switch如何优雅处理nil指针以符合clean code规范

方案1：前置反射统一判空（改动最小，适合快速优化） #

只需要在函数开头加一行统一判空逻辑，无需修改原有type-switch分支，即可消除所有分支的重复判空代码：

import "reflect"

func test(a SomeType) {
    // 统一过滤所有空指针对象
    if v := reflect.ValueOf(a); v.Kind() == reflect.Ptr && v.IsNil() {
        return
    }
    switch msg := a.(type) {
    case *type1:
        dosomething1(msg) // 建议直接用断言后的msg变量，不要用原始a
    case *type2:
        dosomething2(msg)
    case *type3:
        dosomething3(msg)
    default:
        do()
    }
}

该方案逻辑简单，改动量极小，绝大多数业务场景下反射的性能开销可以忽略不计。

方案2：公共接口判空（无反射开销，适合性能敏感场景） #

如果对性能要求极高，可以为需要处理的指针类型实现统一的空判断接口，避免反射开销：

// 定义公共空判断接口
type Nullable interface {
    IsNil() bool
}

// 为所有需要处理的指针类型实现该接口
func (t *type1) IsNil() bool { return t == nil }
func (t *type2) IsNil() bool { return t == nil }
func (t *type3) IsNil() bool { return t == nil }

func test(a SomeType) {
    // 统一判空
    if nullable, ok := a.(Nullable); ok && nullable.IsNil() {
        return
    }
    switch msg := a.(type) {
    case *type1:
        dosomething1(msg)
    case *type2:
        dosomething2(msg)
    case *type3:
        dosomething3(msg)
    default:
        do()
    }
}

该方案完全没有反射开销，后续新增指针类型只需实现Nullable接口即可，无需修改test函数的判空逻辑，符合开闭原则。

方案3：多态替换type-switch（最符合Clean Code规范） #

如果要彻底消除type-switch的冗余代码，推荐用接口多态实现逻辑解耦：

// 定义公共行为接口
type Doer interface {
    Do()
}

// 每个类型实现自己的Do方法，自行处理空值逻辑
func (t *type1) Do() {
    if t == nil {
        return
    }
    // 原dosomething1的业务逻辑
}

func (t *type2) Do() {
    if t == nil {
        return
    }
    // 原dosomething2的业务逻辑
}

func (t *type3) Do() {
    if t == nil {
        return
    }
    // 原dosomething3的业务逻辑
}

func test(a SomeType) {
    if doer, ok := a.(Doer); ok {
        doer.Do()
        return
    }
    do()
}

该方案完全消除了type-switch代码，后续新增类型只需实现Doer接口即可，不需要修改test函数的任何代码，符合开闭原则、单一职责原则，是Clean Code推荐的最优实现方式。

额外注意点 #

• 原示例main函数存在变量名笔误：定义的变量是b_ptr，转接口时用了未定义的b，实际开发中需要修正避免编译错误
• type-switch分支中建议直接使用断言后的msg变量访问成员，不要使用原始的a变量，避免二次断言的开销和出错风险

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