ch7/ch7-05

[giscus[bot]]

ch7/ch7-05

中文版

https://golang-china.github.io/gopl-zh/ch7/ch7-05.html

[dugulingping]

我的一些理解

不知道理解的对不对, 不对的话, 请各路大佬指正

func main() {
	var w io.Writer
	fmt.Printf("(%T, %[1]v)\n", w)
	w = os.Stdout
	w = io.Writer(os.Stdout)
	fmt.Printf("(%T, %[1]v)\n", w)
	w.Write([]byte("hello, writer\n")) // 向屏幕输出了hello, writer
	fmt.Printf("(%T, %[1]v)\n", w)
	w = new(bytes.Buffer)
	fmt.Printf("(%T, %[1]v)\n", w)
	w.Write([]byte("hello")) // 向缓冲区写入了hello
	fmt.Printf("(%T, %[1]v)\n", w)

	w = nil
	fmt.Printf("(%T, %[1]v)\n", w)

	// 这里按照我的理解，w是一个接口，接口的值是一个指针，指向一个实现了Write()方法的结构体
	// os.Stdout是一个变量，保存了 os.NewFile()这个函数的返回值，这个函数返回的是一个File结构体指针
	// 这个File结构体实现了Write()方法
	// 按照接口的约束条件, w可以使用Write()方法
	// 但不能使用File结构体里实现的其他方法，比如Close()方法

	// 这里不管是w = os.Stdout还是w = new(bytes.Buffer),
	// 都是将w的值改变了，但是w的类型是不变的，都是io.Writer
	// 所以接口的类型是不变的，接口的约束仍然存在

	// 接口的值在我看来很像是一个指针，指向一个实现了接口的某一个结构体
	// 这个结构体可以是一个File结构体，也可以是一个Buffer结构体
	// 实现的方法也不一样，所以调用的结果也不一样
	type name struct {
		firstName string
		lastName  string
	}
	var x, y interface{}
	x = name{"John", "Doe"}
	y = name{"John", "Doe"}
	fmt.Println(x == y) // true
	// 这里的x和y是两个接口，接口的值是两个结构体
	// 两个结构体的值是一样的，所以x和y是相等的

	x = &name{"John", "Doe"}
	y = &name{"John", "Doe"}
	fmt.Println(x == y) // false
	// 这里的x和y是两个接口，接口的值是两个结构体指针
	// 两个结构体指针的值是不一样的，所以x和y是不相等的

	// Go中的接口的nil值和指针类型的nil值是不一样的
	type Empty struct{}
	var z interface{}
	var AEmpty Empty
	var p *int
	fmt.Printf("%T, %[1]v\n", AEmpty)
	fmt.Println(z == AEmpty) // false
	fmt.Println(z == nil)    // true
	fmt.Println(p == nil)    // true
	fmt.Println(z == p)      // false
	// 在实际开发中, 要尽量用nil代替空指针去返回
	// see : 【golang 踩坑之：Shit box】 https://www.bilibili.com/video/BV1G8411j7Q6
}

[zhangbest5]

这三章我去，懵逼，真不如看视频

[Awkee]

这个仅仅是个例子，说明 当指向nil的静态类型变量赋值给接口类型变量时，接口类型变量并不是nil。

实际项目中这样写代码不合理，比如 f(buf) 应该是放在 if debug 语句块中的。
当然，这只是作者为了演示本节内容的示例，实际代码中还是不要这样写为好。

const debug = false

// If out is non-nil, output will be written to it.
func f(out io.Writer) {
    // ...do something...
    if out != nil {
        out.Write([]byte("done!\n"))
    }
}

func main() {

    var buf *bytes.Buffer
    if debug {
        buf = new(bytes.Buffer) // enable collection of output
    }
    f(buf) // NOTE: 这里发生了 *bytes.Buffer类型变量 buf 赋值给 io.Writer类型接口参数
    // 由于buf是 *bytes.Buffer类型，所以 io.Writer类型的接口参数包含了type为 *bytes.Buffer和value为nil的值。
    // 因此，此时的out不是nil
    // 避免在函数参数中发生静态类型变量传递给接口类型参数情况。


    // 这只是示例，实际写代码时 f(buf)会放到 if debug 语句块中才是合理的。
    if debug {
        // f(buf)  // OK!
        fmt.Println(buf)
    }

}

[Caleb196x]

翻译的让人看不懂，看英文去了

[KrxkGit]

我说一下我的个人理解吧，从理解的角度，可以将接口值视为一个指针，该指针指向一个表结构（即文中的概念模型），表中记录了动态类型与动态类型的值（如动态类型为int, 值为1）。
当将一个具体的类型（如int）赋值给一个接口时，会发生填表操作，即将int类型记录下来，并记录此时的int类型的值（如1）。而如果记录的动态类型是某些指针，如文中的buffer，即使其为nil也将记录在表中，而重要的是：接口值==nil当且仅当记录的类型为nil。
文中提到的修改方法就是在初始化阶段赋值给接口值为nil，即用nil来完成填整个表（而非仅填动态类型的值部分），从而避免这种问题。

[LuVsLu]

接口值有两个部分组成，一个是具体类型，一个是具体的值，接口值==nil 的前提是类型和值都没有指定的情况下才成立。

[Leaf-aqua]

这就是其他语言的多态吧hh，感觉讲的好抽象

[noahacgn]

第7章翻译得太垃圾了

[WweiweiSmile]

*bytes.Buffer 的Write方法是不支持传入nil的，报错panic
Io.Writer 的 Write方法是支持传入nil的，所以不报错panic
为什么f函数中 out != nil 未能成功判定呢，因为out不是空值。空值是接口类型与接口值都为nil。而out接口类型不是nil，接口值是nil。