go的学习笔记

🕗 发布于 2024-09-19 18:40 golang 学习笔记

第一段代码

所有代码的主文件都是main.go,下面的代码直接在项目里面创建main.go运行

package main // 声明文件所在的包,每个go文件必须有归属的包

import "fmt" // 引入程序需要的包,为了使用包下的函数,比如Println

func main() {
    // 程序的主函数,程序的运行入口
fmt.Println("Hello World")  // 在控制台打印输出一句话
}

如果是vscode等工具需要执行go run main.go来运行,我这里使用的是goLand右键直接运行了

注意事项:

源文件以.go为扩展名
程序的执行入口是main()函数
严格区分大小写
方法由一条条语句构成,每个语句后面不需要加分号,这也体现出go的简洁性
Go编译器是一行行进行编译的,因此一行就写一条语句,不能把多个语句写在同一行,否则报错
定义的变量或者import的包如果没有使用到,代码不能编译通过
大括号都是成对出现的,缺一不可

变量的定义和使用

package main

import "fmt"

// 全局变量: 定义在函数外的变量
var n9 = 100
var n10 = 9.7

// 一次性定义多个全局变量
var (
n11 = 12
n12 = "你好"
)

func main() {
   
// 定义在{}中的变量叫: 局部变量

// 变量重复定义会报错
var name string   // 声明变量和类型
name = "小明"       // 赋值变量
fmt.Println(name) // 打印值

var age int = 18 // 声明变量和类型并赋值
fmt.Println(age)

var address = "北京" // 声明没指定类型时,根据后面的值的类型自动推断类型
//address = 12 // 报错,因为上面类型推断为string
fmt.Println(address)

stuName := "萧寂"                 // 声明和赋值
fmt.Println("学生姓名为: ", stuName) // 打印值

//count = 1  // 不能直接写等于号,除非:=或者var count = 1  必须要声明

fmt.Println("--------------------------------------------")
// 声明多个变量不赋值
var n1, n2, n3 int
fmt.Println(n1, n2, n3) // 不赋值情况下会打印每个类型的原始值

// 声明多个变量并赋值
var n4, n5, n6 = 14, "jack", 12.7
fmt.Println(n4, n5, n6) // 声明多个变量并赋值

n7, n8 := 12, "hahaha"
fmt.Println(n7, n8)

// 打印全局变量
fmt.Println(n9, n10, n11, n12)
}

数据类型介绍

基本数据类型
- 数值型
  - 整数类型(int,int8,int16,int32,int64,uint,uint8,uint16,uint32,uint64,byte)
  - 浮点类型(float32,float64)
- 字符型(没有单独的字符型,使用byte来保存单个字母字符)
- 布尔型(bool)
- 字符串(string)
派生数据类型(也是复杂数据类型)
- 指针
- 数组
- 结构体
- 管道
- 函数
- 切片
- 接口
- map

整数类型

package main

import (
"fmt"
"unsafe"
)

func main() {
   
//整数类型
// 定义一个整数类型
//var num1 int8 = 230 // 报错(230超出int8范围)
//fmt.Println(num1)

// 定义整数类型
var num2 = -20
fmt.Println(num2)

// 打印类型
// 其他占位符的使用: https://www.jianshu.com/p/66aaf908045e
fmt.Printf("num2的类型是: %T", num2)
fmt.Println()                    // 换行作用
fmt.Println(unsafe.Sizeof(num2)) // 打印字节数

// 定义byte类型
var num3 byte = 20
fmt.Println(num3)
}

浮点类型

package main

import "fmt"

func main() {
   
//定义浮点类型的数据
var num1 float32 = 3.14
var num2 float64 = 3.15
fmt.Println(num1, num2)
}

字符类型

package main

import "fmt"

func main() {
   
// 定义字符类型的数据
var c1 byte = 'a'
var c2 byte = 'b'
var c3 byte = '('
var c4 byte = '6'
var c5 int = '中' // 底层是Unicode编码
fmt.Println(c1, c2, c3, c4, c5)
}

布尔类型

package main

import "fmt"

func main() {
   
//测试布尔类型的数值
var flag1 bool = true
var flag2 bool = false
var flag3 = 5 < 9
fmt.Println(flag1, flag2, flag3)
}

字符串类型

package main

import "fmt"

func main() {
   
//测试布尔类型的数值
var str string = "你好"
var str2 string = "世界"
fmt.Println(str)
fmt.Println(str+str2)
}

基本数据类型之间的转换

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

基本数据类型转string

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

string转基本数据类型

package main

import (
"fmt"
"strconv"
)

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

指针

package main

import (
"fmt"
)

func main() {
   
var age int = 18
//&符号+变量 就可以获取这个变量内存的地址
fmt.Println(&age) //0xc0000a2058
//定义一个指针变量：
//var代表要声明一个变量
//ptr 指针变量的名字
//ptr对应的类型是：*int 是一个指针类型 （可以理解为 指向int类型的指针）
//&age就是一个地址，是ptr变量的具体的值
var ptr *int = &age
fmt.Println(ptr)
fmt.Println("ptr本身这个存储空间的地址为：", &ptr)
//想获取ptr这个指针或者这个地址指向的那个数据：
fmt.Printf("ptr指向的数值为：%v", *ptr) //ptr指向的数值为：18
}

运算符

算术运算符

package main

import "fmt"

func main() {
   
//+加号：
//1.正数 2.相加操作  3.字符串拼接
var n1 int = +10
fmt.Println(n1)
var n2 int = 4 + 7
fmt.Println(n2)
var s1 string = "abc" + "def"
fmt.Println(s1)
// /除号：
fmt.Println(10 / 3)   //两个int类型数据运算，结果一定为整数类型
fmt.Println(10.0 / 3) //浮点类型参与运算，结果为浮点类型
// % 取模  等价公式： a%b=a-a/b*b
fmt.Println(10 % 3) // 10%3= 10-10/3*3 = 1
fmt.Println(-10 % 3)
fmt.Println(10 % -3)
fmt.Println(-10 % -3)
//++自增操作：
var a int = 10
a++
fmt.Println(a)
a--
fmt.Println(a)
//++ 自增 加1操作，--自减，减1操作
//go语言里，++，--操作非常简单，只能单独使用，不能参与到运算中去
//go语言里，++，--只能在变量的后面，不能写在变量的前面 --a  ++a  错误写法
}

赋值运算符

package main

import "fmt"

func main() {
   
var num1 int = 10
fmt.Println(num1)
var num2 int = (10+20)%3 + 3 - 7 //=右侧的值运算清楚后，再赋值给=的左侧
fmt.Println(num2)
var num3 int = 10
num3 += 20 //等价num3 = num3 + 20;
fmt.Println(num3)

//练习：交换两个数的值并输出结果：
var a int = 8
var b int = 4
fmt.Printf("a = %v,b = %v", a, b)
//交换：
//引入一个中间变量：
var t int
t = a
a = b
b = t
fmt.Printf("a = %v,b = %v", a, b)
}

关系运算符

package main

import "fmt"

func main() {
   
fmt.Println(5 == 9) //判断左右两侧的值是否相等，相等返回true，不相等返回的是false， ==不是=
fmt.Println(5 != 9) //判断不等于
fmt.Println(5 > 9)
fmt.Println(5 < 9)
fmt.Println(5 >= 9)
fmt.Println(5 <= 9)
}

逻辑运算符

package main

import "fmt"

func main() {
   
//与逻辑：&& :两个数值/表达式只要有一侧是false，结果一定为false
//也叫短路与：只要第一个数值/表达式的结果是false，那么后面的表达式等就不用运算了，直接结果就是false  -->提高运算效率
fmt.Println(true && true)
fmt.Println(true && false)
fmt.Println(false && true)
fmt.Println(false && false)
//或逻辑：||:两个数值/表达式只要有一侧是true，结果一定为true
//也叫短路或：只要第一个数值/表达式的结果是true，那么后面的表达式等就不用运算了，直接结果就是true -->提高运算效率
fmt.Println(true || true)
fmt.Println(true || false)
fmt.Println(false || true)
fmt.Println(false || false)
//非逻辑：取相反的结果：
fmt.Println(!true)
fmt.Println(!false)
}

获取用户终端输入数据

package main

import "fmt"

func main() {
   
//实现功能：键盘录入学生的年龄，姓名，成绩，是否是VIP
//方式1：Scanln
var age int
// fmt.Println("请录入学生的年龄：")
//传入age的地址的目的：在Scanln函数中，对地址中的值进行改变的时候，实际外面的age被影响了
//fmt.Scanln(&age)//录入数据的时候，类型一定要匹配，因为底层会自动判定类型的
var name string
// fmt.Println("请录入学生的姓名：")
// fmt.Scanln(&name)
var score float32
// fmt.Println("请录入学生的成绩：")
// fmt.Scanln(&score)
var isVIP bool
// fmt.Println("请录入学生是否为VIP：")
// fmt.Scanln(&isVIP)
//将上述数据在控制台打印输出：
//fmt.Printf("学生的年龄为：%v,姓名为：%v,成绩为：%v,是否为VIP:%v",age,name,score,isVIP)
//方式2：Scanf
fmt.Println("请录入学生的年龄，姓名，成绩，是否是VIP，使用空格进行分隔")
fmt.Scanf("%d %s %f %t", &age, &name, &score, &isVIP)
//将上述数据在控制台打印输出：
fmt.Printf("学生的年龄为：%v,姓名为：%v,成绩为：%v,是否为VIP:%v", age, name, score, isVIP)
}

流程控制语句

if语句

单分支

package main
import "fmt"
func main(){
   
        //实现功能：如果口罩的库存小于30个，提示：库存不足：
        //var count int = 100
        //单分支：
        // if count < 30 {
   
        // fmt.Println("对不起，口罩存量不足")
        // }
        //if后面表达式，返回结果一定是true或者false，
        //如果返回结果为true的话，那么{}中的代码就会执行
        //如果返回结果为false的话，那么{}中的代码就不会执行
        //if后面一定要有空格，和条件表达式分隔开来
        //{}一定不能省略
        //条件表达式左右的()是建议省略的
        //在golang里，if后面可以并列的加入变量的定义：
        if count := 20;count < 30 {
   
                fmt.Println("对不起，口罩存量不足")
        }
}

双分支

package main

import "fmt"

func main() {
   
//实现功能：如果口罩的库存小于30个，提示：库存不足,否则提示：库存充足
//定义口罩的数量：
var count int = 70
if count < 30 {
    //这个条件表达式返回的是true的话，后面{}执行了
fmt.Println("库存不足")
} else {
    //count >= 30
fmt.Println("库存充足")
}
//双分支一定会二选一走其中一个分支。

}

多分支

package main

import "fmt"

func main() {
   
//实现功能：根据给出的学生分数，判断学生的等级：
// >=90  -----A
// >=80  -----B
// >=70  -----C
// >=60  -----D
// <60   -----E
//方式1：利用if单分支实现：
//定义一个学生的成绩：
var score int = 18
//对学生的成绩进行判定：
// if score >= 90 {
   
// fmt.Println("您的成绩为A级别")
// }
// if score >= 80 && score < 90 {
   
// fmt.Println("您的成绩为B级别")
// }
// if score >= 70 && score < 80 {
   
// fmt.Println("您的成绩为C级别")
// }
// if score >= 60 && score < 70 {
   
// fmt.Println("您的成绩为D级别")
// }
// if score < 60 {
   
// fmt.Println("您的成绩为E级别")
// }
//上面方式1利用多个单分支拼凑出多个选择，多个选择是并列的，依次从上而下顺序执行，即使走了第一个分支，那么其它分支也是需要判断

//方式2：多分支：优点：如果已经走了一个分支了，那么下面的分支就不会再去判断执行了
// if score >= 90 {
   
// fmt.Println("您的成绩为A级别")
// } else if score >= 80 {//else隐藏：score < 90
// fmt.Println("您的成绩为B级别")
// } else if score >= 70 {//score < 80
// fmt.Println("您的成绩为C级别")
// } else if score >= 60 {//score < 70
// fmt.Println("您的成绩为D级别")
// } else {//score < 60
// fmt.Println("您的成绩为E级别")
// } //建议你保证else的存在，只有有了else才会真正 起到多选一 的效果
if score > 10 {
   
fmt.Println("aaa")
} else if score > 6 {
   
fmt.Println("bbb")
}
}

switch语句

package main

import "fmt"

func main() {
   
//实现功能：根据给出的学生分数，判断学生的等级：
// >=90  -----A
// >=80  -----B
// >=70  -----C
// >=60  -----D
// <60   -----E
//给出一个学生分数：
var score int = 187
//根据分数判断等级：
//switch后面是一个表达式，这个表达式的结果依次跟case进行比较，满足结果的话就执行冒号后面的代码。
//default是用来“兜底”的一个分支，其它case分支都不走的情况下就会走default分支
//default分支可以放在任意位置上，不一定非要放在最后。
switch score / 10 {
   
case 10:
fmt.Println("您的等级为A级")
case 9:
fmt.Println("您的等级为A级")
case 8:
fmt.Println("您的等级为B级")
case 7:
fmt.Println("您的等级为C级")
case 6:
fmt.Println("您的等级为D级")
case 5:
fmt.Println("您的等级为E级")
case 4:
fmt.Println("您的等级为E级")
case 3:
fmt.Println("您的等级为E级")
case 2:
fmt.Println("您的等级为E级")
case 1:
fmt.Println("您的等级为E级")
case 0:
fmt.Println("您的等级为E级")
default:
fmt.Println("您的成绩有误")
}

}

注意事项：

switch后是一个表达式(即:常量值、变量、一个有返回值的函数等都可以)
case后面的值如果是常量值(字面量)，则要求不能重复
case后的各个值的数据类型，必须和 switch 的表达式数据类型一致
case后面可以带多个值，使用逗号间隔。比如 case 值1,值2…
case后面不需要带break
default语句不是必须的，位置也是随意的。
switch后也可以不带表达式，当做if分支来使用
switch后也可以直接声明/定义一个变量，分号结束，不推荐
switch穿透，利用fallthrough关键字，如果在case语句块后增加fallthrough ,则会继续执行下一个case,也叫switch穿透。

循环

for循环

go语言只有for循环

package main

import "fmt"

func main() {
   
//实现一个功能：求和： 1+2+3+4+5：
//求和：
//利用for循环来解决问题：
var sum int = 0
for i := 1; i <= 5; i++ {
   
sum += i
}

//输出结果：
fmt.Println(sum)
// for循环的语法格式：
// for 初始表达式; 布尔表达式（条件判断）; 迭代因子 {
   
// 循环体;--》反复重复执行的内容
// }
// 注意：for的初始表达式 不能用var定义变量的形式，要用:=
// 注意：for循环实际就是让程序员写代码的效率高了，但是底层该怎么执行还是怎么执行的，底层效率没有提高，只是程序员写代码简洁了而已
}

细节1:格式灵活

package main

import "fmt"

func main() {
   
i := 1       //变量的初始化
for i <= 5 {
    //条件表达式。判断条件
fmt.Println("你好 Golang") //循环体
i++                      //迭代
}
}

细节2:死循环

package main

import "fmt"

func main() {
   
//死循环：
// for {
   
// fmt.Println("你好 Golang")
// }
for {
   
fmt.Println("你好 Golang")
}
}

for renge键值对循环

（键值循环） for range结构是Go语言特有的一种的迭代结构，在许多情况下都非常有用，for range 可以遍历数组、切片、字符串、map 及通道，for range 语法上类似于其它语言中的 foreach 语句

package main

import "fmt"

func main() {
   
//定义一个字符串：
var str string = "hello golang你好"
//方式1：普通for循环：按照字节进行遍历输出的 （暂时先不使用中文）
// for i := 0;i < len(str);i++ {//i:理解为字符串的下标
// fmt.Printf("%c \n",str[i])
// }
//方式2：for range
for i, value := range str {
   
fmt.Printf("索引为：%d,具体的值为：%c \n", i, value)
}
//对str进行遍历，遍历的每个结果的索引值被i接收，每个结果的具体数值被value接收
//遍历对字符进行遍历的
}

关键字

break

switch分支中，每个case分支后都用break结束当前分支，但是在go语言中break可以省略不写。
break可以结束正在执行的循环
break的作用结束离它最近的循环

package main
import "fmt"
func main(){
   
        //功能：求1-100的和，当和第一次超过300的时候，停止程序
        var sum int = 0
        for i := 1 ; i <= 100 ; i++ {
   
                sum += i
                fmt.Println(sum)
                if sum >= 300 {
   
                        //停止正在执行的这个循环：
                        break 
                }
        }
        fmt.Println("-----ok")
}

深入理解

package main
import "fmt"
func main(){
   
        //双重循环：
        for i := 1; i <= 5; i++ {
   
                for j := 2; j <= 4; j++ {
   
                        fmt.Printf("i: %v, j: %v \n",i,j)
                        if i == 2 && j == 2 {
   
                                break
                        }
                }
        }
}

标签的使用展示

package main

import "fmt"

func main() {
   
//双重循环：
label2:
for i := 1; i <= 5; i++ {
   
for j := 2; j <= 4; j++ {
   
fmt.Printf("i: %v, j: %v \n", i, j)
if i == 2 && j == 2 {
   
break label2 //结束指定标签对应的循环
}
}
}
fmt.Println("-----ok")
}

continue

continue的作用是结束离它近的那个循环，继续离它近的那个循环

package main
import "fmt"
func main(){
   
        //功能：输出1-100中被6整除的数：
        //方式1：
        // for i := 1; i <= 100; i++ {
   
        // if i % 6 == 0 {
   
        // fmt.Println(i)
        // }
        // }
        //方式2：
        for i := 1; i <= 100; i++ {
   
                if i % 6 != 0 {
   
                        continue //结束本次循环，继续下一次循环
                }
                fmt.Println(i)
        }
}