Go 语言从入门到实战

蔚落 2023-09-24 15:47 145阅读 0赞

> [《Go 语言从入门到实战》][Go] 的学习笔记，欢迎阅读斧正。感觉该专栏整体来说对有些后端编程经验的来说比无后端编程经验的人更友好。

## 数据类型 ##

## 运算符 ##

### 算数运算符 ###

![在这里插入图片描述][5c8002901b204fe0ae400ea89e386667.png]

### 比较运算符 ###

![在这里插入图片描述][2d3378675a7f4ae7a17a7b3ea7d5e9c8.png]

#### 用 == 比较数组 ####

相同维数切含有相同个数元素的数组才可以比较，每个元素都相同的才相等。

import "testing"
    
    // 相同维数切含有相同个数元素的数组才可以比较，每个元素都相同的才相等。
    func TestCompareArray(t *testing.T) {
        
    	a := [...]int{
        1, 2, 3, 4}
    	b := [...]int{
        1, 3, 4, 5}
    	//c := [...]int{1, 2, 3, 4, 5}
    	d := [...]int{
        1, 2, 3, 4}
    	e := [...]int{
        1, 4, 3, 5}
    
    	// 输出 false
    	t.Log(a == b)
    	// 长度不同的两个数组，比较会得到一个编译错误
    	//t.Log(a == c)
    	// 输出 true
    	t.Log(a == d)
    	// 输出 false
    	t.Log(b == e)
    }

### 逻辑运算符 ###

![在这里插入图片描述][0a4b7cde50ec4864864cdab3995dd998.png]

### 位运算符 ###

#### 按位清零运算符 ####

![在这里插入图片描述][abb1d2ba34894208b727dec8dc277961.png]

import "testing"
    
    const (
    	Readable = 1 << iota
    	Writable
    	Executable
    )
    
    // 按位清零运算符
    func TestBitClear(t *testing.T) {
        
    	a := 7 // 0111
    	// true true true
    	t.Log(a&Readable == Readable, a&Writable == Writable, a&Executable == Executable)
    	a = a &^ Readable
    	// 6
    	t.Log(a &^ Readable)
    	// false true true
    	t.Log(a&Readable == Readable, a&Writable == Writable, a&Executable == Executable)
    }

## 循环 ##

Go 语言只支持循环关键字 `for`

### While条件循环 ###

### 无限循环 ###

## 条件 ##

### if 条件 ###

![在这里插入图片描述][30eb9ce212804c83a408c9118aa16d22.png]

与其他语言差异：

1.  condition 表达式结果必须是布尔值
2.  支持变量赋值

if var declaration; condition{
        
    //do something

### switch 条件 ###

![在这里插入图片描述][3e9aabe134874219a278412b7a50ad2a.png]

与其他语言差异：

1.  条件表达式不限制为常量或者整数；
2.  单个 case 中，可以出现多个结果选项，使用逗号分隔；
3.  与C语言等规则相反，Go语言不需要用 break 来明确退出一个 case；
4.  可以不设定 switch 之后的条件表达式，在此种情况下，整个 switch 结构与多个 if…else… 的逻辑作用等同

## 数组和切片 ##

### 数组 ###

#### 声明 ####

![在这里插入图片描述][6b149c252f8b41f299dc23db6678655e.png]

#### 遍历 ####

![在这里插入图片描述][d463468b3b3641c0ab461a6ab99f1706.png]

#### 截取 ####

![在这里插入图片描述][aebd2e15821745cba0f2f2ee8632586d.png]

### 切片 ###

#### 声明 ####

![在这里插入图片描述][a1b5f41043cb4a4da6f886578c9389c7.png]

#### 内部结构 ####

![在这里插入图片描述][555fc8a14dc54ebdbf51a90bdceee07e.png]

注意：切片不可以比较

## Map ##

### 声明 ###

![在这里插入图片描述][b8cde465a1db42a29edf3f821ef0430c.png]

访问的 key 不存在时，仍会返回 0 值，不能通过返回 nil 来判断元素是否存在（int 类型，默认是 0，如果换成 string 类型，默认就是空字符串了）

### Map 与工厂 ###

![在这里插入图片描述][2ccd57dfe6d046e09ae01fcad9c254b7.png]

import (
    	"testing"
    )
    
    func TestMapWithFunValue(t *testing.T) {
        
    	m := map[int]func(op int) int{
        }
    	m[1] = func(op int) int {
         return op }
    
    	m[2] = func(op int) int {
         return op * op }
    	m[3] = func(op int) int {
         return op * op * op }
    	// 输出 2 4 8
    	t.Log(m[1](2), m[2](2), m[3](2))
    
    }

### 实现 set ###

![在这里插入图片描述][ea061e8a4c974ead95c83bed2e22a84b.png]

## 字符串 ##

与其他语言差别：

1.  string 是数据类型，不是引用或指针类型
2.  string 是只读的 byte slice，len() 函数可以它所包含的 byte 数
3.  string 的 byte 数组可以存放任何数据

## 函数 ##

1.  可以有多个返回值
2.  所有参数都是值传递
3.  函数可以作为变量的vi
4.  函数可以作为参数和返回值

> 这个需要好好看看，好像还有闭包之类的知识

// 延时一秒后返回入参
    func SlowFun(op int) int {
        
    	time.Sleep(time.Second * 1)
    	return op
    }
    
    // 定义一个函数timeSpent帮助记录入参函数的执行耗时
    //
    //	入参是一个函数,               返回也是一个函数
    func timeSpent(入参函数名 func(op int) int) func(op int) int {
        
    	return func(返回函数的参数 int) int {
        
    		start := time.Now()
    		ret := 入参函数名(返回函数的参数) // 执行有入参的该函数
    		fmt.Println("该入参函数执行结果：", ret)
    		fmt.Println("时间损耗:", time.Since(start).Seconds())
    		return ret
    	}
    }
    
    func TestFn1(t *testing.T) {
        
    	// 给timeSpent入参一个函数, 我们返回一个函数, 这个函数执行这个入参函数并打印该的执行时间
    	// tsSF 得到的就是返回的函数，我们给这个函数提供一个 「返回函数的参数」-> 10
    	tsSF := timeSpent(SlowFun)
    	// 打印执行
    	t.Log(tsSF(10))
    }

### 可变参数 ###

![在这里插入图片描述][8a2c2965fdd84b83ae8f63814df2d7a7.png]

### defer 函数 ###

延迟执行函数，可以当做 Java 中的 try…catch…finally 使用  
![在这里插入图片描述][1dbbb70100434a34a0ffa06b1da67c8c.png]

## 面向对象 ##

![在这里插入图片描述][cec23982bf2b4b31b0bae92d49c0b48a.png]

### 封装数据和行为 ###

#### 结构体定义 ####

![在这里插入图片描述][c45de99d5df54df388a006ca399d48a0.png]

#### 初始化 ####

![在这里插入图片描述][85a1106bb34d4a9e90d1202a977fa2da.png]

#### 行为/方法定义 ####

![在这里插入图片描述][e2febae12fd746899577ad4ef67f714b.png]

### 接口 ###

#### 定义 ####

type Programmer interface {
        
    	WriteHelloWorld() Code
    }

#### 实现 ####

type GoProgrammer struct {
        
    }
    func (p *GoProgrammer) WriteHelloWorld() Code {
        
    	return "fmt.Println(\"Hello World!\")"
    }

#### 接口变量 ####

![在这里插入图片描述][8cc7c872751a4e0f80f4780d6e62557f.png]

#### 自定义类型 ####

`type IntConv func(op int) int` 注意 `func`

### 复合 ###

Go 不支持继承，但是可以通过复合的方式来复用

### 匿名类型嵌入 ###

import (
    	"fmt"
    	"testing"
    )
    
    type Pet struct {
        
    }
    
    func (p *Pet) Speak() {
        
    	fmt.Print("...")
    }
    
    func (p *Pet) SpeakTo(host string) {
        
    	p.Speak()
    	fmt.Println("\n", host)
    }
    
    type Dog struct {
        
    	//p *Pet
    	Pet // 内嵌的结构类型没法当继承来使用
    }

不是继承，如果把内部的 struct 看做父类，外部的 struct 看成子类，会发现以下问题：

1.  不支持子类替换
2.  子类并不是继承了父类的方法
3.  父类的定义的方法无法访问子类的数据和方法

### 多态 ###

代码：

import (
    	"fmt"
    	"testing"
    )
    
    type Code string
    type Programmer interface {
        
    	WriteHelloWorld() Code
    }
    
    type GoProgrammer struct {
        
    }
    
    func (p *GoProgrammer) WriteHelloWorld() Code {
        
    	return "fmt.Println(\"Hello World!\")"
    }
    
    type JavaProgrammer struct {
        
    }
    
    func (p *JavaProgrammer) WriteHelloWorld() Code {
        
    	return "System.out.Println(\"Hello World!\")"
    }
    
    // interface 作为入参，必须是指针实例
    func writeFirstProgram(p Programmer) {
        
    	fmt.Printf("%T %v\n", p, p.WriteHelloWorld())
    }
    
    func TestPolymorphism(t *testing.T) {
        
    	goProg := &GoProgrammer{
        }// 注意 &,取地址或者理解为指针
    	javaProg := new(JavaProgrammer)
    	writeFirstProgram(goProg)
    	writeFirstProgram(javaProg)
    }

### 空接口 ###

1.  空接口可以表示任何类型（可以理解为 Java 中的 Object）
2.  通过断言来将空接口转换为指定类型`v, ok := p.(int) // ok = true 时转换成功`

import (
    	"fmt"
    	"testing"
    )
    
    // 空接口可以代表任何类型
    func DoSomething(p interface{
        }) {
        
    	// if 版本：
    	//if i, ok := p.(int); ok {
        
    	//	fmt.Println("Integer", i)
    	//	return
    	//}
    	//if i, ok := p.(string); ok {
        
    	//	fmt.Println("string", i)
    	//	return
    	//}
    	//fmt.Println("Unknown Type")
    
    	// switch 版本：
    	switch v := p.(type) {
        
    	case int:
    		fmt.Println("Integer", v)
    	case string:
    		fmt.Println("string", v)
    	default:
    		fmt.Println("Unknown Type")
    	}
    }
    
    func TestEmptyInterfaceAssertion(t *testing.T) {
        
    	DoSomething(1)
    	DoSomething("test")
    	DoSomething(true)
    }

### 接口使用原则 ###

![在这里插入图片描述][f05440d9d9ac491187cbbcef1c38e135.png]  
第一行可以理解为 [单一职责][Link 1]，第三行可以理解为 [接口隔离原则][Link 2]

## 错误机制 ##

1.  没有异常机制
2.  error 类型实现了 error 接口
3.  可以通过 errors.New 来快速创建错误实例`errors.New("it's a arrer`

### 实践 ###

#### 定义不同的错误变量，以便于判断错误类型 ####

![在这里插入图片描述][f4e0647340574aff84980dfa4f72bb5b.png]

#### 及早失败，避免嵌套 ####

感觉类似于 卫语句

func GetFibonacci1(str string) {
        
    	var (
    		i    int
    		err  error
    		list []int
    	)
    	if i, err = strconv.Atoi(str); err == nil {
        
    		if list, err = GetFibonacci(i); err == nil {
        
    			fmt.Println(list)
    		} else {
        
    			fmt.Println("Error", err)
    		}
    	} else {
        
    		fmt.Println("Error", err)
    	}
    }
    
    // GetFibonacci2 相对于 GetFibonacci1 来说，避免了错误嵌套，感觉类似 Java 中卫语句？
    func GetFibonacci2(str string) {
        
    	var (
    		i    int
    		err  error
    		list []int
    	)
    	if i, err = strconv.Atoi(str); err != nil {
        
    		fmt.Println("Error", err)
    		return
    	}
    	if list, err = GetFibonacci(i); err != nil {
        
    
    		fmt.Println("Error", err)
    		return
    	}
    	fmt.Println(list)
    
    }

### panic ###

1.  panic 用于不可以恢复的错误
2.  panic 退出前会执行 defer 指定的内容

#### panic vs os.Exit ####

后者不会调用 `defer` 执行的函数，后者退出时不输出当前调用栈信息

### recover ###

错误恢复代码，类似于 Java 中的 `try...catch...` 中的 catch

import (
    	"errors"
    	"fmt"
    	"testing"
    )
    
    func TestPanicVxExit(t *testing.T) {
        
    
    	defer func() {
        
    		if err := recover(); err != nil {
        
    			fmt.Println("recovered from ", err)
    		}
    	}()
    	fmt.Println("Start")
    	panic(errors.New("Something wrong!"))
    }
    
    // 输出：
    // Start
    // recovered from  Something wrong!
    // --- PASS: TestPanicVxExit (0.00s)

使用的时候不能随便 recover，不要随便捕获异常，该抛错误的就抛错误，要不不知道什么错。

## package ##

1.  基本的复用模块单元（另外，**首字母大写表明可被包外代码访问**）
2.  代码的 package 可以和所在目录不一致
3.  同一目录里的 Go 代码的 package 要保持一致

## init 方法 ##

1.  在 main 被执行前，所有依赖的 package 的 init 方法都会被执行
2.  不同包的 init 函数按照包导入的依赖关系决定执行顺序
3.  每个包可以有多个 init 函数
4.  包的每个源文件也可以有多个 init 函数，这点比较特殊

## 测试 ##

### 单元测试 ###

#### 内置单元测试框架 ####

*  Fail，Error：该测试失败，该测试继续，其他测试继续执行
 *  FailNow，Fatal：该测试失败，该测试中止，其他测试继续执行
 *  代码覆盖率：go test-v-cover
 *  断言：https://github.com/stretchr/testify

import (
    	"fmt"
    	"github.com/stretchr/testify/assert"
    	"testing"
    )
    
    func TestSquare(t *testing.T) {
        
    	inputs := [...]int{
        1, 2, 3}
    	expected := [...]int{
        1, 4, 9}
    	for i := 0; i < len(inputs); i++ {
        
    		ret := square(inputs[i])
    		if ret != expected[i] {
        
    			t.Errorf("input is %d, the expected is %d, the actual %d",
    				inputs[i], expected[i], ret)
    		}
    	}
    }
    
    func TestErrorInCode(t *testing.T) {
        
    	fmt.Println("Start")
    	t.Error("Error")
    	fmt.Println("End")
    }
    
    func TestFailInCode(t *testing.T) {
        
    	fmt.Println("Start")
    	t.Fatal("Error")
    	fmt.Println("End")
    }
    
    func TestSquareWithAssert(t *testing.T) {
        
    	inputs := [...]int{
        1, 2, 3}
    	expected := [...]int{
        1, 4, 9}
    	for i := 0; i < len(inputs); i++ {
        
    		ret := square(inputs[i])
    		assert.Equal(t, expected[i], ret)
    	}
    }

### Benchmark ###

![在这里插入图片描述][8997e2976a5745889ae0066585ea95f7.png]  
相关命令（非 Windows 把双引号去掉）：

1.  go test -bench=“.”
2.  go test -bench=“.” -benchmem

### BDD ###

Behavior Driven Development，让业务领域的专家参与开发。  
![在这里插入图片描述][ddfafe1c7028475cbd6c6905588a6683.png]

> 感觉理解起来就是写清需求……

#### BDD In Go ####

项目网站：[https://github.com/smartystreets/goconvey][https_github.com_smartystreets_goconvey]

安装：go get -u github.com/smartystreets/goconvey/convey

启动 UI：$GOPATH/bin/goconvey

## 不安全编程 ##

理解的 Go 的不安全编程是指用到了 unsafe 包中的指针：[使用"不安全编程"帮你绕过 Go 语言中的类型检测系统][Go 1]

> 合理的类型转换以及原子操作不算不安全编程

import (
    	"fmt"
    	"sync"
    	"sync/atomic"
    	"testing"
    	"time"
    	"unsafe"
    )
    
    type Customer struct {
        
    	Name string
    	Age  int
    }
    
    // 理解的 Go 的不安全编程是指用到了 unsafe 包中的内容：https://www.cnblogs.com/traditional/p/11890639.html
    func TestUnsafe(t *testing.T) {
        
    	i := 10
    	f := *(*float64)(unsafe.Pointer(&i))
    	t.Log(unsafe.Pointer(&i))
    	t.Log(f)
    }
    
    // The cases is suitable for unsafe
    type MyInt int
    
    // 合理的类型转换
    func TestConvert(t *testing.T) {
        
    	a := []int{
        1, 2, 3, 4}
    	b := *(*[]MyInt)(unsafe.Pointer(&a))
    	t.Log(b)
    }
    
    // 原子类型操作
    func TestAtomic(t *testing.T) {
        
    	var shareBufPtr unsafe.Pointer
    	writeDataFn := func() {
        
    		data := []int{
        }
    		for i := 0; i < 100; i++ {
        
    			data = append(data, i)
    		}
    		atomic.StorePointer(&shareBufPtr, unsafe.Pointer(&data))
    	}
    	readDataFn := func() {
        
    		data := atomic.LoadPointer(&shareBufPtr)
    		fmt.Println(data, *(*[]int)(data))
    	}
    	var wg sync.WaitGroup
    	writeDataFn()
    	for i := 0; i < 10; i++ {
        
    		wg.Add(1)
    		go func() {
        
    			for i := 0; i < 10; i++ {
        
    				writeDataFn()
    				time.Sleep(time.Microsecond * 100)
    			}
    			wg.Done()
    		}()
    		wg.Add(1)
    		go func() {
        
    			for i := 0; i < 10; i++ {
        
    				readDataFn()
    				time.Sleep(time.Microsecond * 100)
    			}
    			wg.Done()
    		}()
    	}
    	wg.Wait()
    }

## 常见任务 ##

>  *  这些没太花重心学，后期直接看 web 相关框架

### 内置 JSON 解析 ###

利用 [反射][Link 3] 实现，通过 FeildTag 来标识对应的 json 值

var jsonStr = `{
    	"basic_info":{
    	  	"name":"Mike",
    		"age":30
    	},
    	"job_info":{
    		"skills":["Java","Go","C"]
    	}
    }	`
    
    func TestEmbeddedJson(t *testing.T) {
        
    	e := new(Employee)
    	err := json.Unmarshal([]byte(jsonStr), e)
    	if err != nil {
        
    		t.Error(err)
    	}
    	fmt.Println(*e)
    	if v, err := json.Marshal(e); err == nil {
        
    		fmt.Println(string(v))
    	} else {
        
    		t.Error(err)
    	}
    
    }

### easyjson ###

是用代码生成的

相关代码：[easyjson][]

### HTTP 服务 ###

import (
    	"fmt"
    	"net/http"
    	"time"
    )
    
    func main() {
        
    	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        
    		fmt.Fprintf(w, "Hello World!")
    	})
    	http.HandleFunc("/time/", func(w http.ResponseWriter, r *http.Request) {
        
    		t := time.Now()
    		timeStr := fmt.Sprintf("{\"time\": \"%s\"}", t)
    		w.Write([]byte(timeStr))
    	})
    
    	http.ListenAndServe(":8080", nil)
    }

#### 路由规则 ####

*  URL分为两种，末尾是 /：表示一个子树，后面可以跟其他子路径；末尾不是 /，表示一个叶子，固定的路径
 *  以 / 结尾的URL可以匹配它的任何子路径，比如 /images会匹配 /images/cute-cat.jpg
 *  它采用最长匹配原则，如果有多个匹配，一定采用匹配路径最长的那个进行处理
 *  如果没有找到任何匹配项，会返回404错误

#### default router ####

![在这里插入图片描述][886e94b165ef4b2f8b4fed13c511e18d.png]

#### 更好的 router ####

[httprouter: A high performance HTTP request router that scales well][httprouter_ A high performance HTTP request router that scales well]

import (
    	"fmt"
    	"log"
    	"net/http"
    
    	"github.com/julienschmidt/httprouter"
    )
    
    func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
        
    	fmt.Fprint(w, "Welcome!\n")
    }
    
    func Hello(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
        
    	fmt.Fprintf(w, "hello, %s!\n", ps.ByName("name"))
    }
    
    func main() {
        
    	router := httprouter.New()
    	router.GET("/", Index)
    	router.GET("/hello/:name", Hello)
    
    	log.Fatal(http.ListenAndServe(":8080", router))
    }

### 构建 RESTful ###

这个看这里的代码吧：[geektime/go\_learning/code/ch45/roa/resource\_oriented\_arc.go][geektime_go_learning_code_ch45_roa_resource_oriented_arc.go]

## 关联阅读 ##

[Go 反射][Link 3]

[Go 并发][Go 2]

[Go]: http://gk.link/a/11Tec
[5c8002901b204fe0ae400ea89e386667.png]: https://img-blog.csdnimg.cn/5c8002901b204fe0ae400ea89e386667.png
[2d3378675a7f4ae7a17a7b3ea7d5e9c8.png]: https://img-blog.csdnimg.cn/2d3378675a7f4ae7a17a7b3ea7d5e9c8.png
[0a4b7cde50ec4864864cdab3995dd998.png]: https://img-blog.csdnimg.cn/0a4b7cde50ec4864864cdab3995dd998.png
[abb1d2ba34894208b727dec8dc277961.png]: https://img-blog.csdnimg.cn/abb1d2ba34894208b727dec8dc277961.png
[30eb9ce212804c83a408c9118aa16d22.png]: https://img-blog.csdnimg.cn/30eb9ce212804c83a408c9118aa16d22.png
[3e9aabe134874219a278412b7a50ad2a.png]: https://img-blog.csdnimg.cn/3e9aabe134874219a278412b7a50ad2a.png
[6b149c252f8b41f299dc23db6678655e.png]: https://img-blog.csdnimg.cn/6b149c252f8b41f299dc23db6678655e.png
[d463468b3b3641c0ab461a6ab99f1706.png]: https://img-blog.csdnimg.cn/d463468b3b3641c0ab461a6ab99f1706.png
[aebd2e15821745cba0f2f2ee8632586d.png]: https://img-blog.csdnimg.cn/aebd2e15821745cba0f2f2ee8632586d.png
[a1b5f41043cb4a4da6f886578c9389c7.png]: https://img-blog.csdnimg.cn/a1b5f41043cb4a4da6f886578c9389c7.png
[555fc8a14dc54ebdbf51a90bdceee07e.png]: https://img-blog.csdnimg.cn/555fc8a14dc54ebdbf51a90bdceee07e.png
[b8cde465a1db42a29edf3f821ef0430c.png]: https://img-blog.csdnimg.cn/b8cde465a1db42a29edf3f821ef0430c.png
[2ccd57dfe6d046e09ae01fcad9c254b7.png]: https://img-blog.csdnimg.cn/2ccd57dfe6d046e09ae01fcad9c254b7.png
[ea061e8a4c974ead95c83bed2e22a84b.png]: https://img-blog.csdnimg.cn/ea061e8a4c974ead95c83bed2e22a84b.png
[8a2c2965fdd84b83ae8f63814df2d7a7.png]: https://img-blog.csdnimg.cn/8a2c2965fdd84b83ae8f63814df2d7a7.png
[1dbbb70100434a34a0ffa06b1da67c8c.png]: https://img-blog.csdnimg.cn/1dbbb70100434a34a0ffa06b1da67c8c.png
[cec23982bf2b4b31b0bae92d49c0b48a.png]: https://img-blog.csdnimg.cn/cec23982bf2b4b31b0bae92d49c0b48a.png
[c45de99d5df54df388a006ca399d48a0.png]: https://img-blog.csdnimg.cn/c45de99d5df54df388a006ca399d48a0.png
[85a1106bb34d4a9e90d1202a977fa2da.png]: https://img-blog.csdnimg.cn/85a1106bb34d4a9e90d1202a977fa2da.png
[e2febae12fd746899577ad4ef67f714b.png]: https://img-blog.csdnimg.cn/e2febae12fd746899577ad4ef67f714b.png
[8cc7c872751a4e0f80f4780d6e62557f.png]: https://img-blog.csdnimg.cn/8cc7c872751a4e0f80f4780d6e62557f.png
[f05440d9d9ac491187cbbcef1c38e135.png]: https://img-blog.csdnimg.cn/f05440d9d9ac491187cbbcef1c38e135.png
[Link 1]: https://mindartisan.blog.csdn.net/article/details/125555915
[Link 2]: https://mindartisan.blog.csdn.net/article/details/126090272
[f4e0647340574aff84980dfa4f72bb5b.png]: https://img-blog.csdnimg.cn/f4e0647340574aff84980dfa4f72bb5b.png
[8997e2976a5745889ae0066585ea95f7.png]: https://img-blog.csdnimg.cn/8997e2976a5745889ae0066585ea95f7.png
[ddfafe1c7028475cbd6c6905588a6683.png]: https://img-blog.csdnimg.cn/ddfafe1c7028475cbd6c6905588a6683.png
[https_github.com_smartystreets_goconvey]: https://github.com/smartystreets/goconvey
[Go 1]: https://www.cnblogs.com/traditional/p/11890639.html
[Link 3]: https://mindartisan.blog.csdn.net/article/details/128488688
[easyjson]: https://gitee.com/geektime-geekbang/go_learning/tree/master/code/ch43/easyjson
[886e94b165ef4b2f8b4fed13c511e18d.png]: https://img-blog.csdnimg.cn/886e94b165ef4b2f8b4fed13c511e18d.png
[httprouter_ A high performance HTTP request router that scales well]: https://github.com/julienschmidt/httprouter
[geektime_go_learning_code_ch45_roa_resource_oriented_arc.go]: https://gitee.com/geektime-geekbang/go_learning/blob/master/code/ch45/roa/resource_oriented_arc.go
[Go 2]: https://mindartisan.blog.csdn.net/article/details/128462239