你说的这种叫组合，是将多个已定义的struct组合成一个新的struct。
你可以看看，源码中应该有已定义的decoder ,writer 两个struct。
在新的struct中可以不用定义名称，使用的时候，可以直接当成新struct的属性。

原来要这样，声明全局变量及类型，类型用反射获取，然后把逻辑写在init函数中，init函数在main函数之前执行。

package main
import (
    "os"
    "log"
)

var FOB *os.File
func init(){
    var err error
    var filename = "./file.txt"
    FOB, err = os.OpenFile(filename, os.O_WRONLY | os.O_CREATE | os.O_APPEND, 0666)
    if err != nil{
        log.Fatalln("open file error", err.Error())
    }
}

func main(){
    FOB.WriteString("...string...")
    FOB.Close()
}

首先有一点错误是，你不能把 doFunc1 和 doFunc2 这 2 个类型当作参数传到函数里。

其次你需要声明这么一个接口：

type doFunc interface {
    do()
}

总的样子应该是这样：

type DoFunc interface {
        do()
}

//方法1
type doFunc1 struct{}

func (*doFunc1) do() {
        fmt.Println("执行了方法1")
}

//方法2
type doFunc2 struct{}

func (*doFunc2) do() {
        fmt.Println("执行了方法2")
}

func factory(doFunc DoFunc) {
        doFunc.do()
}
// 还可以这样写
// func factory(doFunc interface{}) {
//      doFunc.(DoFunc).do()
// }

func main() {
        var (
                a doFunc1
                b doFunc2
        )
        factory(&a) //输出“执行了方法1”
        factory(&b) //输出“执行了方法2”
}

map、slice 以及 int 等这些基础数据类型都会出现并发安全问题。经常使用 map 是因为 map 比较典型，经常会有这方面的错误。

问题描述

在阅读《go语言圣经》这本数中，对 “并发的循环” 这个章节中，使用 WaitGoup 处理 goroutines 泄漏的描述未看懂，请各位指教。

书中描述说：

如果等待操作被放在了main goroutine中，在循环之前，这样的话就永远都不会结束了

我不明白这里为什么一定要把 wg.Wait() 放到一个goroutine中去执行呢？为什么放到 main goroutine 中，就永远不会结束了？

相关代码

// 请把代码文本粘贴到下方（请勿用图片代替代码）

func makeThumbnails6(filenames <-chan string) int64 {
    sizes := make(chan int64)
    var wg sync.WaitGroup // number of working goroutines
    for f := range filenames {
        wg.Add(1)
        // worker
        go func(f string) {
            defer wg.Done()
            thumb, err := thumbnail.ImageFile(f)
            if err != nil {
                log.Println(err)
                return
            }
            info, _ := os.Stat(thumb) // OK to ignore error
            sizes <- info.Size()
        }(f)
    }

    // closer
    go func() { // 为什么一定要在goroutine中进行执行？
        wg.Wait()
        close(sizes)
    }()

    var total int64
    for size := range sizes {
        total += size
    }
    return total
}

问题描述

在阅读《go语言圣经》这本数中，对 “并发的循环” 这个章节中，使用 WaitGoup 处理 goroutines 泄漏的描述未看懂，请各位指教。

书中描述说：

如果等待操作被放在了main goroutine中，在循环之前，这样的话就永远都不会结束了

我不明白这里为什么一定要把 wg.Wait() 放到一个goroutine中去执行呢？为什么放到 main goroutine 中，就永远不会结束了？

相关代码

// 请把代码文本粘贴到下方（请勿用图片代替代码）

func makeThumbnails6(filenames <-chan string) int64 {
    sizes := make(chan int64)
    var wg sync.WaitGroup // number of working goroutines
    for f := range filenames {
        wg.Add(1)
        // worker
        go func(f string) {
            defer wg.Done()
            thumb, err := thumbnail.ImageFile(f)
            if err != nil {
                log.Println(err)
                return
            }
            info, _ := os.Stat(thumb) // OK to ignore error
            sizes <- info.Size()
        }(f)
    }

    // closer
    go func() { // 为什么一定要在goroutine中进行执行？
        wg.Wait()
        close(sizes)
    }()

    var total int64
    for size := range sizes {
        total += size
    }
    return total
}

问题描述

在阅读《go语言圣经》这本数中，对 “并发的循环” 这个章节中，使用 WaitGoup 处理 goroutines 泄漏的描述未看懂，请各位指教。

书中描述说：

如果等待操作被放在了main goroutine中，在循环之前，这样的话就永远都不会结束了

我不明白这里为什么一定要把 wg.Wait() 放到一个goroutine中去执行呢？为什么放到 main goroutine 中，就永远不会结束了？

相关代码

// 请把代码文本粘贴到下方（请勿用图片代替代码）

func makeThumbnails6(filenames <-chan string) int64 {
    sizes := make(chan int64)
    var wg sync.WaitGroup // number of working goroutines
    for f := range filenames {
        wg.Add(1)
        // worker
        go func(f string) {
            defer wg.Done()
            thumb, err := thumbnail.ImageFile(f)
            if err != nil {
                log.Println(err)
                return
            }
            info, _ := os.Stat(thumb) // OK to ignore error
            sizes <- info.Size()
        }(f)
    }

    // closer
    go func() { // 为什么一定要在goroutine中进行执行？
        wg.Wait()
        close(sizes)
    }()

    var total int64
    for size := range sizes {
        total += size
    }
    return total
}

go 中有一个数据类型 是 byte.
怎么理解这个数据类型的应用场景？
看代码过程中看到经常使用这个，但感觉有些直接使用 string 类型也可以。
那么 byte 这个类型的应用场景是什么?为什么要用它？