学习路线

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

1、搭建环境

https://studygolang.com/dl 。

msi需要自己安装 。

安装目录最好没有中文 。

1. 简单dos命令

1. 进入磁盘 D:, C

2. 查看目录结构 dir 。

3. 进入目录 cd 。

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

5. 补全 tab 。

6. 创建 md 。

7. 删除文件夹 rm 。

8. 删除文件 del 。

2. 环境变量配置

如果我想要在任意的路径下执行某个命令，需要将这个命令所在的目录配置到环境变量path中去 将命令“注册”到当前的计算机中： 解决如下错误:

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

2、简单编写

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

在命令行中执行go build命令进行编译，在运行.exe执行文件，可获得结果 或者是go run直接获取运行结果 。

1.执行流程

如果先 编译生成了可执行女件 ，那么我们可以将该可执行文件拷贝到 没有go开发环境 的机器上， 仍然可以运行 如果直接go run go源代码，那么如果要在另外一个机器上这么运行，需要go开发环境，否则无法执行.

2.语法注意事项

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

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

（3）严格区分大小写.

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

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

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

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

3.代码风格

【1】注意缩进 向后缩进：tab 向前取消缩进：shift+tab 通过命令完成格式化操作:

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

【3】运算符两边加空白 。

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

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

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

【6】行长约定:

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

3、变量

1.声明与使用

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

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

                        
                      

2.多种使用方式

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

                        
                      

3.支持多变量声明

                        
                           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)
  

                        
                      

4.全局变量（两种）

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

                        
                      

4、进制转换

1.进制的介绍：

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

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

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

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

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

平时实际生活中用的最多的是：十进制 计算机用二进制最多 。

2.二进制转换为十进制

二进制： 1101 。

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

                        
                      

= 8 + 4 + 0 + 1 = 13 。

3.十进制转换为二进制：

十进制 13 。

4.八进制转换十进制：

八进制： 16 。

1 8^1 + 6 8^0 = 8 + 6 =14 。

5.十进制转换为八进制：

十进制14:

6.八进制转换为十六进制：

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

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

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

5、数据类型

如何选择

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

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

1.基本数据类型

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)
}

                        
                      

默认值

2.基本数据类型转换

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.基础数据类型转String类型

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)
}


                        
                      

4.String类型转为基础数据类型

                        
                          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)
}

                        
                      

最后此篇关于Go学习笔记1的文章就讲到这里了,如果你想了解更多关于Go学习笔记1的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。