• Go学习笔记1

    学习路线

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

    一、搭建环境

    https://studygolang.com/dl

    msi需要自己安装

    安装目录最好没有中文

    image-20230905000254963

    1. 简单dos命令

    1. 进入磁盘 D:, C:

    2. 查看目录结构 dir

    3. 进入目录 cd

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

    5. 补全 tab

    6. 创建 md

    7. 删除文件夹 rm

    8. 删除文件 del

    2. 环境变量配置

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

    image-20230905134513128

    image-20230905134807376

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

    二、简单编写

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

    image-20230905191629857

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

    image-20230905191559952

    1.执行流程

    image-20230905192122313

    如果先编译生成了可执行女件，那么我们可以将该可执行文件拷贝到没有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】以下代码是错误的：

    image-20230905193712615

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

    【6】行长约定：

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

    image-20230905193729350

    三、变量

    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(){

    四、进制转换

    1.进制的介绍：

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

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

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

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

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

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

    image-20230905200734719

    2.二进制转换为十进制

    二进制： 1101

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

    = 8 + 4 + 0 + 1
    = 13

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

    十进制 13

    image-20230905201614421

    4.八进制转换十进制：

    八进制： 16

    18^1 + 68^0
    = 8 + 6
    =14

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

    十进制14：

    image-20230905201622509

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

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

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

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

    image-20230905201633617

    五、数据类型

    如何选择

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

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

    image-20230905200321360

    1.基本数据类型

    1.整数类型

    1.1有符号整数类型

    一字节占8位

    image-20230905201924985

    PS:127怎么算出来的？
    01111111 -->二进制 ---》转为十进制：
    12^6 + 12^5 + 12^4 + 12^3 + 12^2 + 12^1 + 1*2^0
    = 64 + 32 + 16 + 8 + 4 + 2 + 1
    = 127

    代码测试超出范围：

    image-20230905202021547

    1.2无符号整数类型：

    image-20230905202217844

    1.3其他整数类型：

    image-20230905202339316

    2.浮点类型

    种类

    image-20230905202815586

    3.字符类型

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

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

    【3】ASCII码表：

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

    转义字符

    image-20230905203922863

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

    默认值

    image-20230905205833245

    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 方法一

    image-20230905225615591

    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 方法二

    image-20230905225712317

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

    __EOF__

  • 本文作者： 郜宇博
  • 本文链接： https://www.cnblogs.com/Gao-yubo/p/17681148.html
  • 关于博主： 评论和私信会在第一时间回复。或者直接私信我。
  • 版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
  • 声援博主： 如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。
  • 相关阅读:
    读gaitset代码
    wps文件误删除了怎么恢复？如何找回被误删的WPS文件？
    vscode篇---设置python路径，项目主目录和添加参数
    距离矢量路由协议RIP(含Cisco模拟器实验命令配置)
    python-web开发[20]之开发小结
    Day696.Jetty如何实现具有上下文信息的责任链 -深入拆解 Tomcat & Jetty
    java毕业设计选题基于SSM项目源码实现的校园食堂点餐|订餐系统
    C++入门——引用|内联函数|auto关键字|基于范围的for循环|指针空值
    发电行业中的5G组网模式分析
    PCL入门（一）：ubuntu20使用apt安装pcl
  • 原文地址：https://www.cnblogs.com/Gao-yubo/p/17681148.html