关于go:几个提升Go语言开发效率的小技巧

哈喽，大家好，我是asong。

每门语言都有本人的语法糖，像 java 的语法糖就有办法变长参数、拆箱与装箱、枚举、for-each等等，Go语言也不例外，其也有本人的语法糖，把握这些语法糖能够助咱们进步开发的效率，所以本文就来介绍一些 Go 语言的语法糖，总结的可能不能全，欢送评论区补充。

Go语言容许一个函数把任意数量的值作为参数，Go语言内置了 … 操作符，在函数的最初一个形参能力应用 … 操作符，应用它必须留神如下事项：

可变长参数必须在函数列表的最初一个；
把可变长参数当切片来解析，可变长参数没有没有值时就是 nil 切片
可变长参数的类型必须雷同

func test(a int, b ...int){return}

既然咱们的函数能够接管可变长参数，那么咱们在传参的时候也能够传递切片应用 … 进行解包转换为参数列表，append办法就是最好的例子：

var sl []int
sl = append(sl, 1)
sl = append(sl, sl...)

append 办法定义如下：

//    slice = append(slice, elem1, elem2)
//    slice = append(slice, anotherSlice...)
func append(slice []Type, elems ...Type) []Type

数组是有固定长度的，咱们在申明数组时肯定要申明长度，因为数组在编译时就要确认好其长度，然而有些时候对于想偷懒的我，就是不想写数组长度，有没有方法让他本人算呢？当然有，应用 … 操作符申明数组时，你只管填充元素值，其余的交给编译器本人去搞就好了；

a := [...]int{1, 3, 5} // 数组长度是 3，等同于 a := [3]{1, 3, 5}

有时咱们想申明一个大数组，然而某些 index 想设置特地的值也能够应用 … 操作符搞定：

a := [...]int{1: 20, 999: 10} // 数组长度是 100, 下标 1 的元素值是 20，下标 999 的元素值是 10，其余元素值都是 0

`init`函数

Go语言提供了先于 main 函数执行的 init 函数，初始化每个包后会主动执行 init 函数，每个包中能够有多个 init 函数，每个包中的源文件中也能够有多个 init 函数，加载程序如下：

从以后包开始，如果以后包蕴含多个依赖包，则先初始化依赖包，层层递归初始化各个包，在每一个包中，依照源文件的字典序从前往后执行，每一个源文件中，优先初始化常量、变量，最初初始化 init 函数，当呈现多个 init 函数时，则依照程序从前往后顺次执行，每一个包实现加载后，递归返回，最初在初始化以后包！

init函数实现了 sync.Once，无论包被导入多少次，init 函数只会被执行一次，所以应用 init 能够利用在服务注册、中间件初始化、实现单例模式等等，比方咱们常常应用的 pprof 工具，他就应用到了 init 函数，在 init 函数外面进行路由注册：

//go/1.15.7/libexec/src/cmd/trace/pprof.go
func init() {http.HandleFunc("/io", serveSVGProfile(pprofByGoroutine(computePprofIO)))
 http.HandleFunc("/block", serveSVGProfile(pprofByGoroutine(computePprofBlock)))
 http.HandleFunc("/syscall", serveSVGProfile(pprofByGoroutine(computePprofSyscall)))
 http.HandleFunc("/sched", serveSVGProfile(pprofByGoroutine(computePprofSched)))

 http.HandleFunc("/regionio", serveSVGProfile(pprofByRegion(computePprofIO)))
 http.HandleFunc("/regionblock", serveSVGProfile(pprofByRegion(computePprofBlock)))
 http.HandleFunc("/regionsyscall", serveSVGProfile(pprofByRegion(computePprofSyscall)))
 http.HandleFunc("/regionsched", serveSVGProfile(pprofByRegion(computePprofSched)))
}

Go 语言在设计师有代码洁癖，在设计上尽可能防止代码滥用，所以 Go 语言的导包必须要应用，如果导包了然而没有应用的话就会产生编译谬误，但有些场景咱们会遇到只想导包，然而不应用的状况，比方上文提到的 init 函数，咱们只想初始化包里的 init 函数，然而不会应用包内的任何办法，这时就能够应用 _ 操作符号重命名导入一个不应用的包：

import _ "github.com/asong"

在咱们日常开发中，个别都是在屎上上堆屎，遇到能够用的办法就间接复用了，然而这个办法的返回值咱们并不一定都应用，还要搜索枯肠的给他想一个命名，有没有方法能够不解决不要的返回值呢？当然有，还是 _ 操作符，将不须要的值赋给空标识符：

_, ok := test(a, b int)

大多数业务场景咱们都会对 struct 做序列化操作，但有些时候咱们想要 json 外面的某些字段不加入序列化，–操作符能够帮咱们解决，Go语言的构造体提供标签性能，在构造体标签中应用 – 操作符就能够对不须要序列化的字段做非凡解决，应用如下：

type Person struct{
  name string `json:"-"`
  age string `json: "age"`
}

咱们应用 json.Marshal 进行序列化是不会疏忽 struct 中的空值，默认输入字段的类型零值（string类型零值是 ””，对象类型的零值是nil…），如果咱们想在序列化是疏忽掉这些没有值的字段时，能够在构造体标签中中增加omitempty tag：

type User struct {
    Name  string   `json:"name"`
    Email string   `json:"email,omitempty"`
  Age int        `json: "age"`
}

func test() {
    u1 := User{Name: "asong",}
    b, err := json.Marshal(u1)
    if err != nil {fmt.Printf("json.Marshal failed, err:%v\n", err)
        return
    }
    fmt.Printf("str:%s\n", b)
}

运行后果：

str:{"name":"asong","Age":0}

Age字段咱们没有增加 omitempty tag 在json 序列化后果就是带空值的，email字段就被疏忽掉了；

每次应用变量时都要先进行函数申明，对于我这种懒人来说是真的不想写，因为写 python 写惯了，那么在 Go 语言是不是也能够不进行变量申明间接应用呢？咱们能够应用 name := expression 的语法模式来申明和初始化局部变量，相比于应用 var 申明的形式能够缩小申明的步骤：

var a int = 10
等用于
a := 10

应用短变量申明时有两个正文事项：

短变量申明只能在函数内应用，不能用于初始化全局变量
短变量申明代表引入一个新的变量，不能在同一作用域反复申明变量
多变量申明中如果其中一个变量是新变量，那么能够应用短变量申明，否则不可反复申明变量；

咱们通常都会应用 interface，一种是带办法的interface，一种是空的interface，Go1.18 之前是没有泛型的，所以咱们能够用空的 interface{} 来作为一种伪泛型应用，当咱们应用到空的 interface{} 作为入参或返回值时，就会应用到类型断言，来获取咱们所须要的类型，在 Go 语言中类型断言的语法格局如下：

value, ok := x.(T)
or
value := x.(T)

x 是 interface 类型，T 是具体的类型，形式一是平安的断言，形式二断言失败会触发 panic；这里类型断言须要辨别 x 的类型，如果 x 是空接口类型：

空接口类型断言本质是将 eface 中_type与要匹配的类型进行比照，匹配胜利在内存中组装返回值，匹配失败间接清空寄存器，返回默认值。

如果 x 是非空接口类型：

非空接口类型断言的本质是 iface 中 *itab 的比照。*itab 匹配胜利会在内存中组装返回值。匹配失败间接清空寄存器，返回默认值。

具体源码分析能够看这篇文章：源码分析类型断言是如何实现的！附性能损耗测试

切片 / 数组是咱们常常应用的操作，在 Go 语言中提供了 for range 语法来疾速迭代对象，数组、切片、字符串、map、channel 等等都能够进行遍历，总结起来总共有三种形式：

// 形式一：只遍历不关怀数据，实用于切片、数组、字符串、map、channel
for range T {}

// 形式二：遍历获取索引或数组，切片，数组、字符串就是索引，map 就是 key，channel 就是数据
for key := range T{}

// 形式三：遍历获取索引和数据，实用于切片、数组、字符串，第一个参数就是索引，第二个参数就是对应的元素值，map 第一个参数就是 key，第二个参数就是对应的值；for key, value := range T{}

Go 语言提供语法 value, ok := m[key]来判断 map 中的 key 是否存在，如果存在就会返回 key 所对应的值，不存在就会返回空值：

import "fmt"

func main() {dict := map[string]int{"asong": 1}
    if value, ok := dict["asong"]; ok {fmt.Printf(value)
    } else {fmt.Println("key:asong 不存在")
    }
}

Go语言提供了 select 关键字，select配合 channel 可能让 Goroutine 同时期待多个 channel 读或者写，在 channel 状态未扭转之前，select会始终阻塞以后线程或Goroutine。先看一个例子：

func fibonacci(ch chan int, done chan struct{}) {
 x, y := 0, 1
 for {
  select {
  case ch <- x:
   x, y = y, x+y
  case <-done:
   fmt.Println("over")
   return
  }
 }
}
func main() {ch := make(chan int)
 done := make(chan struct{})
 go func() {
  for i := 0; i < 10; i++ {fmt.Println(<-ch)
  }
  done <- struct{}{}
 }()
 fibonacci(ch, done)
}

select与 switch 具备类似的控制结构，与 switch 不同的是，select中的 case 中的表达式必须是 channel 的收发操作，当 select 中的两个 case 同时被触发时，会随机执行其中的一个。为什么是随机执行的呢？随机的引入就是为了防止饥饿问题的产生，如果咱们每次都是依照程序顺次执行的，若两个 case 始终都是满足条件的，那么前面的 case 永远都不会执行。

下面例子中的 select 用法是阻塞式的收发操作，直到有一个 channel 产生状态扭转。咱们也能够在 select 中应用 default 语句，那么 select 语句在执行时会遇到这两种状况：

当存在能够收发的 Channel 时，间接解决该Channel 对应的 case；
当不存在能够收发的Channel 时，执行 default 中的语句；

留神：nil channel上的操作会始终被阻塞，如果没有 default case, 只有nil channel 的select会始终被阻塞。

本文介绍了 Go 语言中的一些开发技巧，也就是 Go 语言的语法糖，把握好这些能够进步咱们的开发效率，你都学会了吗？

好啦，本文到这里就完结了，我是asong，咱们下期见。

欢送关注公众号：Golang 梦工厂

关于go:几个提升Go语言开发效率的小技巧

前言

可变长参数

申明不定长数组

`init`函数

疏忽导包

疏忽字段

json 序列化疏忽某个字段

json 序列化疏忽空值字段

短变量申明

类型断言

切片循环

判断 map 的 key 是否存在

select 控制结构

总结

Just My Socks（注册教程内含优惠码）

关于go:几个提升Go语言开发效率的小技巧

前言

可变长参数

申明不定长数组

init函数

疏忽导包

疏忽字段

json 序列化疏忽某个字段

json 序列化疏忽空值字段

短变量申明

类型断言

切片循环

判断 map 的 key 是否存在

select 控制结构

总结

Just My Socks（注册教程 内含优惠码）

`init`函数

Just My Socks（注册教程内含优惠码）