Go语言中接口与指针的正确姿势：避免*interface{}的陷阱

package main

import (
    "fmt"
    "io"
)

// MyResource 结构体实现了 io.Closer 接口
type MyResource struct {
    name   string
    closed bool
}

func (mr *MyResource) Close() error {
    if mr.closed {
        return nil // 已经关闭
    }
    mr.closed = true
    fmt.Printf("%s 已关闭。\n", mr.name)
    return nil
}

func main() {
    resource := &MyResource{name: "文件句柄"}
    var closer io.Closer = resource // 将 MyResource 的指针赋值给 io.Closer 接口变量
    closer.Close()                  // 在接口变量上调用方法
}

package main

import (
    "fmt"
    "io"
)

// 模拟一个实现了 io.Closer 接口的类型
type MockCloser struct{}

func (mc *MockCloser) Close() error {
    fmt.Println("MockCloser closed.")
    return nil
}

func main() {
    // 1. 正确用法：直接使用接口类型变量
    var closer io.Closer = &MockCloser{} // closer 是一个 io.Closer 接口类型变量
    closer.Close()                       // 正确：在接口变量上调用方法

    // 2. 错误示范：对接口类型变量取指针
    // var ptrToCloser *io.Closer = &closer
    // 编译错误：ptrToCloser.Close undefined (type *io.Closer has no field or method Close)
    // fmt.Println(ptrToCloser) // 如果上面一行取消注释，此行将无法编译
}

package main

import (
    "fmt"
    "io"
)

// MyCustomResource 结构体，其方法接收者为指针类型
type MyCustomResource struct {
    id     int
    status string
}

// Read 方法，实现了 io.Reader 接口的一部分
func (mcr *MyCustomResource) Read(p []byte) (n int, err error) {
    if mcr.status == "closed" {
        return 0, io.EOF
    }
    fmt.Printf("Resource %d reading. Status: %s\n", mcr.id, mcr.status)
    copy(p, []byte("data")) // 模拟读取数据
    return len("data"), nil
}

// Close 方法，实现了 io.Closer 接口
func (mcr *MyCustomResource) Close() error {
    if mcr.status == "closed" {
        return nil
    }
    mcr.status = "closed"
    fmt.Printf("Resource %d closed.\n", mcr.id)
    return nil
}

func main() {
    // 1. 创建一个具体类型的实例（通常是其指针，如果方法接收者是指针）
    resource := &MyCustomResource{id: 101, status: "open"}

    // 2. 将具体类型实例（这里是 *MyCustomResource）赋值给接口类型变量
    // resource 实现了 io.Reader 和 io.Closer，因此可以赋值给 io.ReadCloser
    var rc io.ReadCloser = resource

    // 3. 直接在接口类型变量上调用方法
    buf := make([]byte, 10)
    n, err := rc.Read(buf)
    if err != nil && err != io.EOF {
        fmt.Printf("Error reading: %v\n", err)
    } else {
        fmt.Printf("Read %d bytes: %s\n", n, string(buf[:n]))
    }

    err = rc.Close()
    if err != nil {
        fmt.Printf("Error closing: %v\n", err)
    }

    // 再次读取，此时资源已关闭
    n, err = rc.Read(buf)
    fmt.Printf("After close - Read %d bytes, error: %v\n", n, err)
}

package main

import "fmt"

func main() {
    var i interface{} // 声明一个空接口变量，其零值是 nil
    fmt.Printf("var i interface{}: Type=%T, Value=%v, IsNil=%t\n", i, i, i == nil)

    ptrToI := new(interface{}) // ptrToI 是一个 *interface{} 类型
    fmt.Printf("new(interface{}): Type=%T, Value=%v, IsNil=%t\n", ptrToI, ptrToI, ptrToI == nil)
    fmt.Printf("*ptrToI: Type=%T, Value=%v, IsNil=%t\n", *ptrToI, *ptrToI, *ptrToI == nil)
}

var i interface{}: Type=<nil>, Value=<nil>, IsNil=true
new(interface{}): Type=*interface {}, Value=0x... (address), IsNil=false
*ptrToI: Type=<nil>, Value=<nil>, IsNil=true