Java程序员的Go入门笔记

系列文章目录和关于我
0.背景

3年java开发背景（因此这篇文章的特点是：比较适合java程序员doge），业余时间有了解过一些go，如今主要技术栈是go，此篇主要结合go语言圣经和团队内go项目，总结一些基础知识。
另外文章中没有对if，switch ，for进行说明，看多了文中的例子，自然就会这部分了
1.程序结构

1.1.声明、赋值和类型

Go语言主要有四种类型的声明语句：var、const、type和func，分别对应变量、常量、类型和函数实体对象的声明
以下是一个 Go 语言程序结构的代码示例：

1. // 结构体声明
2. type MyStruct struct {
3.     name     string
4.     age      int8
5.     sex      bool
6.     userType UserType
7.     sub      *MyStruct
8.     keys     []string
9.     feature  map[string]any
10. }
12. // 类型
13. type UserType int64
14. // 常量声明
15. const (
16.     SUPER UserType = 1
17. )
19. func main() {
21.     // 常量声明
22.     const sexBool bool = false
23.     // 变量
24.     var userName string
25.     // 变量赋值
26.     userName = "username"
28.     //简短变量声明并赋值
29.     userAge := 1
30.     // map类型
31.     userFeature := make(map[string]any)
32.     // map赋值
33.     userFeature["key"] = "value"
34.     // 数组类型
35.     var keys []string = make([]string, 20)
36.     //数组类型赋值
37.     keys[0] = "!"
38.     // 结构体
39.     var subStruct = MyStruct{age: 1, userType: 1, sex: false, name: "1"}
40.     myStruct := MyStruct{age: int8(userAge), userType: SUPER, sex: sexBool,
41.     name: userName, feature: userFeature, sub: &subStruct, keys: keys}
42.    
43. }

复制代码

1.2.包和文件

包的概念和java中的包类似，不同的是导入包路径使用的是“/”进行分割

1. package main
3. import (
4.     "errors"
5.     "fmt"
6. )
7. import "code.byted.org/life_service/chenxinglandingdemo/compare" // 导入自定义的包

复制代码

该包中有一个文件int_comparator.go，定义了一个Compare函数

1. type IntPriority interface {
2.     GetPriority() int
3. }
5. func Compare(first IntPriority, second IntPriority) (int, error) {
6.     if first == nil || second == nil {
7.        return 0, errors.New("null input")
8.     }
9.     firstPriority := first.GetPriority()
10.     secondPriority := second.GetPriority()
11.     if firstPriority == secondPriority {
12.        return 0, nil
13.     }
14.     if firstPriority > secondPriority {
15.        return 1, nil
16.     }
17.     return -1, nil
18. }

复制代码

引入包后的使用例子

1. compare.Compare(&myStruct, &subStruct)

复制代码

其中大写开头的方法才被视为是public的，这点一开始让我觉得有点草率，但是似乎确实比java的private，protected，public用起来更爽一点
使用init方法可以对包文件的初始化，有点类似java类中的static静态代码块，但是无论该文件是否被使用，都会执行init，不像java只有使用到这个类执行类的初始化后才会执行static

1. package compare
3. import "fmt"
5. func init() {
6.     fmt.Println("init_method_learn.go")
7. }

复制代码

init方法的执行是依赖文件名称顺序的，因此如果A文件使用B文件中的方法是，也许B文件还没有调用init
2.基本数据类型

2.1 整形

Go语言同时提供了有符号和无符号类型的整数运算。这里有int8、int16、int32和int64四种截然不同大小的有符号整数类型，分别对应8、16、32、64bit大小的有符号整数，与此对应的是uint8、uint16、uint32和uint64四种无符号整数类型。
这里需要注意的是，int 和 uint 类型的大小取决于操作系统的位数。在32位操作系统中，int 和 uint 类型的大小通常为4字节（32位）；在64位操作系统中，它们的大小通常为8字节（64位）。我看我们系统中一般是没有直接使用int和unit的。
2.2 浮点数

Go语言提供了两种精度的浮点数，float32和float64。它们的算术规范由IEEE754浮点数国际标准定义，该浮点数规范被所有现代的CPU支持。
和其他语言一样，float32和float64都有一定精度误差

1. var f float32 = 16777216
2. // true
3. fmt.Println(f+1 == f)
5. var f64 float64 = 16777216
6. // true
7. fmt.Println(f64+0.000000000000001 == f64)

复制代码

在 IEEE 754 标准中，float32 类型的浮点数使用 32 位来存储，其中包括 1 位符号位（S）、8 位指数位（E）和 23 位尾数位（M）。对于数字 16777216，将其转换为二进制表示为 1000000000000000000000000。将其转换为 IEEE 754 格式的 float32 类型，具体步骤如下：

• 符号位 S：16777216 是正数，所以符号位 S 为 0。
  
• 指数位 E：将二进制数 1000000000000000000000000 右移 23 位，得到指数为 24。由于指数位的偏移量为 127，所以实际的指数值为 24 - 127 = -103。
  
• 尾数位 M：取二进制数 1000000000000000000000000 的后 23 位，即 00000000000000000000000，省略掉开头的 1。
  

因此，16777216 在 IEEE 754 存储中的表示为：0 10000001 00000000000000000000000。
对于数字 16777217，按照同样的步骤转换为 IEEE 754 格式的 float32 类型：

• 符号位 S：16777217 是正数，所以符号位 S 为 0。
  
• 指数位 E：将二进制数 1000000000000000000000001 右移 23 位，得到指数为 24。由于指数位的偏移量为 127，所以实际的指数值为 24 - 127 = -103。
  
• 尾数位 M：取二进制数 1000000000000000000000001 的后 23 位，即 000000000000000000000001，省略掉开头的 1。
  

所以，16777217 在 IEEE 754 存储中的表示也是：0 10000001 00000000000000000000000。
这就是为什么 16777216 和 16777217 在 IEEE 754 存储中看起来是一样的原因，它们的尾数位相同，而指数位也相同，只是在转换为十进制时，由于精度限制，会出现舍入误差，导致结果略有不同。
和java一样go也提供big来解决这个问题

1. // 使用 math/big 包进行高精度计算
2. a := new(big.Float).SetPrec(128).SetFloat64(0.000000000000001)
3. b := new(big.Float).SetPrec(128).SetFloat64(16777216)
4. c := new(big.Float).Add(a, b)
6. // 输出1，表示c大于b，符合预期
7. fmt.Println(c.Cmp(b))

复制代码

2.3 bool 布尔

类似于java中的boolean，在 Go 语言中，布尔型数据只有true和false两个值，没有像 Java 中那样的Boolean类型。
2.4 字符串

1. func main() {
3.     str := "testStr测试字符串"
5.     // 输出22 ===>7+15(汉子3个字符)
6.     fmt.Println(len(str))
7.     // 输出116 utf8编码
8.     var u uint8 = str[0]
9.     fmt.Println(u)
10.     // 输出116 utf8编码
11.     fmt.Println(str[0])
13.     // testStr
14.     fmt.Println(str[0:7])
15.     // testStr
16.     fmt.Println(str[:7])
17.     //测试字符串
18.     fmt.Println(str[7:])
19.     // 测试字符串
20.     fmt.Println(str[7:len(str)])
21.    
22.     // 字符串循环
23.     for i := range str {
24.        fmt.Println(string(str[i]))
25.     }
26.    
27. }

复制代码

如上是字符串常用的一些操作，go中的字符串也是不可变的
让我比较迷惑的是str[7:]这种字符串的操作似乎是深拷贝，但是有一些文档也说是浅拷贝
3.复合数据类型

3.1 数组

1. // 声明，然后赋值
2. ints := [10]int{}
3. ints[1] = 1
4. // 声明并赋值，没有赋值的index使用初值0
5. var ints2 [20]int = [20]int{1, 2, 3, 4, 5}
6. fmt.Println(ints2[19])
7. fmt.Println(len(ints2))
9. // 根据元素的个数来自动设置长度
10. ints3 := [...]int{1, 2, 3, 4, 5}
11. fmt.Println(len(ints3))
13. ints4 := [...]int{99: -1}
15. // 长度为100 = 99+1
16. fmt.Println(len(ints4))
18. ints5 := [5]int{1, 2, 3, 4, 5}
19. // true
20. fmt.Println(ints3 == ints5)

复制代码

其中我觉得比较有意思的是

• 数组的比较：
  

如果一个数组的元素类型是可以相互比较的，那么数组类型也是可以相互比较的，这时候我们可以直接通过==比较运算符来比较两个数组，只有当两个数组的所有元素都是相等的时候数组才是相等的。不相等比较运算符!=遵循同样的规则。

• 数组类型
  

[5]int和[20]int是不同的类型
因此两个不太类型的数组是不可以比较的

以及也不能把[5]int类型的变量使用=赋值一个[20]int 类型的变量

<ul>数组作为参数<ul>
数组作为参数是值传递，这意味着下面clearArray1方法是无法清空数组内容的，使用指针的clearArray2是可以清空的（这也启发我们，比较占用内存的变量应该使用指针，因为指针作为参数值拷贝浪费的内存少，拷贝的是指针对象！）

• 1. func clearArray1(array [5]int) {
  2.     for i := range array {
  3.        array[i] = 0
  4.     }
  5. }
  7. func clearArray(array *[5]int) {
  8.     for i := range array {
  9.        array[i] = 0
  10.     }
  11. }

  复制代码

因为[5]int和[20]int是不太同的数组类型，因此上面两个函数，都只能穿入长度为5的数组，这一点让我觉得有点恶心
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！