1. 追踪执行时间的技巧

如果你想追踪 Go 中函数的执行时间,有一个简单高效的技巧可以用一行代码实现,使用 defer 关键字即可。你只需要一个 TrackTime 函数:

// Utility
func TrackTime(pre time.Time) time.Duration {
  elapsed := time.Since(pre)
  fmt.Println("elapsed:", elapsed)

  return elapsed
}

func TestTrackTime(t *testing.T) {
  defer TrackTime(time.Now()) // <--- THIS

  time.Sleep(500 * time.Millisecond)
}

// 输出:
// elapsed: 501.11125ms

2. 两阶段延迟执行

Go 的 defer 不仅仅是用于清理任务,还可以用于准备任务,考虑以下示例:

func setupTeardown() func() {
    fmt.Println("Run initialization")
    return func() {
        fmt.Println("Run cleanup")
    }
}

func main() {
    defer setupTeardown()() // <--------
    fmt.Println("Main function called")
}

// 输出:
// Run initialization
// Main function called
// Run cleanup

这种模式的美妙之处在于,只需一行代码,你就可以完成诸如以下任务:

  • 打开数据库连接,然后关闭它。
  • 设置模拟环境,然后拆除它。
  • 获取分布式锁,然后释放它。

3. 预分配切片

根据文章《Go 性能提升技巧》中的见解,预分配切片或映射可以显著提高 Go 程序的性能。但是值得注意的是,如果我们不小心使用 append 而不是索引(如 a[i]),这种方法有时可能导致错误。你知道吗,我们可以在不指定数组长度(为零)的情况下使用预分配的切片,就像在上述文章中解释的那样?这使我们可以像使用 append 一样使用预分配的切片:

// 与其
a := make([]int, 10)
a[0] = 1

// 不如这样使用
b := make([]int, 0, 10)
b = append(b, 1)

4. 链式调用

链式调用技术可以应用于函数(指针)接收器。为了说明这一点,让我们考虑一个 Person 结构,它有两个函数 AddAge 和 Rename,用于对其进行修改。

type Person struct {
  Name string
  Age  int
}

func (p *Person) AddAge() {
  p.Age++
}

func (p *Person) Rename(name string) {
  p.Name = name
}

如果你想给一个人增加年龄然后给他们改名字,常规的方法是:

func main() {
  p := Person{Name: "Aiden", Age: 30}

  p.AddAge()
  p.Rename("Aiden 2")
}

或者,我们可以修改 AddAge 和 Rename 函数接收器,使其返回修改后的对象本身,即使它们通常不返回任何内容。

func (p *Person) AddAge() *Person {
  p.Age++
  return p
}

func (p *Person) Rename(name string) *Person {
  p.Name = name
  return p
}

通过返回修改后的对象本身,我们可以轻松地将多个函数接收器链在一起,而无需添加不必要的代码行:

p = p.AddAge().Rename("Aiden 2")

5. Go 1.20 允许将切片解析为数组或数组指针

当我们需要将切片转换为固定大小的数组时,不能直接赋值,例如:

a := []int{0, 1, 2, 3, 4, 5}
var b [3]int = a[0:3]

// 在变量声明中不能将 a[0:3](类型为 []int 的值)赋值给 [3]int 类型的变量
// (不兼容的赋值)

为了将切片转换为数组,Go 团队在 Go 1.17 中更新了这个特性。随着 Go 1.20 的发布,借助更方便的字面量,转换过程变得更加简单:

// Go 1.20
func Test(t *testing.T) {
   a := []int{0, 1, 2, 3, 4, 5}
   b := [3]int(a[0:3])

  fmt.Println(b) // [0 1 2]
}

// Go 1.17
func TestM2e(t *testing.T) {
  a := []int{0, 1, 2, 3, 4, 5}
  b := *(*[3]int)(a[0:3])

  fmt.Println(b) // [0 1 2]
}

只是一个快速提醒:你可以使用 a[:3] 替代 a[0:3]。我提到这一点是为了更清晰地说明。

6. 使用 “import _” 进行包初始化

有时,在库中,你可能会遇到结合下划线 (_) 的导入语句,如下所示:

import (
  _ "google.golang.org/genproto/googleapis/api/annotations"
)

这将执行包的初始化代码(init 函数),而无需为其创建名称引用。这允许你在运行代码之前初始化包、注册连接和执行其他任务。

让我们通过一个示例来更好地理解它的工作原理:

// 下划线
package underscore

func init() {
  fmt.Println("init called from underscore package")
}
// main
package main

import (
  _ "lab/underscore"
)

func main() {}
// 输出:init called from underscore package

7. 使用 “import.” 进行导入

在了解了如何使用下划线进行导入后,让我们看看如何更常见地使用点 (.) 运算符。作为开发者,点 (.) 运算符可用于在不必指定包名的情况下使用导入包的导出标识符,这对于懒惰的开发者来说是一个有用的快捷方式。很酷,对吧?这在处理项目中的长包名时特别有用,比如 externalmodel 或 doingsomethinglonglib。

为了演示,这里有一个简单的例子:

package main

import (
  "fmt"
 . "math"
)

func main() {
  fmt.Println(Pi) // 3.141592653589793
  fmt.Println(Sin(Pi / 2)) // 1
}

8. Go 1.20 允许将多个错误合并为单个错误

Go 1.20 引入了对错误包的新功能,包括对多个错误的支持以及对 errors.Is 和 errors.As 的更改。在 errors 中添加的一个新函数是 Join,我们将在下面详细讨论它:

var (
  err1 = errors.New("Error 1st")
  err2 = errors.New("Error 2nd")
)

func main() {
  err := err1
  err = errors.Join(err, err2)

  fmt.Println(errors.Is(err, err1)) // true
  fmt.Println(errors.Is(err, err2)) // true
}

如果有多个任务导致错误,你可以使用 Join 函数而不是手动管理数组。这简化了错误处理过程。

9. 检查接口是否为真正的 nil

即使接口持有的值为 nil ,也不意味着接口本身为 nil。这可能导致 Go 程序中的意外错误。因此,重要的是要知道如何检查接口是否为真正的 nil 。

func main() {
  var x interface{}
  var y *int = nil
  x = y

  if x!= nil {
    fmt.Println("x!= nil") // <-- 实际输出
  } else {
    fmt.Println("x == nil")
  }

  fmt.Println(x)
}

// 输出:
// x!= nil
// <nil>

我们如何确定 interface{}值是否为 nil 呢?幸运的是,有一个简单的工具可以帮助我们实现这一点:

func IsNil(x interface{}) bool {
  if x == nil {
    return true
  }

  return reflect.ValueOf(x).IsNil()
}

10. 在 JSON 中解析 time.Duration

当解析 JSON 时,使用 time.Duration 可能是一个繁琐的过程,因为它需要在一秒的后面添加 9 个零(即 1000000000)。为了简化这个过程,我创建了一个名为 Duration 的新类型:

type Duration time.Duration

为了将字符串(如 “1s” 或 “20h5m”)解析为 int64 类型的持续时间,我还为这个新类型实现了自定义的解析逻辑:

func (d *Duration) UnmarshalJSON(b []byte) error {
  var s string
  if err := json.Unmarshal(b, &s); err!= nil {
    return err
  }
  dur, err := time.ParseDuration(s)
  if err!= nil {
    return err
  }
  *d = Duration(dur)
  return nil
}

但是,需要注意的是,变量 ‘d’ 不应为 nil,否则可能会导致编组错误。或者,你还可以在函数开头对 ‘d’ 进行检查。

11. 避免裸参数

当处理具有多个参数的函数时,仅通过阅读其用法来理解每个参数的含义可能会令人困惑。考虑以下示例:

printInfo("foo", true, true)

如果不检查 printInfo 函数,那么第一个 ‘true’ 和第二个 ‘true’ 的含义是什么呢?当你有一个具有多个参数的函数时,仅通过阅读其用法来理解参数的含义可能会令人困惑。但是,我们可以使用注释使代码更易读。例如:

//func printInfo(name string, isLocal, done bool)

printInfo("foo", true /* isLocal */, true /* done */)

有些 IDE 也支持这个功能,可以在函数调用建议中显示注释,但可能需要在设置中启用。

以上是我分享的一些实用技巧,但我不想让文章过长,难以跟进,因为这些技巧与特定主题无关,涵盖了各种类别。如果你觉得这些技巧有用,或有自己的见解要分享,请随时留言。我重视你的反馈,并乐于在回应此文章时点赞或推荐你的想法。

参考文章:https://juejin.cn/post/7303390778490028070