Golang 【basic_leaming】常用函数 C

阅读目录

• ​​基础​​

• ​​如何高效地拼接字符串​​

• ​​1 "+"​​
• ​​2 fmt.Sprintf​​
• ​​3 strings.Builder​​
• ​​4 bytes.Buffer​​
• ​​5 strings.join​​
• ​​性能比较：​​
• ​​5种拼接方法的实例代码​​

• ​​什么是 rune 类型​​
• ​​支持默认参数或可选参数吗？​​
• ​​如何交换 2 个变量的值？​​
• ​​Go 语言 tag 的用处？​​
• ​​如何获取一个结构体的所有tag？​​
• ​​如何判断 2 个字符串切片（slice) 是相等的？​​
• ​​结构体打印时，%v 和 %+v 的区别​​
• ​​Go 语言中如何表示枚举值(enums)？​​
• ​​空 struct{} 的用途​​
• ​​go 里面的 int 和 int32 是同一个概念吗？​​

• ​​实现原理​​

• ​​init() 函数是什么时候执行的？​​
• ​​如何知道一个对象是分配在栈上还是堆上？​​
• ​​2 个 interface 可以比较吗 ？​​
• ​​2 个 nil 可能不相等吗？​​

基础

如何高效地拼接字符串

拼接字符串的方式有：

• ​​+​​
• fmt.Sprintf
• strings.Builder
• bytes.Buffer
• strings.Join

1 “+”

使用+操作符进行拼接时，会对字符串进行遍历，计算并开辟一个新的空间来存储原来的两个字符串。

2 fmt.Sprintf

由于采用了接口参数，必须要用反射获取值，因此有性能损耗。

3 strings.Builder

用 WriteString() 进行拼接，内部实现是指针+切片，同时String()返回拼接后的字符串，它是直接把 []byte 转换为string，从而避免变量拷贝。

4 bytes.Buffer

bytes.Buffer是一个一个缓冲byte类型的缓冲器，这个缓冲器里存放着都是byte，

bytes.buffer底层也是一个[]byte切片。

5 strings.join

strings.join 也是基于strings.builder来实现的,并且可以自定义分隔符，在join方法内调用了b.Grow(n)方法，这个是进行初步的容量分配，而前面计算的n的长度就是我们要拼接的slice的长度，因为我们传入切片长度固定，所以提前进行容量分配可以减少内存分配，很高效。

性能比较：

​​strings.Join ≈ strings.Builder > bytes.Buffer > "+" > fmt.Sprintf​​

5种拼接方法的实例代码

package main

import (
  "bytes"
  "fmt"
  "strings"
)

func main() {
  a := []string{"a", "b", "c"}
  //方式1：+
  ret := a[0] + a[1] + a[2]

  //方式2：fmt.Sprintf
  ret := fmt.Sprintf("%s%s%s", a[0], a[1], a[2])

  //方式3：strings.Builder
  var sb strings.Builder
  sb.WriteString(a[0])
  sb.WriteString(a[1])
  sb.WriteString(a[2])
  ret := sb.String()

  //方式4：bytes.Buffer
  buf := new(bytes.Buffer)
  buf.Write(a[0])
  buf.Write(a[1])
  buf.Write(a[2])
  ret := buf.String()
  
  //方式5：strings.Join
  ret := strings.Join(a, "")
}

什么是 rune 类型

ASCII 码只需要 7 bit 就可以完整地表示，但只能表示英文字母在内的128个字符，为了表示世界上大部分的文字系统，发明了 Unicode， 它是ASCII的超集，包含世界上书写系统中存在的所有字符，并为每个代码分配一个标准编号（称为Unicode CodePoint），在 Go 语言中称之为 rune，是 int32 类型的别名。

Go 语言中，字符串的底层表示是 byte (8 bit) 序列，而非 rune (32 bit) 序列。

sample := "我爱GO"
runeSamp := []rune(sample)
runeSamp[0] = '你'
fmt.Println(string(runeSamp))  // "你爱GO"
fmt.Println(len(runeSamp))  // 4

一个汉字 = 2字节

1字节（Byte)＝8字位＝8个二进制数

1字位(bit)＝1个二进制数

1B=8b

1KB=1024B

1MB=1024KB

1GB=1024MB

b称为字位、B称为字节、KB称为千字节、MB称为兆字节、GB称为吉字节。

支持默认参数或可选参数吗？

不支持。但是可以利用结构体参数，或者…传入参数切片数组。

// 这个函数可以传入任意数量的整型参数
func sum(nums ...int) {
    total := 0
    for _, num := range nums {
        total += num
    }
    fmt.Println(total)
}

如何交换 2 个变量的值？

• 变量 ​​a,b = b,a；​​
• 指针 ​​*a,*b = *b, *a​​

Go 语言 tag 的用处？

tag 可以为结构体成员提供属性。

常见的：

• json：序列化或反序列化时字段的名称
• db: sqlx 模块中对应的数据库字段名
• form: gin框架中对应的前端的数据字段名
• binding: 搭配 form 使用, 默认如果没查找到结构体中的某个字段则不报错值为空, binding为 required 代表没找到返回错误给前端。

如何获取一个结构体的所有tag？

利用反射：

package main

import (
  "fmt"
  "reflect"
)

type Author struct {
  Name         int      `json:Name`
  Publications []string `json:Publication,omitempty`
}

func main() {

  t := reflect.TypeOf(Author{})

  for i := 0; i < t.NumField(); i++ {
    name := t.Field(i).Name
    s, _ := t.FieldByName(name)
    fmt.Println(name, s.Tag)
  }

}

PS E:\TEXT\test_go\test\case> go run .\case.go
Name json:Name
Publications json:Publication,omitempty
PS E:\TEXT\test_go\test\case>

上述例子中，reflect.TypeOf方法获取对象的类型，之后NumField()获取结构体成员的数量。

通过 ​​Field(i)​​​ 获取第 ​​i​​​ 个成员的名字。
再通过其 Tag 方法获得标签。

如何判断 2 个字符串切片（slice) 是相等的？

这个是是顺序一致的比较，如果需要不一致的比较需要转成 map 类型。

​​reflect.DeepEqual() ​​， 但反射非常影响性能。

结构体打印时，%v 和 %+v 的区别

​​%v​​ 输出结构体各成员的值；

​​%+v​​ 输出结构体各成员的名称和值；

​​%#v​​ 输出结构体名称和结构体各成员的名称和值；

Go 语言中如何表示枚举值(enums)？

在常量中用 iota 可以表示枚举。
iota从0开始。

const (
  B = 1 << (10 * iota)
  KiB 
  MiB
  GiB
  TiB
  PiB
  EiB
)

空 struct{} 的用途

用 map 模拟一个 set，那么就要把值置为 struct{}，struct{} 本身不占任何空间，可以避免任何多余的内存分配。

package main

import "fmt"

type Set map[string]struct{}

func main() {
  set := make(Set)

  for _, item := range []string{"A", "A", "B", "C"} {
    set[item] = struct{}{}
  }

  fmt.Println(len(set)) // 3

  if _, ok := set["A"]; ok {
    fmt.Println("A exists") // A exists
  }
}

有时候给通道发送一个空结构体, ​​channel<-struct{}{}​​ ，也是节省了空间。

package main

func main() {
  ch := make(chan struct{}, 1)
  go func() {
    <-ch
    // do something
  }()
  ch <- struct{}{}
  // ...
}

仅有方法的结构体：​​type Lamp struct{}​​

go 里面的 int 和 int32 是同一个概念吗？

不是一个概念！千万不能混淆。

go语言中的 int 的大小是和操作系统位数相关的，如果是32位操作系统，int类型的大小就是4字节。如果是64位操作系统，int类型的大小就是8个字节。

除此之外uint也与操作系统有关。

int8占1个字节，int16占2个字节，int32占4个字节，int64占8个字节。

实现原理

init() 函数是什么时候执行的？

简答： 在 main 函数之前执行。

详细：
init() 函数是go初始化的一部分，由runtime初始化每个导入的包，初始化不是按照从上到下的导入顺序，而是按照解析的依赖关系，没有依赖的包最先初始化。

每个包首先初始化包作用域的常量和变量（常量优先于变量），然后执行包的init()函数。

同一个包，甚至是同一个源文件可以有多个init()函数。

init()函数没有入参和返回值，不能被其他函数调用，同一个包内多个init()函数的执行顺序不作保证。

执行顺序：​​import –> const –> var –>init()–>main()​​

一个文件可以有多个init()函数！

如何知道一个对象是分配在栈上还是堆上？

Go和C++不同，Go局部变量会进行逃逸分析。

如果变量离开作用域后没有被引用，则优先分配到栈上，否则分配到堆上。

那么如何判断是否发生了逃逸呢？

​​go build -gcflags '-m -m -l' xxx.go​​

关于逃逸的可能情况：

变量大小不确定，变量类型不确定，变量分配的内存超过用户栈最大值，暴露给了外部指针。

2 个 interface 可以比较吗 ？

Go 语言中，interface 的内部实现包含了 2 个字段，类型 T 和值 V，interface 可以使用 ​​==​​​ 或 ​​!=​​ 比较。

2 个 interface 相等有以下 2 种情况：

1、两个 interface 均等于 nil（此时 V 和 T 都处于 unset 状态）
2、类型 T 相同，且对应的值 V 相等。

看下面的例子：

package main

import "fmt"

type Stu struct {
  Name string
}

type StuInt interface{}

func main() {
  var stu1, stu2 StuInt = &Stu{"Tom"}, &Stu{"Tom"}
  var stu3, stu4 StuInt = Stu{"Tom"}, Stu{"Tom"}
  fmt.Println(stu1 == stu2) // false
  fmt.Println(stu3 == stu4) // true
}

stu1 和 stu2 对应的类型是 ​​*Stu​​，值是 Stu 结构体的地址，两个地址不同，因此结果为 false。

stu3 和 stu4 对应的类型是 Stu，值是 Stu 结构体，且各字段相等，因此结果为 true。

2 个 nil 可能不相等吗？

可能不等。interface 在运行时绑定值，只有值为 nil 接口值才为 nil，但是与指针的 nil 不相等。

举个例子：

package main

import "fmt"

func main() {
  var p *int = nil
  var i interface{} = nil
  if p == i {
    fmt.Println("Equal")
  }
}

两者并不相同。
总结：两个 nil 只有在类型相同时才相等。