深入理解Go语言中对接口类型应用new()操作符_技术教程

在go语言中，对接口类型使用`new()`操作符会创建一个指向该接口零值（即`nil`）的指针。虽然语法上合法，但这种做法在实际开发中几乎没有实用价值，因为它引入了不必要的间接层，且go接口本身的设计意图是直接使用而非通过指向接口的指针来操作。

new()操作符在Go语言中的作用

在Go语言中，new()是一个内置函数，用于为指定类型分配内存并返回一个指向该类型零值的指针。它的签名是func new(Type) *Type。这意味着无论Type是什么，new(Type)总是返回*Type。

对结构体类型应用new()

当我们对一个结构体类型应用new()时，其行为符合直觉。例如：

package main

import "fmt"

type MyStruct struct {
    Name string
    Age  int
}

func main() {
    s := new(MyStruct) // s 的类型是 *MyStruct
    fmt.Printf("Type of s: %T, Value of s: %v\n", s, s)
    fmt.Printf("Dereferenced s: %v\n", *s)
    // 输出:
    // Type of s: *main.MyStruct, Value of s: &{ 0}
    // Dereferenced s: { 0}
}

在这里，new(MyStruct)分配了一个MyStruct类型的内存，并将其所有字段初始化为零值（Name为空字符串，Age为0），然后返回一个指向这个新分配的MyStruct实例的指针。

对接口类型应用new()

现在，让我们考虑对一个接口类型应用new()的情况。假设我们定义一个接口：

type Burper interface {
    burp() int
}

当我们执行b := new(Burper)时，Go编译器会做什么呢？

package main

import "fmt"

type Burper interface {
    burp() int
}

func main() {
    b := new(Burper) // b 的类型是 *Burper
    fmt.Printf("Type of b: %T, Value of b: %v\n", b, b)
    fmt.Printf("Dereferenced *b: %T, Value of *b: %v\n", *b, *b)

    // 验证 *b 是否为 nil
    if *b == nil {
        fmt.Println("*b is nil")
    }

    // 尝试调用方法会引发运行时错误，因为 *b 是 nil
    // (*b).burp() // 这行代码如果执行会 panic: runtime error: invalid memory address or nil pointer dereference
}

解析：

b := new(Burper)：new()函数返回一个指向Burper类型零值的指针。因此，b的类型是*Burper。
*Burper指向的内存中存储的是一个Burper接口类型的值。Go语言中接口的零值是nil。这意味着这个接口值不包含任何具体的类型信息，也不包含任何具体的值。
所以，b是一个指向nil接口值的指针。当你解引用b时（即*b），你得到的是那个nil接口值。

从输出中我们可以清楚地看到：b的类型是*main.Burper，而*b的类型是，值也是。

为什么对接口类型使用new()不常见且无用？

理解为什么这种用法不实用，需要回顾Go接口的本质：

接口的结构： 在Go内部，一个接口值可以被看作是一个包含两个指针的结构体：一个指向其具体类型（type）的指针，另一个指向该具体类型的值（value）的指针。当接口为nil时，这两个指针都为nil。

接口的直接使用： 在Go中，我们通常直接声明一个接口类型的变量，例如var myBurper Burper。这个myBurper变量本身就是一个接口值，它最初是nil。我们可以直接将实现该接口的具体类型实例赋值给它：

package main

import "fmt"

type Burper interface {
    burp() int
}

type MyConcreteBurper struct{}
func (m MyConcreteBurper) burp() int { return 42 }

func main() {
    var myBurper Burper // myBurper 是 Burper 类型，初始值为 nil
    fmt.Printf("Type of myBurper: %T, Value of myBurper: %v\n", myBurper, myBurper) // 输出: Type of myBurper: , Value of myBurper: 

    myBurper = MyConcreteBurper{} // 直接赋值，myBurper 现在包含具体类型和值
    fmt.Printf("Type of myBurper: %T, Value of myBurper: %v\n", myBurper, myBurper) // 输出: Type of myBurper: main.MyConcreteBurper, Value of myBurper: {}
    fmt.Println(myBurper.burp()) // 输出: 42
}

这种方式直接且符合Go语言的惯例。

new(Burper)引入的额外间接层： 当你使用b := new(Burper)时，b是一个*Burper。为了使用这个接口，你必须先解引用它：(*b)。然后你才能尝试将一个具体类型赋值给(*b)。这增加了一个不必要的指针层级。

package main

import "fmt"

type Burper interface {
    burp() int
}

type MyConcreteBurper struct{}
func (m MyConcreteBurper) burp() int { return 42 }

func main() {
    concreteBurper := MyConcreteBurper{}

    b := new(Burper) // b 是 *Burper
    // 现在我们需要将 concreteBurper 赋值给 *b
    *b = concreteBurper // 此时 *b 不再是 nil 接口
    fmt.Printf("Type of *b: %T, Value of *b: %v\n", *b, *b) // 输出: Type of *b: main.MyConcreteBurper, Value of *b: {}
    fmt.Println((*b).burp()) // 输出: 42
}

对比直接使用var myBurper Burper; myBurper = concreteBurper;，new(Burper)的方式显然更为繁琐，且没有带来任何实际的好处。