100 Go Mistakes and How to Avoid Them - 1

关于本书

100 Go Mistakes and How to Avoid Them

Spot errors in your Go code you didn’t even know you were making and boost your productivity by avoi...

https://book.douban.com/subject/36084407/

2. Code and Project organization

• 以符合go语言习惯的组织代码

• 代码能高效的处理抽象：接口和泛型

• 提供构建项目的最佳实践

2.1 #1 Unintended variable shadowing（变量遮蔽带来的非意料行为 ）

// 这种场景在if语句中使用 := 声明了和最外层client同名的变量，
// 这样会出现内部变量覆盖外层变量的情况
var client *http.Client
if tracing {
	// 这里的client是新的临时变量，实际上没有对外层的client赋值
	client, err := createClientWithTracing()
	if err != nil {
		return err
	}
	log.Println(client)
} else {
	client, err := createDefaultClient()
	if err != nil {
		return err
	}
	log.Println(client)
}

// 把判断语句中的声明语法换成赋值语法，同样在最外层声明err，可以做到减少代码量的效果
var client *http.Client
var err error
if tracing {
	client, err = createClientWithTracing()
} else {
	client, err = createDefaultClient()
}
if err != nil {
		return err
}
log.Println(client)

2.2 #2 Unnecessary nested code （没有必要的代码嵌套 ）

func join(s1, s2 string, max int) (string, error) {
	if s1 == "" {
		return "", errors.New("s1 is empty")
	} else {
		if s2 == "" {
			return "", errors.New("s2 is empty")
		} else {
			concat, err := concatenate(s1, s2)
			if err != nil {
				return "", errors
			} else {
				if len(concat) > max {
					return concat[:max], nil
				} else {
					return concat, nil
				}
			}
		}
	}
}

func join(s1, s2 string, max int) (string, error) {
	if s1 == "" {
		return "", errors.New("s1 is empty")
	}
	if s2 == "" {
		return "", errors.New("s2 is empty")
	}
	concat, err := concatenate(s1, s2)
	if err != nil {
		return "", err
	}
	if len(concat) > max {
		return concat[:max], nil
	}
	return concat, nil
}

if foo() {
	// ...
	return true
} else {
	// ...
}

if foo() {
	// ...
	return true
}
// ...

if s != "" {
	// ...
} else {
	return errors.New("empty string")
}

if s == "" {
		return errors.New("empty string")
}
// ...

2.3 #3 Misusing init functions（错误使用和理解 init 函数）

1. init函数无法抛出异常，错误处理有限制，极端情况只能panic

2. 增加了测试的复杂性，因为在测试代码执行前，包内的init函数

3. 如果init函数需要设置状态，往往需要一个全局变量存储。

1. 定义静态配置, go的官方博客使用 init 函数定义静态配置

// Copyright 2013 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Command blog is a web server for the Go blog that can run on App Engine or
// as a stand-alone HTTP server.
package main

import (
	"net/http"
	"strings"
	"time"

	"golang.org/x/tools/blog"
	"golang.org/x/website/content/static"

	_ "golang.org/x/tools/playground"
)

const hostname = "blog.golang.org" // default hostname for blog server

var config = blog.Config{
	Hostname:     hostname,
	BaseURL:      "https://" + hostname,
	GodocURL:     "https://golang.org",
	HomeArticles: 5,  // articles to display on the home page
	FeedArticles: 10, // articles to include in Atom and JSON feeds
	PlayEnabled:  true,
	FeedTitle:    "The Go Programming Language Blog",
}
// here
func init() {
	// Redirect "/blog/" to "/", because the menu bar link is to "/blog/"
	// but we're serving from the root.
	redirect := func(w http.ResponseWriter, r *http.Request) {
		http.Redirect(w, r, "/", http.StatusFound)
	}
	http.HandleFunc("/blog", redirect)
	http.HandleFunc("/blog/", redirect)

	// Keep these static file handlers in sync with app.yaml.
	static := http.FileServer(http.Dir("static"))
	http.Handle("/favicon.ico", static)
	http.Handle("/fonts.css", static)
	http.Handle("/fonts/", static)

	http.Handle("/lib/godoc/", http.StripPrefix("/lib/godoc/", http.HandlerFunc(staticHandler)))
}

func staticHandler(w http.ResponseWriter, r *http.Request) {
	name := r.URL.Path
	b, ok := static.Files[name]
	if !ok {
		http.NotFound(w, r)
		return
	}
	http.ServeContent(w, r, name, time.Time{}, strings.NewReader(b))
}

2.4 #4 Overusing getters and setters（过度使用 getters 和 setters）

timer := time.NewTimer(time.Second)
<-timer.C

1. They encapsulate a behavior associated with getting or setting a field, allowing new functionality to be added later (for example, validating a field, returning a computed value, or wrapping the access to a field around a mutex).

2. They hide the internal representation, giving us more flexibility in what we expose.

3. They provide a debugging interception point for when the property changes at run time, making debugging easier.

2.5 #5 Interface pollution （接口污染）

type ReadWriter interface {
    Reader
    Writer 
}

1. 多种类型有相同的行为，像sort包提供的sort方法只需要类型实现下面的接口就可以被排序

2. 代码解耦，结构体中包含接口成员而不是具体的结构体，能够帮助我们更好的解耦，不需要做大量的代码修改就能切换其他成员。

 

1. 可以代码限制行为，在这个例子里，调用Foo的代码，只能获取到阈值，却不能修改阈值，这就达到了限制行为的作

2.6 #6 Interface on the producer side （错误的把接口定义在实现端）

2.7 #7 Returning interfaces (返回接口)

1. 返回结构体，而不是接口

2. 函数或者结构体尽量接受接口

func LimitReader(r Reader, n int64) Reader {
    return &LimitedReader{r, n}
}

2.8 #8 any says nothing （any 类型表达性很弱）

2.9 #9: Being confused about when to use generics （不知道何时使用泛型）

// customConstraint 接口要求实现类型的底层类型是int就可以了，并且可以实现String方法
// 如果 ~int 改为 int，编译就会报错，int类型没有实现String方法
type customConstraint interface {
    ~int
    String() string
}

// customInt 满足 customConstraint 的要求，并且实现了 String 方法
type customInt int
func (i customInt) String() string {
    return strconv.Itoa(int(i))
}

1. 构建数据结构，例如，如果我们实现二叉树、链表或堆，我们可以使用泛型来分解出元素类型。

2. 处理任何类型的slice、map和channel的函数-例如，合并两个channel的函数适用于任何通道类型。

func merge[T any](ch1, ch2 <-chan T) <-chan T {
	// ...
}

3. 众多类型在实现接口方法时候拥有相似的处理逻辑，例如调用sort包方法对数组排序，需要数组元素类型实现Interface接口，没有泛型的时候，int,int32,int64,float都要实现一遍接口，而这些类型的实际方法的逻辑都是一样的，用泛型能够减少大量冗余代码

// sort package
// This interface is used by different functions such as sort.Ints or 
// sort .Float64s. Using type parameters, we could factor out the sorting 
// behavior (for example, by defining a struct holding a slice and a comparison function):
type Interface interface {
     Len() int
     Less(i, j int) bool
     Swap(i, j int)
}



s := SliceFn[int]{
	S: []int{3, 2, 1},
	Compare: func(a, b int) bool {
		return a < b
	}
}
sort.Sort(s)
fmt.Println(s.S)

1. 下面的例子我们调用了接口的方法，使用泛型没有带来任何好处

func foo[T io.Writer](w T) {
	b := getBytes()
	_, _ = w.Write(b)
}

2. 当使用泛型会带来更多复杂度

2.10 #10: Not being aware of the possible problems with type embedding （对类型嵌入的使用场景不熟悉）

1. 简单来说，类型嵌入可以避免编写大量的模板代码，使用嵌入类型的原则是，如果不想暴露成员的访问权，就尽量不使用类型嵌入。

2. 嵌入接口的话，嵌入类型还能够默认实现嵌入接口。

2.11 #11: Not using the functional options pattern（编写构造函数的时候，使用option模式）

func NewServer(addr string, port int) (*http.Server, error) { 
	// ...
}

1. 如果不传递port的时候，我们希望使用默认值，但是这里port又必须要填写一个值

2. 额外增加参数的时候，会对函数签名有不兼容的修改。

1. 如果port没有设置，我们使用默认值

2. 如果port是负数，抛出错误，这很重要

3. 如果port是0，那我们就随机生成端口

4. 其他场景，我们使用默认值

port := 0
// 但是用户使用的时候需要传递指针类型给Config结构体，会给人造成困惑，
// 配置一个端口需要传递一个int指针，所以这种设计并不API友好
config := httplib.Config{
	Port: &port,
}
// 当我们不想传递配置的时候，也不行，必要给一个空的结构提
httplib.NewServer("localhost", httplib.Config{})

// 构造函数，可以传递多个配置项
server, err := httplib.NewServer("localhost",
        httplib.WithPort(8080),
        httplib.WithTimeout(time.Second))
// 因为是可变参数，之前必填的cfg对象，可以省略
server, err := httplib.NewServer("localhost")

2.12 #12: Project misorganization（推荐的项目组织结构）

project-layout/README_zh-CN.md at master · golang-standards/project-layout

Standard Go Project Layout. Contribute to golang-standards/project-layout development by creating an account on GitHub.

https://github.com/golang-standards/project-layout/blob/master/README_zh-CN.md

2.13 #13: Creating utility packages（不推荐使用utility包）

// bad
set := util.NewStringSet("c", "a", "b")
fmt.Println(util.SortStringSet(set))

// good
set := stringset.New("c", "a", "b")
fmt.Println(stringset.Sort(set))

2.14 #14: Ignoring package name collisions（忽略包命名冲突）

import "xxx/redis"

// bad
redis := redis.NewClient()
v, err := redis.Get("foo")

redisClient := redis.NewClient()
v, err := redisClient.Get("foo")

import redisapi "mylib/redis"

redis := redisapi.NewClient()
v, err := redis.Get("foo")

2.15 #15: Missing code documentation（完善代码文档）

2.16 #16: Not using linters（不使用linters）

3 Data types

3.1 #17: Creating confusion with octal literals（混淆八进制）

sum := 100 + 010
fmt.Println(sum)

// output
// 108

file, err := os.OpenFile("foo", os.O_RDONLY, 0o644)

• 二进制-使用0b或者0B作为前缀（0b100代表4）

• 16进制-使用0x或者0X前缀（0xF代表15）

• 虚数-使用i作为后缀（3i）

3.2 #18 Neglecting integer overflows（忽略整数溢出）

// 当对整数进行+1操作时，对溢出判断
func Inc32(counter int32) int32 {
	if counter == math.MaxInt32 {
		panic("int32 overflow")
	}
	return counter + 1
}

func IncInt(counter int) int {
	if counter == math.MaxInt {
		panic("int overflow")
	}
	return counter + 1
}

func IncUint(counter uint) uint {
	if counter == math.MaxUint {
		panic("uint overflow")
	}
	return counter + 1
}

// 当两个整数相加时，提前做溢出判断
func AddInt(a, b int) int {
	if a > math.MaxInt-b {
		panic("int overflow")
	}

	return a + b
}

// 两数相乘时提前做溢出判断
func MultiplyInt(a, b int) int {
	if a == 0 || b == 0 {
		return 0
	}

	result := a * b
	if a == 1 || b == 1 {
		return result
	}
	if a == math.MinInt || b == math.MinInt {
		panic("integer overflow")
	}
	if result/b != a {
		panic("integer overflow")
	}
	return result
}

3.3 #19: Not understanding floating points（对浮点数理解欠缺）

浮点数的二进制表示(IEEE 754标准)

浮点数是我们在程序里常用的数据类型，它在内存中到底是怎么样的形式存在，是我了解之前是觉得好神奇，以此记录，作为学习笔记并分享。 现代计算机中，一般都以IEEE 754标准存储浮点数，这个标准的在内存中存储的…

https://zhuanlan.zhihu.com/p/144697348

1. float32和float64存储精度有限，可能会导致存储出现偏差。因此也会对使用方式产生影响：首先就是对2个浮点数进行比较大小，因此对2个浮点数对比的时候，我们保证误差在可接受范围内即可：

1. 浮点运算的误差会随着执行次数累积：f2和f1的执行顺序不一致，导致f2的误差更低

func f1(n int) float64 {
	result := 10_000.
	for i := 0; i < n; i++ {
		result += 1.0001
	}
	return result
}

func f2(n int) float64 {
	result := 0.
	for i := 0; i < n; i++ {
		result += 1.0001
	}
	return result + 10_000.
}

a := 100000.001
b := 1.0001
c := 1.0002

fmt.Println(a * (b + c))
// 方式2精度更高，优先计算乘除，但是执行效率低
fmt.Println(a*b + a*c)

// output
// 200030.00200030004
// 200030.0020003

• 浮点数比较大小的时候，检查2数误差在可接受范围内即可

• 为了提升结果的精度，在进行加减操作时，把具有相似数量级的数进行分组操作

• 为了提高准确性，如果一系列操作需要加法、减法、乘法或除法，请先执行乘法和除法操作

3.4 #20: Not understanding slice length and capacity（不理解切片len和cap）

3.5 #21: Inefficient slice initialization（低效的切片初始化）

func convertEmptySlice(foos []Foo) []Bar {
	bars := make([]Bar, 0)
	// 如果foos过长，导致bars频繁申请内存，拷贝数组对执行效率和GC产生影响
	for _, foo := range foos {
		bars = append(bars, fooToBar(foo))
	}
	return bars
}

func convertGivenCapacity(foos []Foo) []Bar {
	n := len(foos)
  // 预先指定 cap
	bars := make([]Bar, 0, n)
	
	for _, foo := range foos {
		bars = append(bars, fooToBar(foo))
	}
	return bars
}

func convertGivenLength(foos []Foo) []Bar {
	n := len(foos)
	// 预先指定len，通过下标赋值，比使用append内置函数效率更高一些
	bars := make([]Bar, n)

	for i, foo := range foos {
		bars[i] = fooToBar(foo)
	}
	return bars
}

3.6 #22: Being confused about nil vs. empty slices（区分nil和empty切片）

func main() {
	var s1 []float32
	customer1 := customer{
		ID:         "foo",
		Operations: s1,
	}
	b, _ := json.Marshal(customer1)
	// {"ID":"foo","Operations":null} nil 的切片被解析为 null
	fmt.Println(string(b))

	s2 := make([]float32, 0)
	customer2 := customer{
		ID:         "bar",
		Operations: s2,
	}
	b, _ = json.Marshal(customer2)
  // {"ID":"bar","Operations":[]} empty 的切片被解析为 []
	fmt.Println(string(b))
}

type customer struct {
	ID         string
	Operations []float32
}

3.7 #23: Not properly checking if a slice is empty（判断切片为空）

len(s) == 0

3.8 #24: Not making slice copies correctly（没有正确的复制切片）

func bad() {
	src := []int{0, 1, 2}
	var dst []int
	copy(dst, src)
	fmt.Println(dst)

	_ = src
	_ = dst
}

func correct() {
	src := []int{0, 1, 2}
	dst := make([]int, len(src))
	copy(dst, src)
	fmt.Println(dst)

	_ = src
	_ = dst
}

3.9 #25: Unexpected side effects using slice append（使用切片append时产生的副作用-s[low:high:max]用法）

// 当调用f函数的时候，对s入参做的修改都会反应到上层函数中的s
func listing1() {
	s := []int{1, 2, 3}

	f(s[:2])
	fmt.Println(s)
}

// 解决方案一：对s进行深拷贝
func listing2() {
	s := []int{1, 2, 3}
	sCopy := make([]int, 2)
	copy(sCopy, s)

	f(sCopy)
	result := append(sCopy, s[2])
	fmt.Println(result)
}

// 解决方案二：使用 full slice expression: s[low:high:max]，这样就限制了切片的cap
// cap = max-low = 2-0 = 2
// 这样f函数对切片进行append操作就不用影响其他共享底层存储的切片了
func listing3() {
	s := []int{1, 2, 3}
	f(s[:2:2])
	fmt.Println(s)
}

func f(s []int) {
	_ = append(s, 10)
}

3.10 #26: Slices and memory leaks（切片的内存泄露）

func main() {
	foos := make([]Foo, 1_000)
	printAlloc()

	for i := 0; i < len(foos); i++ {
		foos[i] = Foo{
			v: make([]byte, 1024*1024),
		}
	}
	printAlloc()
	
  // 和上面类似不会回收剩下998个元素
	two := keepFirstTwoElementsOnly(foos)
	runtime.GC()
	printAlloc()
	runtime.KeepAlive(two)
}

func keepFirstTwoElementsOnly(foos []Foo) []Foo {
	return foos[:2]
}

// keepFirstTwoElementsOnlyCopy 和 keepFirstTwoElementsOnlyMarkNil
// 都能保证剩下的资源被回收，但是如果想留下的元素不是2，我们想保留500个元素，
// 使用 keepFirstTwoElementsOnlyMarkNil 会有更高的效率，不用额外拷贝资源
func keepFirstTwoElementsOnlyCopy(foos []Foo) []Foo {
	res := make([]Foo, 2)
	copy(res, foos)
	return res
}

// keepFirstTwoElementsOnlyMarkNil 给元素中的指针成员置为nil，能够让GC自动回收
func keepFirstTwoElementsOnlyMarkNil(foos []Foo) []Foo {
	for i := 2; i < len(foos); i++ {
		foos[i].v = nil
	}
	return foos[:2]
}

func printAlloc() {
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	fmt.Printf("%d KB\n", m.Alloc/1024)
}

3.11 #27: Inefficient map initialization（低效的map初始化）

map 的实现原理

什么是 map # 维基百科里这样定义 map： In computer science, an associative array, map, symbol table, or dictionary is an abstract data type composed of a collection of (key, value) pairs, such that each possible key appears at most once in the collection. 简单说明一下：在计算机科学里，被称为相关数组、map、符号表或者字典，是由一组 <key, value> 对组成的抽象数据结构，，并且同一个 key 只会出现一次。 有两个关键点：map 是由 key-value 对组成的；key 只会出现一次。 和 map 相关的操作主要是： 增加一个 k-v 对 —— Add or insert； 删除一个 k-v 对 —— Remove or delete； 修改某个 k 对应的 v —— Reassign； 查询某个 k 对应的 v —— Lookup； 简单说就是最基本的 增删查改。

https://golang.design/go-questions/map/principal/

1. 装载因子超过阈值，源码里定义的阈值是 6.5。(loadFactor := count / (2^B)) count 就是 map 的元素个数，2^B 表示 bucket 数量。

2. overflow 的 bucket 数量过多：当 B 小于 15，也就是 bucket 总数 2^B 小于 2^15 时，如果 overflow 的 bucket 数量超过 2^B；当 B >= 15，也就是 bucket 总数 2^B 大于等于 2^15，如果 overflow 的 bucket 数量超过 2^15。

3.12 #28: Maps and memory leaks（map类型的内存泄露，map中的值建议使用指针类型）

Go map 如何缩容？

快速了解 map 缩容机制

https://mp.weixin.qq.com/s/Slvgl3KZax2jsy2xGDdFKw

func main() {
	// Init
	n := 1_000_000
	m := make(map[int][128]byte)
	printAlloc()

	// Add elements
	for i := 0; i < n; i++ {
		m[i] = randBytes()
	}
	printAlloc()

	// Remove elements
	for i := 0; i < n; i++ {
		delete(m, i)
	}

	// End
	runtime.GC()
	printAlloc()
	runtime.KeepAlive(m)
}
// output
// 0 MB
// 461 MB
// 293 MB

func randBytes() [128]byte {
	return [128]byte{}
}

func printAlloc() {
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	fmt.Printf("%d MB\n", m.Alloc/1024/1024)
}

• 解决方案一是不断的拷贝新的map，但是在下个gc周期前，内存会翻倍；

• 解决方案二修改map中value的类型为指针，减少value空值占用的空间；

3.13 #29: Comparing values incorrectly（错误的对比值）

• 对与一些不可比较的类型：slice不能直接使用 == 来比较

var cust1 any = customer{id: "x", operations: []float64{1.}}
var cust2 any = customer{id: "x", operations: []float64{1.}}
fmt.Println(cust1 == cust2)

// panic: runtime error: comparing uncomparable type main.customer

• 使用 reflect.DeepEqual 方法可以根据类型不同进行不同的比较，但是运行时间是 == 的100倍，因此在对性能有需要的场景，建议自行编写对比函数。

cust1 := customer{id: "x", operations: []float64{1.}} 
cust2 := customer{id: "x", operations: []float64{1.}} 
// 1. reflect.DeepEqual 执行效率低
fmt.Println(reflect.DeepEqual(cust1, cust2))
// 2. equal 执行效率是 reflect.DeepEqual 的 96 倍
fmt.Println(cust1.equal(cust2))

func (a customer) equal(b customer) bool {
	if a.id != b.id {
		return false
	}
	if len(a.operations) != len(b.operations) {
		return false
	}
	for i := 0; i < len(a.operations); i++ {
		if a.operations[i] != b.operations[i] {
			return false
		}
	}
	return true
}

4 Control structures

4.1 #30: Ignoring the fact that elements are copied in range loops（range loop中的值为副本）

func main() {
	accounts := createAccounts()
	for _, a := range accounts {
		a.balance += 1000
	}
  // [{100} {200} {300}]
	fmt.Println(accounts)
	
	// 方案一：直接使用下标访问到特定的值，仍然使用 range loop
	accounts = createAccounts()
	for i := range accounts {
		accounts[i].balance += 1000
	}
  // [{1100} {1200} {1300}]
	fmt.Println(accounts)

	// 方案二：直接使用下标访问到特定的值，自己计算下标值
	accounts = createAccounts()
	for i := 0; i < len(accounts); i++ {
		accounts[i].balance += 1000
	}
  // [{1100} {1200} {1300}]
	fmt.Println(accounts)
	
	// 方案三：迭代指针类型，及时a为副本但是仍然指向同一个内存地址
	accountsPtr := createAccountsPtr()
	for _, a := range accountsPtr {
		a.balance += 1000
	}
}

func createAccounts() []account {
	return []account{
		{balance: 100.},
		{balance: 200.},
		{balance: 300.},
	}
}

func createAccountsPtr() []*account {
	return []*account{
		{balance: 100.},
		{balance: 200.},
		{balance: 300.},
	}
}

4.2 #31: Ignoring how arguments are evaluated in range loops（忽略rang的对象是何时被计算）

// range loop 的对象是一个表达式，这个表达式可以是 string, slice等，当执行
// 循环的时候，exp只会被计算一次，对原始迭代值进行拷贝生成一个副本
for i, v := range exp

// 迭代对象只计算一次，迭代3次就结束，不会无限循环
s := []int{0, 1, 2}
for range s {
    s = append(s, 10)
}

// 但是下面这种写法就会无限循环
s := []int{0, 1, 2}
for i := 0; i < len(s); i++ {
    s = append(s, 10)
}

func main() {
	ch1 := make(chan int, 3)
	go func() {
		ch1 <- 0
		ch1 <- 1
		ch1 <- 2
		close(ch1)
	}()

	ch2 := make(chan int, 3)
	go func() {
		ch2 <- 10
		ch2 <- 11
		ch2 <- 12
		close(ch2)
	}()

	ch := ch1
	// rang loop里的ch一直指向ch1，只会迭代3次
	for v := range ch {
		fmt.Println(v)
		ch = ch2
	}
}
// output
// 0 1 2

4.3 #32: Ignoring the impact of using pointer elements in range loops （错误的引用range loop的生成值）

type Customer struct {
	ID      string
	Balance float64
}

type Store struct {
	m map[string]*Customer
}

func main() {
	s := Store{
		m: make(map[string]*Customer),
	}
	s.storeCustomers([]Customer{
		{ID: "1", Balance: 10},
		{ID: "2", Balance: -10},
		{ID: "3", Balance: 0},
	})
	print(s.m)
}

// 问题来源：
func (s *Store) storeCustomers(customers []Customer) {
	for _, customer := range customers {
		// 每次迭代的时候 customer 都是同一个对象，只是 customer 的值会不断被新的值覆盖
		fmt.Printf("%p\n", &customer)
		// 最终map中的每个key都指向了同一个内存地址
		s.m[customer.ID] = &customer
	}
}

// 解决方案一：把每次迭代的值copy到一个新的临时变量
func (s *Store) storeCustomers2(customers []Customer) {
	for _, customer := range customers {
		current := customer
		s.m[current.ID] = &current
	}
}

// 解决方案二：直接引用切片的元素
// 问题：如果slice出现扩容的时候，那原本地址还是被引用，可能出现内存泄露
func (s *Store) storeCustomers3(customers []Customer) {
	for i := range customers {
		customer := &customers[i]
		s.m[customer.ID] = customer
	}
}

func print(m map[string]*Customer) {
	for k, v := range m {
		fmt.Printf("key=%s, value=%#v\n", k, v)
	}
}

4.4 #33: Making wrong assumptions during map iterations（在迭代map的时候做出了错误的假设）

• 迭代map的时候，GO不保证有序，甚至还估计打乱迭代顺序。如果想要按顺序迭代map，可以使用第三方库
gods
emirpasic • Updated Mar 25, 2023

• 边迭代map边增加map的值，GO的行为不可预测，有可能迭代到新加入的值有可能迭代不到

4.5 #34: Ignoring how the break statement works（不明确break语句是如何工作-break label的使用）

func listing() {
loop:
	for i := 0; i < 5; i++ {
		fmt.Printf("%d ", i)
		switch i {
		default:
		case 2:
			break loop
		}
	}
}

4.6 #35: Using defer inside a loop（在loop循环中使用defer语句）

• 每次迭代之后就主动关闭，不借助于defer的能力

• 放在一个函数闭包内，当闭包执行完之后执行defer

func readFiles(ch <-chan string) error {
	for path := range ch {
		
		err := func() error {
			file, err := os.Open(path)
			if err != nil {
				return err
			}

			defer file.Close()

			// Do something with file
			return nil
		}() // 放在闭包内并及时调用
		if err != nil {
			return err
		}
	}
	return nil
}

5 Strings

5.1 #36: Not understanding the concept of a rune（不理解rune的概念）

• Go源代码使用UTF-8进行编码。因此，所有字符串都是UTF-8字符串。但是，由于字符串可以包含任意字节，如果它来自其他地方（而不是源代码），则不能保证基于UTF-8编码

• rune对应着Unicode中的码点的概念，一个rune代表Unicode中的一个字符

• 使用UTF-8编码，Unicode码点可以编码为1到4个字节

• len函数返回的是字节长度，而不是rune的长度

func main() {
	s := "hello"
	// output: 5
	fmt.Println(len(s))

	s = "汉"
  // output: 3
	fmt.Println(len(s))
	
  // 汉 被编码为3个字节
	s = string([]byte{0xE6, 0xB1, 0x89})
	fmt.Printf("%s\n", s)
}

5.2 #37: Inaccurate string iteration（错误的迭代string-当string中的字符并非单字节Utf-8编码时）

runes := []rune(s)
for i, r := range runes {
	fmt.Printf("position %d: %c\n", i, r)
}
// output
// position 0: h
// position 1: ê
// position 2: l
// position 3: l
// position 4: o

5.3 #38: Misusing trim functions（错误使用 trim 函数）

func main() {
	// output: 123
	// TrimRight removes all the trailing runes contained in a given set
	fmt.Println(strings.TrimRight("123oxo", "xo"))
	
	// output: 123o
	// TrimSuffix returns a string without a provided trailing suffix
	fmt.Println(strings.TrimSuffix("123oxo", "xo"))
	
	// output: 123
	// TrimLeft like TrimRight
	fmt.Println(strings.TrimLeft("oxo123", "ox"))

	// output: o123
	// TrimPrefix like TrimSuffix
	fmt.Println(strings.TrimPrefix("oxo123", "ox"))
	
	// output: 123
	fmt.Println(strings.Trim("oxo123oxo", "ox"))
}

5.4 #39: Under-optimized string concatenation（如何高效的字符串拼接-strings.Builder）

func concatV1(values []string) string {
	s := ""
	for _, value := range values {
		s += value
	}
	return s
}

func concatV2(values []string) string {
	sb := strings.Builder{}
	for _, value := range values {
		_, _ = sb.WriteString(value)
	}
	return sb.String()
}

func concatV3(values []string) string {
	total := 0
	for i := 0; i < len(values); i++ {
		total += len(values[i])
	}

	sb := strings.Builder{}
	sb.Grow(total)
	for _, value := range values {
		_, _ = sb.WriteString(value)
	}
	return sb.String()
}

5.5 #40: Useless string conversions（无用的字符串转换）

• bytes 包支持很多和strings包类似的方法，很多时候没有必要一定要把[]byte转化为string：比如bytes.TrimSpace 方法

5.6 #41: Substrings and memory leaks（子字符串和内存泄露-Consistent with #26）

func main() {
	s1 := "Hello, World!"
	s2 := s1[:5]
	fmt.Println(s2)

	s1 = "Hêllo, World!"
	s2 = string([]rune(s1)[:5])
	fmt.Println(s2)
}

type store struct{}

func (s store) handleLog1(log string) error {
	if len(log) < 36 {
		return errors.New("log is not correctly formatted")
	}
	uuid := log[:36]
	s.store(uuid)
	// Do something
	return nil
}

func (s store) handleLog2(log string) error {
	if len(log) < 36 {
		return errors.New("log is not correctly formatted")
	}
	uuid := string([]byte(log[:36]))
	s.store(uuid)
	// Do something
	return nil
}

func (s store) handleLog3(log string) error {
	if len(log) < 36 {
		return errors.New("log is not correctly formatted")
	}
	uuid := string(strings.Clone(log[:36]))
	s.store(uuid)
	// Do something
	return nil
}

6 Functions and methods

6.1 #42: Not knowing which type of receiver to use（不知道receiver应该使用什么样的类型）

 

• 方法需要修改receiver的值

• 如果receiver的成员不能被拷贝

• 如果receiver是一个大的对象，使用指针类型可以更高效的处理程序，这里大的具体数值不好界定，需要看实际的场景，这里可以使用benchmark来估计。

• 如果强制要求receiver是不可变的

• 如果receiver是一个map、function、channel类型，否则会有编译错误

• receiver是一个slice，并且一定需要修改

• receiver是一个array或者是一个没有可变字段的struct，如time.Time

• receiver是基本类型，例如int、float64或string。

• 这种场景建议receiver的类型设为指针类型，能明确的告诉使用者这个方法会修改成员的值

6.2 #43: Never using named result parameters （“永远”不要使用命名结果参数）

6.3 #44: Unintended side effects with named result parameters （使用命名参数可能会出现意向不到的副作用）

6.4 ⚠️ #45: Returning a nil receiver（返回了一个nil的值，该值的指针类型实现了某一接口）

// MultiError 实现了 Error 接口
type MultiError struct {
    errs []string
}
func (m *MultiError) Add(err error) {
    m.errs = append(m.errs, err.Error())
}
func (m *MultiError) Error() string {
    return strings.Join(m.errs, ";")
}

func (c Customer) Validate() error {
    var m *MultiError
    if c.Age < 0 {
        m = &MultiError{}
        m.Add(errors.New("age is negative"))
    }
    if c.Name == "" {
        if m == nil {
            m = &MultiError{}
				}
        m.Add(errors.New("name is nil"))
    }
    // 按照惯性思维，如果校验通过m也就是个nil，直接返回nil表示没有错误
		return m 
}

customer := Customer{Age: 33, Name: "John"}
if err := customer.Validate(); err != nil {
    log.Fatalf("customer is invalid: %v", err)
}
// output
// 2021/05/08 13:47:28 customer is invalid: <nil>

if c.Age < 0 {
    // ...
}
if c.Name == "" {
	// ... 
}
if m != nil {
    return m
}
return nil

6.5 #46: Using a filename as a function input（没有考虑好函数参数抽象）

func countEmptyLines(reader io.Reader) (int, error) {
    scanner := bufio.NewScanner(reader)
    for scanner.Scan() {
			// ... 
		}
}

6.6 ⚠️ #47: Ignoring how defer arguments and receivers are evaluated（认清defer是如何以及何时计算函数参数）

1. defer调用函数时候常犯的错误

1. defer执行的是一个方法时，执行结果和receiver的类型有关

// 可以把方法转化为下面的形式，会帮助你理解
print(s Struct) vs print(s &Struct)