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语言编程-许式伟