2023-Go全链路工程师课纲 https://www.processon.com/view/link/63594cd97d9c0854f9ac855e

一、搭建环境

https://studygolang.com/dl

msi需要自己安装

安装目录最好没有中文

1. 进入磁盘 D:, C:

2. 查看目录结构 dir

3. 进入目录 cd

4. 目录层级 .代表当前目录，..代表上一层目录

5. 补全 tab

6. 创建 md

7. 删除文件夹 rm

8. 删除文件 del

如果我想要在任意的路径下执行某个命令，需要将这个命令所在的目录配置到环境变量path中去

将命令“注册”到当前的计算机中：

解决如下错误：

加入环境变量后，需要重启 命令窗口

二、简单编写

在vscode中创建文件目录如下：

在命令行中执行go build命令进行编译，在运行.exe执行文件，可获得结果

或者是go run直接获取运行结果

如果先编译生成了可执行女件，那么我们可以将该可执行文件拷贝到没有go开发环境的机器上，仍然可以运行

如果直接go run go源代码，那么如果要在另外一个机器上这么运行，需要go开发环境，否则无法执行。

（1）源文件以"go"为扩展名。

（2）程序的执行入口是main()函数。

（3）严格区分大小写。

（4）方法由一条条语句构成，每个语句后不需要分号(Go语言会在每行后自动加分号)，这也体现出Golang的简洁性。

（5）Go编译器是一行行进行编译的，因此我们一行就写一条语句，不能把多条语句写在同一个，否则报错

（6）定义的变量或者import的包如果没有使用到，代码不能编译通过。

（7）大括号都是成对出现的，缺一不可

【1】注意缩进

向后缩进：tab

向前取消缩进：shift+tab

通过命令完成格式化操作：

【2】成对编程 {} （） “” ‘’

【3】运算符两边加空白

【4】注释：官方推荐行注释//

【5】以下代码是错误的：

原因：go的设计者想要开发者有统一的代码风格，一个问题尽量只有一个解决方案是最好的

【6】行长约定：

一行最长不超过80个字符，超过的请使用换行展示，尽量保持格式优雅

三、变量

变量相当于内存中一个数据存储空间的表示

package main
import "fmt"
func main ()  {
    var age int = 20
    fmt.Println("age = ", age)
}


//第一种：变量的使用方式：指定变量的类型，并且赋值，
        var num int = 18
        fmt.Println(num)
//第二种：指定变量的类型，但是不赋值，使用默认值
        var num2 int
        fmt.Println(num2)
//第三种：如果没有写变量的类型，那么根据=后面的值进行判定变量的类型 （自动类型推断）
        var num3 = "tom"
        fmt.Println(num3)
//第四种：省略var，注意 := 不能写为 =
        sex := "男"
        fmt.Println(sex)


 var n1,n2,n3 int
        fmt.Println(n1)
        fmt.Println(n2)
        fmt.Println(n3)

var n4,name,n5 = 10,"jack",7.8
        fmt.Println(n4)
        fmt.Println(name)
        fmt.Println(n5)

n6,height := 6.9,100.6
        fmt.Println(n6)
        fmt.Println(height)



//全局变量：定义在函数外的变量
var n7 = 100
var n8 = 9.7
//设计者认为上面的全局变量的写法太麻烦了，可以一次性声明：
var (
        n9 = 500
        n10 = "netty"
)
func main(){

四、进制转换

十进制整数，如：99, -500, 0

八进制整数，要求以 0 开头，如：015

十六进制数，要求 0x 或 0X 开头，如：0x15

二进制：要求0b或者0B开头，如：0b11

几进制：就是逢几进1的问题：

平时实际生活中用的最多的是：十进制

计算机用二进制最多

二进制： 1101

1*2^3  +   1*2^2   +  0*2^1  +     1*2^0

= 8 + 4 + 0 + 1

= 13

十进制 13

八进制： 16

1_8^1 + 6_8^0

= 8 + 6

=14

十进制14：

把十进制当做一个中转站：

八进制---》十进制---》十六进制

实际上根本不用自己转换这么麻烦：我们可以直接用系统中提供给我们的计算器：

五、数据类型

Golang程序中整型变量在使用时,遵守保小不保大的原则

即:在保证程序正确运行下,尽量使用占用空间小的数据类型

1.整数类型

1.1有符号整数类型

一字节占8位

PS:127怎么算出来的？

01111111 -->二进制 ---》转为十进制：

1_2^6 + 1_2^5 + 1_2^4 + 1_2^3 + 1_2^2 + 1_2^1 + 1*2^0

= 64 + 32 + 16 + 8 + 4 + 2 + 1

= 127

代码测试超出范围：

1.2无符号整数类型：

1.3其他整数类型：

2.浮点类型

种类

3.字符类型

【1】Golang中没有专门的字符类型，如果要存储单个字符(字母)，一般使用byte来保存。

【2】Golang中字符使用UTF-8编码

【3】ASCII码表：

左面是不可见字符 右面是可见字符

转义字符

4.布尔类型

【1】布尔类型也叫bool类型，bool类型数据只允许取值true和false

【2】布尔类型占1个字节。

【3】布尔类型适于逻辑运算，一般用于程序流程控制

【4】代码：

package main
import "fmt"
func main(){
        //测试布尔类型的数值：
        var flag01 bool = true
        fmt.Println(flag01)
        var flag02 bool = false
        fmt.Println(flag02)
        var flag03 bool = 5 < 9
        fmt.Println(flag03)
}

5.字符串类型（java中不属于基本数据类型）

字符串就是一串固定长度的字符连接起来的字符序列。

字符串的使用：

如果字符串中有特殊字符，字符串的表示形式用反引号 ``

package main
import "fmt"
func main(){
        //1.定义一个字符串：
        var s1 string = "你好全面拥抱Golang"
        fmt.Println(s1)
        //2.字符串是不可变的：指的是字符串一旦定义好，其中的字符的值不能改变
        var s2 string = "abc"
        //s2 = "def"
        //s2[0] = 't'
        fmt.Println(s2)
        //3.字符串的表示形式：
        //（1）如果字符串中没有特殊字符，字符串的表示形式用双引号
        //var s3 string = "asdfasdfasdf"
        //（2）如果字符串中有特殊字符，字符串的表示形式用反引号 ``
        var s4 string = `
        package main
        import "fmt"

        func main(){
                //测试布尔类型的数值：
                var flag01 bool = true
                fmt.Println(flag01)

                var flag02 bool = false
                fmt.Println(flag02)

                var flag03 bool = 5 < 9
                fmt.Println(flag03)
        }
        `
        fmt.Println(s4)
        //4.字符串的拼接效果：
        var s5 string = "abc" + "def"
        s5 += "hijk"
        fmt.Println(s5)
        //当一个字符串过长的时候：注意：+保留在上一行的最后
        var s6 string = "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" +
         "def"+ "abc" + "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+
          "abc" + "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+ "abc" +
           "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+ "abc" + "def" +
           "abc" + "def"+ "abc" + "def"
        fmt.Println(s6)
}

默认值

Go在不同类型的变量之间赋值时需要显式转换，并且只有显式转换(强制转换)。

package main
import "fmt"
func main(){
        //进行类型转换：
        var n1 int = 100
        //var n2 float32 = n1  在这里自动转换不好使，比如显式转换
        fmt.Println(n1)
        //fmt.Println(n2)
        var n2 float32 = float32(n1)
        fmt.Println(n2)
        //注意：n1的类型其实还是int类型，只是将n1的值100转为了float32而已，n1还是int的类型
        fmt.Printf("%T",n1)  //int
        fmt.Println()
        //将int64转为int8的时候，编译不会出错的，但是会数据的溢出
        var n3 int64 = 888888
        var n4 int8 = int8(n3)
        fmt.Println(n4)//56
        var n5 int32 = 12
        var n6 int64 = int64(n5) + 30  //一定要匹配=左右的数据类型
        fmt.Println(n5)
        fmt.Println(n6)
        var n7 int64 = 12
        var n8 int8 = int8(n7) + 127  //编译通过，但是结果可能会溢出
        //var n9 int8 = int8(n7) + 128 //编译不会通过
        fmt.Println(n8)
        //fmt.Println(n9)
}

3.1 方法一

package main
import "fmt"
func main(){
        var n1 int = 19
        var n2 float32 = 4.78
        var n3 bool = false
        var n4 byte = 'a'
        var s1 string = fmt.Sprintf("%d",n1)
        fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)
        var s2 string = fmt.Sprintf("%f",n2)
        fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)
        var s3 string = fmt.Sprintf("%t",n3)
        fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)
        var s4 string = fmt.Sprintf("%c",n4)
        fmt.Printf("s4对应的类型是：%T ，s4 = %q \n",s4, s4)
}

3.2 方法二

package main
import(
        "fmt"
        "strconv"
)
func main(){
        var n1 int = 18
        var s1 string = strconv.FormatInt(int64(n1),10)  //参数：第一个参数必须转为int64类型 ，第二个参数指定字面值的进制形式为十进制
        fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)
        var n2 float64 = 4.29
        var s2 string = strconv.FormatFloat(n2,'f',9,64)
        //第二个参数：'f'（-ddd.dddd）  第三个参数：9 保留小数点后面9位  第四个参数：表示这个小数是float64类型
        fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)
        var n3 bool = true
        var s3 string = strconv.FormatBool(n3)
        fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)
}

func main(){
        //string-->bool
        var s1 string = "true"
        var b bool
        //ParseBool这个函数的返回值有两个：(value bool, err error)
        //value就是我们得到的布尔类型的数据，err出现的错误
        //我们只关注得到的布尔类型的数据，err可以用_直接忽略
        b , _ = strconv.ParseBool(s1)
        fmt.Printf("b的类型是：%T,b=%v \n",b,b)
        //string---》int64
        var s2 string = "19"
        var num1 int64
        num1,_ = strconv.ParseInt(s2,10,64)
        fmt.Printf("num1的类型是：%T,num1=%v \n",num1,num1)
        //string-->float32/float64
        var s3 string = "3.14"
        var f1 float64
        f1,_ = strconv.ParseFloat(s3,64)
        fmt.Printf("f1的类型是：%T,f1=%v \n",f1,f1)
        //注意：string向基本数据类型转换的时候，一定要确保string类型能够转成有效的数据类型，否则最后得到的结果就是按照对应类型的默认值输出
        var s4 string = "golang"
        var b1 bool
        b1 , _ = strconv.ParseBool(s4)
        fmt.Printf("b1的类型是：%T,b1=%v \n",b1,b1)
        var s5 string = "golang"
        var num2 int64
        num2,_ = strconv.ParseInt(s5,10,64)
        fmt.Printf("num2的类型是：%T,num2=%v \n",num2,num2)
}