Golang基础学习

2023-03-04

安装

brew install go@1.17

brew unlink go

brew link go@1.17

go mod

命令	解释
go mod download	下载依赖包到本地（默认为 `GOPATH//pkg//mod` 目录）
go mod edit	编辑 go.mod 文件
go mod graph	打印模块依赖图
go mod init	初始化当前文件夹，创建 go.mod 文件
go mod tidy	增加缺少的包，删除无用的包
go mod vendor	将依赖复制到 vendor 目录下
go mod verify	校验依赖
go mod why	解释为什么需要依赖
go mod build	将当前目录打包成package

go的一个目录对应一个包，包应当与目录名相同；

xxxx_test.go这类的命名存在bug，不要使用
Go的测试工具只会任务xxx_test.go的文件是测试文件，否则go test的时候可能会报没有测试文件的错误。

go plugin

参考

init函数

init函数的主要作用：

初始化不能采用初始化表达式初始化的变量。
程序运行前的注册。
实现sync.Once功能。
其他

init函数的主要特点：

init函数先于main函数自动执行，不能被其他函数调用；
init函数没有输入参数、返回值；
每个包可以有多个init函数；
包的每个源文件也可以有多个init函数，这点比较特殊；
同一个包的init执行顺序，golang没有明确定义，编程时要注意程序不要依赖这个执行顺序。
不同包的init函数按照包导入的依赖关系决定执行顺序。

defer/recover/panic联系

recover 只有在发生 panic之后调用才会生效；
panic 只会触发当前 Goroutine 的 defer；
recover 只有在 defer 中调用才会生效；
panic 允许在 defer 中嵌套多次调用；

详情参考

Go协程与线程的区别

简介

协程，英文名Coroutine。但在 Go语言中，协程的英文名是：gorutine。它常常被用于进行多任务，即并发作业。没错，就是多线程作业的那个作业。
虽然在 Go 中，我们不用直接编写线程之类的代码来进行并发，但是 Go 的协程却依赖于线程来进行。

特点

多个协程可由一个或多个线程管理，协程的调度发生在其所在的线程中；
可以被调度，调度策略由应用层代码定义，即可被高度自定义实现；
执行效率高；
占用内存少。

因为协程的调度切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。
调度发生在应用态而非内核态。内存的花销，使用其所在的线程的内存，意味着线程的内存可以供多个协程使用。
其次协程的调度不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，所以执行效率比多线程高很多。

参考

Example 1：在main或其他函数中开协程，主程序结束了，协程还继续执行吗?

main函数中的协程，如果main结束了，协程也会结束
其他函数里的协程，函数结束了，只要main没结束，协程就会执行。

Example 2：并发非重Practice

package mutexSyntex

import (
	"errors"
	"fmt"
	"sync"
)

type Fetcher interface {
	// Fetch 返回URL的body内容，并且将这个页面上找到的URL放到一个slice中
	Fetch(url string) (body string, urls []string, err error)
}

var vis = struct {
	m map[string]error
	sync.Mutex
}{m: make(map[string]error)}

var loading = errors.New("url load in progress")

// Crawl 使用fetcher从某个URL开始递归地爬取页面，直到达到最大深度
func Crawl(url string, depth int, fetcher Fetcher) {

	if depth <= 0 {

		return
	}

	vis.Lock()

	if _, ok := vis.m[url]; ok {
		vis.Unlock()
		return
	}
	vis.m[url] = loading
	vis.Unlock()

	body, urls, err := fetcher.Fetch(url)

	vis.Lock()
	vis.m[url] = err
	vis.Unlock()

	if err != nil {
		fmt.Printf("Error: url{%v} doesn't exist!\n", url)
		return
	}

	fmt.Printf("url{%s} -> body: %q\n", url, body)

	ch := make(chan bool) // 方便阻塞的时候用
	for _, u := range urls {
		go func(url string) {
			Crawl(url, depth-1, fetcher)
			ch <- true
		}(u)
	}

	for _ = range urls {
		<-ch // 阻塞到协程结束
	}
}

type fakeFetcher map[string]*fakeResult

type fakeResult struct {
	body string
	urls []string
}

func (f *fakeFetcher) Fetch(url string) (string, []string, error) {
	if res, ok := (*f)[url]; ok {
		return res.body, res.urls, nil
	}
	return "", nil, fmt.Errorf("not found: %s", url)
}

// fetcher 是填充后的fakeFetcher
var fetcher = &fakeFetcher{
	"https://golang.org/": &fakeResult{
		"The Go Programming Language",
		[]string{
			"https://golang.org/pkg/",
			"https://golang.org/cmd/",
		},
	},
	"https://golang.org/pkg/": &fakeResult{
		"Packages",
		[]string{
			"https://golang.org/",
			"https://golang.org/cmd/",
			"https://golang.org/pkg/fmt/",
			"https://golang.org/pkg/os/",
		},
	},
	"https://golang.org/pkg/fmt/": &fakeResult{
		"Package fmt",
		[]string{
			"https://golang.org/",
			"https://golang.org/pkg/",
		},
	},
	"https://golang.org/pkg/os/": &fakeResult{
		"Package os",
		[]string{
			"https://golang.org/",
			"https://golang.org/pkg/",
		},
	},
}

func TestMutexCase() {

	Crawl("https://golang.org/", 4, fetcher)
	// time.Sleep(100000)  // 主线程必须等到协程运行完结束，否则看不到结果，因为主线程结束，协程就不用运行了----已经通过channel优化
}

参考

闭包

闭包的本质源自两点，词法作用域和函数当作值传递。
词法作用域，就是，按照代码书写时的样子，内部函数可以访问函数外面的变量。引擎通过数据结构和算法表示一个函数，使得在代码解释执行时按照词法作用域的规则，可以访问外围的变量，这些变量就登记在相应的数据结构中。
函数当作值传递，即所谓的first class对象。就是可以把函数当作一个值来赋值，当作参数传给别的函数，也可以把函数当作一个值return。一个函数被当作值返回时，也就相当于返回了一个通道，这个通道可以访问这个函数词法作用域中的变量，即函数所需要的数据结构保存了下来，数据结构中的值在外层函数执行时创建，外层函数执行完毕时理因销毁，但由于内部函数作为值返回出去，这些值得以保存下来。而且无法直接访问，必须通过返回的函数。这也就是私有性。本来执行过程和词法作用域是封闭的，这种返回的函数就好比是一个虫洞，开了挂。显然，闭包的形成很简单，在执行过程完毕后，返回函数，或者将函数得以保留下来，即形成闭包。

参考

Example

package main

import "fmt"

func adder() func(int) int {
	sum := 0  // 局部变量
	return func(x int) int {
		sum += x // 使用了外部局部变量
		return sum
	}
}

func main() {
	pos, neg := adder(), adder()  // 函数闭包，封装了sum变量
	for i := 0; i < 10; i++ {
		fmt.Println(
			pos(i),
			neg(-2*i),
		)
	}
}

package main

import "fmt"

// 返回一个“返回int的函数”
func fibonacci() func() int {
	a, b := 0, 0
	return func() int {
		ans := a + b
		a = b
		b = ans
		if b == 0 {
			b = 1
		}
		return ans
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

``` 

# new和make区别

- new(T) 返回的是 T 的指针；
- make 只能用于 slice,map,channel，并且返回的是 T 的 引用

[参考：goland中new和make的区别](https://sanyuesha.com/2017/07/26/go-make-and-new/)

# 空接口

## 1. 什么是空接口？

空接口是特殊形式的接口类型，普通的接口都有方法，而空接口没有定义任何方法口，也因此，我们可以说所有类型都至少实现了空接口。
```go
type empty_iface interface {}

每一个接口都包含两个属性，一个是值，一个是类型。
而对于空接口来说，这两者都是 nil，可以使用 fmt 来验证一下

package main

import (
    "fmt"
)

func main() {
    var i interface{}
    fmt.Printf("type: %T, value: %v", i, i)
}

输出如下

1	type: <nil>, value: <nil>

2. 如何使用空接口？

第一，通常我们会直接使用interface{}作为类型声明一个实例，而这个实例可以承载任意类型的值。

package main

import (
    "fmt"
)

func main()  {
    // 声明一个空接口实例
    var i interface{}

    // 存 int 没有问题
    i = 1
    fmt.Println(i)

    // 存字符串也没有问题
    i = "hello"
    fmt.Println(i)

    // 存布尔值也没有问题
    i = false
    fmt.Println(i)
}

第二，如果想让你的函数可以接收任意类型的值，也可以使用空接口接收一个任意类型的值

package main

import (
    "fmt"
)

func myfunc(iface interface{}){
    fmt.Println(iface)
}

func main()  {
    a := 10
    b := "hello"
    c := true

    myfunc(a)
    myfunc(b)
    myfunc(c)
}

接收任意个任意类型的值

package main

import (
    "fmt"
)

func myfunc(ifaces ...interface{}){
    for _,iface := range ifaces{
        fmt.Println(iface)
    }
}

func main()  {
    a := 10
    b := "hello"
    c := true

    myfunc(a, b, c)
}

** 第三，你也定义一个可以接收任意类型的array、slice、map、strcut，例如这边定义一个切片

package main

import "fmt"

func main() {
    any := make([]interface{}, 5)
    any[0] = 11
    any[1] = "hello world"
    any[2] = []int{11, 22, 33, 44}
    for _, value := range any {
        fmt.Println(value)
    }
}

3. 空接口几个要注意的坑

坑1：空接口可以承载任意值，但不代表任意类型就可以承接空接口类型的值

从实现的角度看，任何类型的值都满足空接口。因此空接口类型可以保存任何值，也可以从空接口中取出原值。但要是你把一个空接口类型的对象，再赋值给一个固定类型（比如 int, string等类型）的对象赋值，是会报错的。

package main

func main() {
    // 声明a变量, 类型int, 初始值为1
    var a int = 1

    // 声明i变量, 类型为interface{}, 初始值为a, 此时i的值变为1
    var i interface{} = a

    // 声明b变量, 尝试赋值i
    var b int = i
}

这个报错，它就好比可以放进行礼箱的东西，肯定能放到集装箱里，但是反过来，能放到集装箱的东西就不一定能放到行礼箱了，在 Go 里就直接禁止了这种反向操作。（声明：底层原理肯定还另有其因，但对于新手来说，这样解释也许会容易理解一些。）

1	.\main.go:11:6: cannot use i (type interface {}) as type int in assignment: need type assertion

坑2：：当空接口承载数组和切片后，该对象无法再进行切片

package main

import "fmt"

func main() {
    sli := []int{2, 3, 5, 7, 11, 13}

    var i interface{}
    i = sli

    g := i[1:3]
    fmt.Println(g)
}

执行会报错。

1	.\main.go:11:8: cannot slice i (type interface {})

坑3：当你使用空接口来接收任意类型的参数时，它的静态类型是 interface{}，但动态类型（是int，string还是其他类型）我们并不知道，因此需要使用类型断言。

package main

import (
    "fmt"
)

func myfunc(i interface{})  {

    switch i.(type) {
    case int:
        fmt.Println("参数的类型是 int")
    case string:
        fmt.Println("参数的类型是 string")
    }
}

func main() {
    a := 10
    b := "hello"
    myfunc(a)
    myfunc(b)
}

输出如下

1 2	参数的类型是 int 参数的类型是 string

参考

Go的内存管理

Go 实现的垃圾回收器是无分代（对象没有代际之分）、不整理（回收过程中不对对象进行移动与整理）、并发（与用户代码并发执行）的三色标记清扫算法。从宏观的角度来看，Go 运行时的垃圾回收器主要包含五个阶段：

阶段	说明	赋值器状态
清扫终止	为下一个阶段的并发标记做准备工作，启动写屏障	STW
标记	与赋值器并发执行，写屏障处于开启状态	并发
标记终止	保证一个周期内标记任务完成，停止写屏障	STW
内存清扫	将需要回收的内存归还到堆中，写屏障处于关闭状态	并发
内存归还	将过多的内存归还给操作系统，写屏障处于关闭状态	并发

对象整理的优势是解决内存碎片问题以及“允许”使用顺序内存分配器。
但Go 运行时的分配算法基于 tcmalloc，基本上没有碎片问题。并且顺序内存分配器在多线程的场景下并不适用。
Go 使用的是基于tcmalloc的现代内存分配算法，对对象进行整理不会带来实质性的性能提升。

三色标记

三色抽象只是一种描述追踪式回收器的方法，在实践中并没有实际含义，它的重要作用在于从逻辑上严密推导标记清理这种垃圾回收方法的正确性。也就是说，当我们谈及三色标记法时，通常指标记清扫的垃圾回收。

从垃圾回收器的视角来看，三色抽象规定了三种不同类型的对象，并用不同的颜色相称：

白色对象（可能死亡）：未被回收器访问到的对象。在回收开始阶段，所有对象均为白色，当回收结束后，白色对象均不可达。
灰色对象（波面）：已被回收器访问到的对象，但回收器需要对其中的一个或多个指针进行扫描，因为他们可能还指向白色对象。
黑色对象（确定存活）：已被回收器访问到的对象，其中所有字段都已被扫描，黑色对象中任何一个指针都不可能直接指向白色对象。

title

波面

这样三种不变性所定义的回收过程其实是一个波面不断前进的过程，这个波面同时也是黑色对象和白色对象的边界，灰色对象就是这个波面。

当垃圾回收开始时，只有白色对象。随着标记过程开始进行时，灰色对象开始出现（着色），这时候波面便开始扩大。当一个对象的所有子节点均完成扫描时，会被着色为黑色。当整个堆遍历完成时，只剩下黑色和白色对象，这时的黑色对象为可达对象，即存活；而白色对象为不可达对象，即死亡。这个过程可以视为以灰色对象为波面，将黑色对象和白色对象分离，使波面不断向前推进，直到所有可达的灰色对象都变为黑色对象为止的过程。

根对象

根对象在垃圾回收的术语中又叫做根集合，它是垃圾回收器在标记过程时最先检查的对象，包括：

全局变量：程序在编译期就能确定的那些存在于程序整个生命周期的变量。
执行栈：每个 goroutine都包含自己的执行栈，这些执行栈上包含栈上的变量及指向分配的堆内存区块的指针。
寄存器：寄存器的值可能表示一个指针，参与计算的这些指针可能指向某些赋值器分配的堆内存区块。

参考：Go垃圾回收的基本想法
 参考：GC的认识

Go面向对象（封装/多态/继承）

封装：首字母大小写为区分，大写的暴露出来，小写的只在package内部用；
继承：一个struct可以包含另外一个struct，同时拥有了它的methods以及属性；
多态：即接口的使用，注意不是struct，struct必须是相等的，与Java类似。

Example

1.多态

/* 多态行为的例子 */
package main

import "fmt"

type notifer interface {
   notify()
}

type user struct {
   name string
   email string
}

type admin struct {
   name string
   age  int
}

type ad struct {
   name string
   age  int
}

//使用指针接收者实现了notofy接口,方法会共享接收者所指向的值user
func (u *user) notify()  {
   fmt.Println("sendNotify to user", u.name)
}

//使用值接收者实现了notofy接口,方法使用u值的副本,对u的修改不会影响原值
func (u admin) notify(){
   fmt.Println("sendNotify to admin:", u.name)
}

//接收一个notifer接口类型的值，如果一个实体类型实现了该接口，
//sendNotify函数会根据实体类型的值类执行notifer接口的notify行为，这个函数具有多态的能力。
func sendNotify(n notifer){
   n.notify()
}

func main()  {
   user1 := user{"张三", "qq@qq.com"}
   sendNotify(&user1)

   user2 := admin{"李四", 25}
   sendNotify(user2)

   var n notifer
   n = &user1
   n.notify()
}

2.继承

package main
import "fmt"

type person struct {
   name string
   age int
}

//如果一个struct嵌入另一个匿名结构体，就可以直接访问匿名结构体的字段或方法，从而实现继承
type student struct {
   person //匿名字段
   number string
}

//如果一个struct嵌套了另一个【有名】的结构体，叫做组合
type teacher struct {
   p person   //有名字段
   mobile string
}

func (p *person) run(){
   fmt.Println(p.name, " person run")
}

func (s *student) reading(){
   fmt.Println(s.name, " student reading")
}

func main(){

   s := student{person{"lisi", 20}, "000"}
   fmt.Println(s.name)    //访问结构体的【匿名】字段，student对象没有name字段，访问的是从person继承过来的name字段
   s.run()  //访问结构体的【匿名】字段实现的方法，虽然student对象没有实现run方法，但student继承了person，person类型实现的方法能被直接访问

   t := teacher{person{"wangwu", 25}, "111"}
   fmt.Println(t.p.name) //访问【有名】结构体的字段。不是继承，不能被直接访问，需要指定结构体
   t.p.run()
}

参考1
参考2

select-case语法

select 语句的语法：

每个 case 都必须是一个通信
所有 channel 表达式都会被求值
所有被发送的表达式都会被求值
如果任意某个通信可以进行，它就执行，其他被忽略。
如果有多个 case都可以运行，Select会随机公平地选出一个执行。其他不会执行。
否则：
- 如果有 default 子句，则执行该语句。
- 如果没有 default子句，select将阻塞，直到某个通信可以运行；Go 不会重新对 channel 或值进行求值。

time.After(dutation)

调用time.After(duration)，此函数马上返回，返回一个time.Time类型的Chan(type: <- chan time.Time只读)，不阻塞。
后面你该做什么做什么，不影响。到了duration时间后，自动塞一个当前时间进去。

channel通道

有/无缓冲通道，根据缓冲区大小进行阻塞；
默认是阻塞的；
可以是只读、只写、同时可读写的；
常用作goroutine的通信/同步。

//定义只读的channel
read_only := make (<-chan int)

//定义只写的channel
write_only := make (chan<- int)

//可同时读写
read_write := make (chan int)

定义只读和只写的channel意义不大，一般用于在参数传递中，见代码：

package main

import (
    "fmt"
    "time"
)

func main() {
    c := make(chan int)
    go send(c)
    go recv(c)
    time.Sleep(3 * time.Second)
}
//只能向chan里写数据
func send(c chan<- int) {
    for i := 0; i < 10; i++ {
        c <- i
    }
}
//只能取channel中的数据
func recv(c <-chan int) {
    for i := range c {
        fmt.Println(i)
    }
}

参考1
参考2

iota关键字

关键字 iota 在常量声明区里有特殊的作用。
这个关键字让编译器为每个常量复制相同的表达式，直到声明区结束，或者遇到一个新的赋值语句。
关键字 iota 的另一个功能是，iota 的初始值为 0，之后 iota 的值在每次处理为常量后，都会自增 1。

log包

log 包有一个很方便的地方就是，这些日志记录器是多 goroutine 安全的；
这意味着在多个 goroutine可以同时调用来自同一个日志记录器的这些函数，而不会有彼此间的写冲突；
标准日志记录器具有这一性质，用户定制的日志记录器也应该满足这一性质。

单元测试

单元测试时用来测试包或者程序的一部分代码或者一组代码的函数。测试的目的是确认目标代码在给定的场景下，有没有按照期望工作。

正向路径测试：就是在正常执行的情况下，保证代码不产生错误的测试；
负向路径测试：保证代码不仅会产生错误，而且是预期的错误。

Go mod 测试命令

go test -v [xxx_test.go]
-v表示输出详细内容

基础测试（basic test）

测试函数必须以Test单词开头，而且必须接受一个指向testing.T类型的指针，并且不返回任何值;
否则，测试框架就不会认为这个函数是一个测试函数。

package unitTestSyntax

import (
	"net/http"
	"testing"
)

const checkMark = "\u2713" // ✅
const ballotX = "\u2717"   // ❎

// TestDownload 确认http包的Get函数可以下载内容
func TestDownload(t *testing.T) { // 测试函数必须以Test单词开头，而且必须接受一个指向testing.T类型的指针，并且不返回任何值。否则，测试框架就不会认为这个函数是一个测试函数。
	url := "http://www.goingo.net/feeds/posts/default?alt=rss"
	statusCode := 200

	t.Log("Given the need to test downloading content.")
	{
		t.Logf("\tWhen checking \"%s\" for status code \"%d\"",
			url, statusCode)
		{
			resp, err := http.Get(url)
			if err != nil {
				t.Fatal("\t\tShould be able to make the Get call.",
					ballotX, err)
			}
			t.Log("\t\tShould be able to make the Get Call.",
				checkMark)
			defer resp.Body.Close()

			if resp.StatusCode == statusCode {
				t.Logf("\t\tShould receive a \"%d\"  status. %v",
					statusCode, checkMark)
			} else {
				t.Errorf("\t\tShould receive a \"%d\" status. %v %v",
					statusCode, ballotX, resp.StatusCode)
			}
		}
	}
}

=== RUN   TestDownloadByUnitTest
    basicUnit_test.go:16: Given the need to test downloading content.
    basicUnit_test.go:18:       When checking "https://www.goinggo.net/feeds/posts/default?alt=rss" for status code "200"
    basicUnit_test.go:23:               Should be able to make the Get call. ✗ Get "https://www.ardanlabs.com/blog/feeds/posts/default?alt=rss": EOF
--- FAIL: TestDownloadByUnitTest (6.75s)

表组测试（table test）

package unitTestSyntax

import (
	"net/http"
	"testing"
)

const checkMark = "\u2713" // ✅
const ballotX = "\u2717"   // ❎

// TestDownloadByTableTest 确认http包的Get函数可以下载内容并正确处理不同的状态
func TestDownloadByTableTest(t *testing.T) {
	var urls = []struct {
		url        string
		statusCode int
	}{
		{
			"https://www.goinggo.net/feeds/posts/default?alt=rss",
			http.StatusOK,
		},
		{
			"https://rss.cnn.com/rss/cnn_topstbadurl.rss",
			http.StatusNotFound,
		},
	}

	t.Log("Given the need to test downloading different content.")
	{
		for _, u := range urls {
			t.Logf("\tWhen checking \"%s\" for status code \"%d\"",
				u.url, u.statusCode)
			{
				resp, err := http.Get(u.url)
				if err != nil {
					t.Fatal("\t\tShould be able to Get the url.",
						ballotX, err)
				}
				t.Log("\t\tShould be able to Get the url",
					checkMark)

				defer resp.Body.Close()

				if resp.StatusCode == u.statusCode {
					t.Logf("\t\tShould have a \"%d\" status. %v",
						u.statusCode, checkMark)
				} else {
					t.Errorf("\t\tShould have a \"%d\" status %v %v",
						u.statusCode, ballotX, resp.StatusCode)
				}
			}
		}
	}
}

=== RUN   TestDownloadByTableTest
    table_test.go:27: Given the need to test downloading different content.
    table_test.go:30:   When checking "https://www.goinggo.net/feeds/posts/default?alt=rss" for status code "200"
    table_test.go:35:           Should be able to Get the url. ✗ Get "https://www.goinggo.net/feeds/posts/default?alt=rss": unexpected EOF
--- FAIL: TestDownloadByTableTest (9.41s)
FAIL
exit status 1
FAIL    GolangProjects/unitTestSyntax   16.735s

模拟调用（Mock）

package unitTestSyntax

import (
	"fmt"
	"net/http"
	"net/http/httptest"
	"testing"
)

const checkMark = "\u2713" // ✅
const ballotX = "\u2717"   // ❎

// feed 模仿了我们期望接收的XML文档
var feed = `<?xml version="1.0" encoding="UTF-8"?>
<rss>
<channel>
	<title>Going Go Programming</title>
	<description>Golang : https://github.com/goinggo</description>
	<link>https://www.goinggo.net</link>
	<item>
		<pubDate>Sun, 15 Mar 2015 15:04:00 ++0000</pubDate>
		<title>Object Oriented Programming Mechanics</title>
		<description>Go is an object oriented language.</description>
		<link>https://www.goinggo.net/2015/03/object-oriented</link>
	</item>
</channel>
</rss>
`

// mockServer 返回用来处理请求的服务器的指针
func mockServer() *httptest.Server {
	f := func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(200)
		w.Header().Set("Content-Type", "application/xml")
		fmt.Fprintln(w, feed)
	}
	// HandlerFunc类型是一个适配器，允许常规函数作为HTTP的处理函数使用；
	// 如果函数f具有合适的签名，HandlerFunc(f)就是一个处理HTTP请求的Handler对象，内部通过调用f处理请求
	return httptest.NewServer(http.HandlerFunc(f))
}

// TestDownloadByMock 确认http包的Get函数可以下载内容并且内容可以被正确地反序列化并关闭
func TestDownloadByMock(t *testing.T) {
	statusCode := http.StatusOK

	server := mockServer()
	defer server.Close()

	t.Log("Given the need to test downloading content.")
	{
		t.Logf("\tWhen checking \"%s\" for status code \"%d\"",
			server.URL, statusCode)
		{
			resp, err := http.Get(server.URL)
			if err != nil {
				t.Fatal("\t\tShould be able to make the Get call.",
					ballotX, err)
			}
			t.Log("\t\tShould be able to make the Get call.",
				checkMark)
			defer resp.Body.Close()

			if resp.StatusCode != statusCode {
				t.Fatalf("\t\tShould receive a \"%d\" status. %v %v",
					statusCode, ballotX, resp.StatusCode)
			}
			t.Logf("\t\tShould receive a \"%d\" status. %v",
				statusCode, checkMark)
		}
	}
}

=== RUN   TestDownloadByMock
    mock_test.go:49: Given the need to test downloading content.
    mock_test.go:51:    When checking "http://127.0.0.1:58912" for status code "200"
    mock_test.go:59:            Should be able to make the Get call. ✓
    mock_test.go:67:            Should receive a "200" status. ✓
--- PASS: TestDownloadByMock (0.01s)

服务端点测试

服务端点(endpoint)是指与服务宿主信息无关，用来分辨某个服务的地址，一般是不包含宿主的一个路径。
如果在构造网络API，你会希望直接测试自己的服务的所有服务端点，而不用启动整个网络服务。
包 httptest 正好提供了做到这一点的机制。

package handlers

import (
	"encoding/json"
	"log"
	"net/http"
)

// Routes set the routes for the web service.
func Routes() {
	http.HandleFunc("/sendjson", SendJSON)
}

// SendJSON returns a simple JSON document.
func SendJSON(rw http.ResponseWriter, r *http.Request) {
	u := struct {
		Name  string
		Email string
	}{
		Name:  "Bill",
		Email: "bill@ardanstudios.com",
	}

	rw.Header().Set("Content-Type", "application/json")
	rw.WriteHeader(200)
	json.NewEncoder(rw).Encode(&u)
}

func TestHandler() {
	Routes()

	port := "10000" // 端口可能被占用
	log.Printf("listener : Started : Listening on :%v", port)
	log.Printf("Please use your browser: localhost:%v/sendjson", port)

	err := http.ListenAndServe(":"+port, nil)
	if err != nil {
		log.Fatalln(err)
	}
}

package unitTestSyntax

import (
	"GolangProjects/handlers"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"
)

const checkMark = "\u2713" // ✅
const ballotX = "\u2717"   // ❎

func init() {
	handlers.Routes()
}

// TestSendJSON 测试/sendjson内部服务端点
func TestSendJSON(t *testing.T) {
	t.Log("Given the need to test the SendJSON endpoint.")
	{
		req, err := http.NewRequest("GET", "/sendjson", nil)
		if err != nil {
			t.Fatal("\tShould be able to create a request.",
				ballotX, err)
		}
		t.Log("\tShould be able to create a request.",
			checkMark)

		rw := httptest.NewRecorder()
		http.DefaultServeMux.ServeHTTP(rw, req)

		if rw.Code != 200 {
			t.Fatal("\tShould receive \"200\"", ballotX, rw.Code)
		}
		t.Log("\tShould receive \"200\"", checkMark)

		u := struct {
			Name  string
			Email string
		}{}

		if err := json.NewDecoder(rw.Body).Decode(&u); err != nil {
			t.Fatal("\tShould decode the response.", ballotX)
		}
		t.Log("\tShould decode the response.", checkMark)

		if u.Name == "Bill" {
			t.Log("\tShould have a Name.", checkMark)
		} else {
			t.Error("\tShould have a Name.", ballotX, u.Name)
		}

		if u.Email == "bill@ardanstudios.com" {
			t.Log("\tShould have an Email.", checkMark)
		} else {
			t.Error("\tShould have an Email.", ballotX, u.Email)
		}
	}
}

=== RUN   TestSendJSON
    sendJSON_test.go:20: Given the need to test the SendJSON endpoint.
    sendJSON_test.go:27:        Should be able to create a request. ✓
    sendJSON_test.go:36:        Should receive "200" ✓
    sendJSON_test.go:46:        Should decode the response. ✓
    sendJSON_test.go:49:        Should have a Name. ✓
    sendJSON_test.go:55:        Should have an Email. ✓
--- PASS: TestSendJSON (0.00s)

Doc示例

package handlers_test

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"net/http/httptest"
)

// ExampleSendJSON 提供了基础示例
func ExampleSendJSON() {
	r, _ := http.NewRequest("GET", "/sendjson", nil)
	rw := httptest.NewRecorder()
	http.DefaultServeMux.ServeHTTP(rw, r)
	var u struct {
		Name  string
		Email string
	}

	if err := json.NewDecoder(rw.Body).Decode(&u); err != nil {
		log.Println("ERROR:", err)
	}

	// 使用fmt将结果写到stdout来检测输出
	fmt.Println(u)
	// Output:
	// {Bill bill@ardanstudios.com}
}

godoc -http=:6060可以看到示例Example
go test -v -run="ExampleSendJSON

基准测试

基准测试是一种测试代码性能的方法。想要测试解决同一问题的不同方案的性能，以及查看哪种解决方案的性能更好时，基准测试就会很有用。
基准测试也可以用来识别某段代码的CPU或者内存效率问题，而这段代码的效率可能会严重影响整个应用程序的性能。
许多开发人员会用基准测试来测试不同的并发模式，或者用基准测试来辅助配置工作池的数量，以保证能最大化系统的吞吐量。

单组测试

package unitTestSyntax

import (
	"fmt"
	"testing"
)

// BenchmarkSprintf 对fmt.Sprintf进行基准测试
func BenchmarkSprintf(b *testing.B) {
	number := 10

	b.ResetTimer()

	for i := 0; i < b.N; i++ { // 每执行一次，b.N都会增加，而且是
		str := fmt.Sprintf("%d", number)
		fmt.Println(str)
	}
}

go test -v -run="none" -bench="BenchmarkSprintf" 默认最少持续测试1秒
go test -v -run="none" -bench="BenchmarkSprintf" -benchtime="3s" 持续测试3秒
-run="none" 用于匹配弄开头的单元测试，这里是为了过滤所有的单元测试

多组测试

package unitTestSyntax

import (
	"fmt"
	"strconv"
	"testing"
)

// BenchmarkSprintf 对fmt.Sprintf进行基准测试
func BenchmarkSprintf(b *testing.B) {
	number := 10

	// 开始循环之前需要进行初始化，这个方法用来重置计时器，
	// 保证测试代码执行前的初始化代码不会干扰计时器的结果
	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		_ = fmt.Sprintf("%d", number)
	}
}

// BenchmarkFormat 对strconv.FormatInt函数进行基准测试
func BenchmarkFormat(b *testing.B) {
	number := int64(10)

	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		strconv.FormatInt(number, 10)
	}
}

// BenchmarkItoa 对strconv.Itoa函数进行基准测试
func BenchmarkItoa(b *testing.B) {
	number := 10

	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		strconv.Itoa(number)
	}
}

go test -v -run="none" -bench=. -benchtime="3s":

goos: darwin
goarch: amd64
pkg: GolangProjects/unitTestSyntax
cpu: VirtualApple @ 2.50GHz
BenchmarkSprintf
BenchmarkSprintf-8      46060076                78.40 ns/op
BenchmarkFormat
BenchmarkFormat-8       1000000000               2.838 ns/op
BenchmarkItoa
BenchmarkItoa-8         1000000000               2.846 ns/op
PASS
ok      GolangProjects/unitTestSyntax   10.518s

go test -v -run="none" -bench=. -benchtime="3s" -benchmem:

goos: darwin
goarch: amd64
pkg: GolangProjects/unitTestSyntax
cpu: VirtualApple @ 2.50GHz
BenchmarkSprintf
BenchmarkSprintf-8      44524904                78.66 ns/op            2 B/op          1 allocs/op
BenchmarkFormat
BenchmarkFormat-8       1000000000               2.839 ns/op           0 B/op          0 allocs/op
BenchmarkItoa
BenchmarkItoa-8         1000000000               2.900 ns/op           0 B/op          0 allocs/op
PASS
ok      GolangProjects/unitTestSyntax   10.207s

Go与C++/Java/Python的区别

Go没有类，可以给结构体定义方法；
Go没有继承，转而通过结构体的组合方式实现相应逻辑，也就是has-a的关系，而不是继承的is-a的关系；
Go的多态通过接口实现，实现接口只要结构体定义了接口对应的方法就行；
重写覆盖也类似于其他面向对象的语言；
Go有自动垃圾回收方式，不需要C++那种手动释放，文件/tcp连接/数据库句柄等除外；
case语句自带break；

Go 反射

https://ehlxr.me/2018/01/26/golang-reflect/