当前位置：首页 > news >正文

go的学习笔记

news 来源：原创 2025/5/13 19:40:29

中文标准库文档:https://studygolang.com/pkgdoc

第一段代码

所有代码的主文件都是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)
        }
}

深入理解

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

标签的使用展示

package main

import "fmt"

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

goto

Golang的 goto 语句可以无条件地转移到程序中指定的行。
goto语句通常与条件语句配合使用。可用来实现条件转移.
在Go程序设计中一般不建议使用goto语句，以免造成程序流程的混乱。

package main

import "fmt"

func main() {
   
	fmt.Println("hello golang1")
	fmt.Println("hello golang2")
	if 1 == 1 {
   
		goto label1 //goto一般配合条件结构一起使用
	}
	fmt.Println("hello golang3")
	fmt.Println("hello golang4")
	fmt.Println("