Go语言学习笔记

注:上一篇安装教程

一.Go语言详解

1.概述

1.main函数介绍

2.类型

2.1、注解

// 这是一个单行注解

/*
	这是一个多行注解
	1.解释
	2.流程
	3.结束
 */

2.2、变量

2.2.1、变量定义

var会根据数据自己判断类型，且可以省略。

/*
		赋值，自动判断配型
	*/
	var x = 100
	var y = false

	/*
		定义q、w为int类型，默认为0
	*/
	var q, w int

	/*
		将a赋值100，b赋值"abc"
	*/
	var a, s = 100, "abc"

	/*
		隐形赋值
	*/
	z := 100
	f, m := 200, 300
	
	/*
		多重赋值功能，将i和j交换
	*/
	var i, j = 1, 2
	i, j = j, i
	println(i, j)

2.2.2、匿名变量

func main() {
	_, _, v3 := GetUser() //“_”占用符，对应GetUser返回参数name，sex，age

	println(v3) //输出结果"18"
}

func GetUser() (name, sex, age string) { //设置返回值name,sex,age类型为string
	return "姓名", "男", "18"
}

2.3、命名

	/*
		命名建议
		1.字母或下划线开始，由多个字母、数字和下划线组合
		2.区分大小写
		3.使用驼峰格式
		4.局部变量优先使用短名
		5.不适用关键字
		6.不建议使用与预定义相同的名字
		7.专有名字通常全部大写
	*/

	//大小写作用域不同,小字母包内使用,大字母为导出成员,可包外使用
	var name = "彬少"
	var Name = "binshao"
	println(name, Name)

2.4、常量

2.4.1、常量定义

在Go语言中，常量是指编译期间就已知且不可改变的值。常量可以是数值类型（包括整型、
浮点型和复数类型）、布尔类型、字符串类型等。
注意:常量是编译期定义的，所以运行期出现的值不能赋值

	const n = 123

	const ( //一个const，多次定义常量，省略多次const
		i = 100
		j = "wang"
	)

	{
		const n = "abc" //不同作用域可以用同名
		println(n)
	}

	println(n, i, j)

	/*
		如果不指定类型和初始化值,则赋值上行非空属性和值
	*/
	const (
		x uint16 = 120
		y
		s = "abc"
		z
	)
	println("y=", y)
	println("z=", z)

2.4.2、预定义常量

Go语言预定义了这些常量：true、false和iota

func main() {
	/**
	iota每次初始化为0，每次递增1
	*/
	const (
		x = iota //1
		y = iota //2
		z = iota //3
	)

	/**
	以下写法省略了iota
	*/
	const (
		j = iota //1
		p        //2
		q        //3
	)

	const (
		w = 20 * iota //20*0=1
		e             //20*1=20
		r             //20*2=40
	)

	const (
		a = 1 << iota //1向左移动0位为0B1=1
		b             //1向左移动1位为0B10=2
		c             //1向左移动2位为0B100=4
	)

	println(x, y, z) //0 1 2
	println(j, p, q) //0 1 2
	println(w, e, r) //0 20 40
	println(a, b, c) //1 2 4

	/**
		iota此时不递增
	*/
	const l = iota //0
	const p = iota //0

	println(l, p) //0 0

}

2.4.3、枚举

func main() {
	const (
		Sunday = iota
		Monday
		Tuesday
		Wednesday
		Thursday
		Friday
		Saturday
		numberOfDays // 小写表示只能在包内使用
	)
}

2.5、基本类型

2.5.1、运算符

数值运算:+(加)、-（减）、*(乘)、/(除)和%(取余)。
比较运算符:>(大于)、<(小于)、==(等于)、>=(大于等于)、<=(小于等于)和!=(不等于)。注:必须类型一致
位运算符:x << y (左移)、x >> y(右移)、 x ^ y(异或)、x & y(与)、x | y(或)、^x(取反)

2.5.2、类型转换

	
func main() {

	a := 10
	b := byte(a)    //将类型转换成byte再赋值，得到的是byte类型
	c := a + int(b) //相加时必须保证类型一致
	println(c)

	var value2 int32
	value1 := 64 // value1将会被自动推导为int类型
	// value2 = value1 编译期不通过，因为类型不一致
	value2 = int32(value1) // 注意:int和int32不一样，必须通过强转
	println(value2)

	x := 100
	p := (*int)(&x) //将p解析为指针类型
	println(&x)
	println(p)
}

2.5.3、复数类型

func main() {
	/**
		复数的三种赋值方式
		对于一个复数z = complex(x, y)，就可以通过Go语言内置函数real(z)获得该复数的实部，也就是x，通过imag(z)获得该复数的虚部，也就是y。
	*/
	var v1 complex64
	v1 = 3.2 + 12i
	v2 := 3.2 + 12i
	v3 := complex(3.2, 12)
	println(v1)
	println(v2)
	println(v3)
}

2.5.4、字符串

func main() {
	var str string
	str = "hello " + "world" //字符串赋值
	ch := str[0]             //取第一个字母
	println(len(str))        //输出str长度
	println(ch)              //输入第一个字符
}

2.5.5、数组

func main() {
	/*
		定义数组 注:数组的长度在定义之后无法再次修改
		[32]byte                //长度为32数组，每个元素一个字节
		[4]struct{ x, y int32 } //复杂类型数组
		[1000]*float64          //指针数组
		[3][5]int               //二维数组
		[2][2][2]float64        //三维数组
	*/

	var arr = [5]int{1, 2, 3, 4, 5}
	//循环遍历方法一
	for i, a := range arr {
		println(i, a)
	}

	//循环遍历方法二
	for i := 0; i < len(arr); i++ {
		println(i, arr[i])
	}

	//将数组第2位值赋值10
	arr[1] = 10
	println("arr[1]:", arr[1])
}

2.5.6、数组切片

数组切片是数组的衍生版，可以自动扩容。
1.基于数组创建切片

func main() {
	//先定义一个数组
	var myArray = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	//基于数组创建一个切片
	var mySlice []int = myArray[:5] //[param1:param2] param1表示从开始位置截取，param2表示截取的长度,[:]所有数组创建切片

	println("Elements of myArray: ")
	for _, v1 := range myArray {
		print(v1)
	}

	println("\nElements of mySlice: ")
	for _, v1 := range mySlice {
		print(v1)
	}
}

2.数组切片拓展

func main() {

	/**
	直接创建数组切片三种方式
	*/
	// 第一种:创建一个初始元素个数为5的数组切片,元素默认为0
	mySlicel1 := make([]int, 5)
	// 第二种:创建一个初始元素个数为5的数组切片,开辟10个存储空间,元素默认为0
	mySlicel2 := make([]int, 5, 10)
	// 第三种:直接创建切片并初始化值
	mySlicel3 := []int{1, 2, 3, 4, 5}

	print("\nmySlicel1:")
	for i := 0; i < len(mySlicel1); i++ {
		fmt.Print(" ", mySlicel1[i])
	}
	print("\nmySlicel2:")
	for i := 0; i < len(mySlicel2); i++ {
		fmt.Print(" ", mySlicel2[i])
	}
	print("\nmySlicel3:")
	for i := 0; i < len(mySlicel3); i++ {
		fmt.Print(" ", mySlicel3[i])
	}

	/**
	常用的数组切块函数
	*/
	//len表示存储的个数
	println("len(mySlicel2):", len(mySlicel2))

	//cap表示开辟的空间大小
	println("cap(mySlicel2):", cap(mySlicel2))

	//append表示继续新增元素  输出:0 0 0 0 0 28 88 89
	mySlicel1 = append(mySlicel1, 28, 88, 89)
	//append表示将mySlicel3添加到mySlicel1中，省略号表示将mySlicel3打散后传入。输出:0 0 0 0 0 28 88 89 1 2 3 4 5
	mySlicel1 = append(mySlicel1, mySlicel3...)

	//基于数组切片创建切片[v1:v2],v1表示开始位置，v2表示结束位置
	mySlicel4 := mySlicel3[:3]

	//内容复制
	mySlice5 := []int{1, 2, 3, 4, 5}
	mySlice6 := []int{5, 4, 3}
	//按最小的元素个数进行复制,mySlice6输出：1 2 3
	//copy(mySlice6, mySlice5)
	//mySlice5输出:5 4 3 4 5
	copy(mySlice5, mySlice6)

	print("\nmySlice5:")
	for i := 0; i < len(mySlice5); i++ {
		fmt.Print(" ", mySlice5[i])
	}

	print("\nmySlicel4:")
	for i := 0; i < len(mySlicel4); i++ {
		fmt.Print(" ", mySlicel4[i])
	}
	print("\nmySlicel1:")
	for i := 0; i < len(mySlicel1); i++ {
		fmt.Print(" ", mySlicel1[i])
	}

}

2.5.7、字典

map是一堆键值对的未排序集合

func main() {
	userInfo := make(map[string]UserInfo)

	//插入数据
	userInfo["1"] = UserInfo{"binshao.wang", 18, "男"}
	userInfo["2"] = UserInfo{"shanmu", 19, "女"}

	//获取param1获取内容UserInfo类型,param2返回成功失败bool类型
	param1, param2 := userInfo["1"]
	if param2 {
		println("param1:", param1.name)
	} else {
		println("is error!")
	}

}

type UserInfo struct {
	name string
	age  int
	sex  string
}

1.拓展

func main() {
	//声明
	var userInfo map[string]UserInfo

	//创建。 开辟空间100,可省略。
	userInfo = make(map[string]UserInfo, 100)

	//插入数据
	userInfo["1"] = UserInfo{"binshao.wang", 18, "男"}
	userInfo["2"] = UserInfo{"shanmu", 19, "女"}

	//创建和插入数据合并
	//userInfo = map[string]UserInfo{"1": UserInfo{"binshao.wan", 18, "男"}}

	//删除key值为"2"的数据,注:没有不会报错
	delete(userInfo, "2")

	//元素查找，获取param1获取内容UserInfo类型,param2返回成功失败bool类型
	param1, param2 := userInfo["1"]
	if param2 {
		println("param1:", param1.name)
	} else {
		println("is error!")
	}

}

下一篇

下一篇笔记

参考文献

Go语言学习笔记-雨痕
Go语言编程-许式伟