一、基本数据类型
golang基本数据类型包含：
整数型：int, uint, int8, uint8(byte), int16, uint16, int32(rune), uint32, int64, uint64
浮点类型：float32, float64
复数类型：complex64, complex128
布尔类型：bool
字符串：string
可以定义为私有变量，公有变量，常量、枚举，数据的各种定义方式代码如下
package main
// 定义私有（private变量首字母小写，同一个package内可以使用）bool 类型全局变量
var isTrue bool
// 定义公有（public变量首字母大写，不同package内可以使用）bool类型全局变量isFalse并赋初始值true
var IsFalse bool = true
// 定义一组全局变量
var (
a int
b uint
c int8
d uint8
e byte
f int16
g uint16
h int32
i rune
j uint32
k int64
l uint64
m float32
n float64
o string
p complex64
q complex128
)
//定义常量
const PI = 3.1415926
//枚举值 iota 从零开始每次加1，遇到const重置零
const (
x = iota
y
z
)
const (
u = iota
v
)
//定义变量并赋初始值，系统根据值推断数据类型
var a1, a2, a3 = "abcd", 2, 3.0
//定义变量并赋初始值
var b1, b2, b3 int = 1, 2, 3
/*main函数*/
func main() {
println("isTrue = ", isTrue)
println("isFalse = ", IsFalse)
println("整数默认值：", a, b, c, d, e, f, g, h, i, j, k, l)
println("浮点数默认值：", m, n)
println("字符串默认值：", o)
println("复数默认值：", p, q)
println("a1,a2,a3值分别为：", a1, a2, a3)
println("b1,b2,b3值分别为：", b1, b2, b3)
println("枚举值：", x, y, z, u, v)
// 局部变量定义后必须使用，否则编译报错
var age int = 23
var height = 175 //系统根据值推断数据类型
weight := 75.00 //局部变量特有的定义方式
println(age, height, weight)
var (
hello string = "hello"
//定义多行字符串
world string = `world
!!!`
)
println(hello, world)
}
命令窗口执行 go run Main.go 输出如下
isTrue = false
isFalse = true
整数默认值： 0 0 0 0 0 0 0 0 0 0 0 0
浮点数默认值： +0.000000e+000 +0.000000e+000
字符串默认值：
复数默认值： (+0.000000e+000+0.000000e+000i) (+0.000000e+000+0.000000e+000i)
a1,a2,a3值分别为： abcd 2 +3.000000e+000
b1,b2,b3值分别为： 1 2 3
枚举值： 0 1 2 0 1
23 175 +7.500000e+001
hello world
!!!
符合类型包含：数组 array、结构体 struct
1、array
golang数组的定义及使用（一维数组，多维数组）
package main
func main() {
// 定义名称为lanArr类型为[3]string的数组并初始化数据
var lanArr [3]string = [3]string{"golang", "java", "vue"}
// 遍历数字 i,v 分别是数组下标及对应值
for i, v := range lanArr {
println(i, v)
}
// 定义users数组
var users [3]string
// 为数组赋值
users[0] = "Lily"
users[1] = "Lucy"
users[2] = "Tom"
for i := 0; i < len(users); i++ {
print(users[i])
}
// 定义数组arr 数组类型长度系统根据赋值表自动推断
arr := [...]string{"Tom"}
println(arr[0]) //打印值：Tom
//定义数组arr2并为下标100的位置赋值为 Tom
arr2 := [...]string{100: "Tom"}
// 打印数组100坐标的值及数组长度：Tom 101
println(arr2[100], len(arr2))
}
2、struct
golang struct 的定义及使用
package main
import "fmt"
// 定义用户结构体包含用户名、年龄两个属性
type users struct {
name string
age int
}
// 定义学生结构体包含users、学号两个属性
type students struct {
stNo string
user users
}
func main() {
//定义结构体users变量user并为属性赋值
user := users{age: 20, name: "Tom"}
// 打印：user's age is 20 and name is Tom
fmt.Printf("user's age is %d and name is %s \n", user.age, user.name)
student := students{stNo: "001", user: users{age: 20, name: "Lucy"}}
// 打印：student's age is 20 and name is Lucy and stNo is 001
fmt.Printf("student's age is %d and name is %s and stNo is %s\n", student.user.age, student.user.name, student.stNo)
}
引用类型包含：slice、map、channel。
1、slice
在使用数组时我们并不知道数组的长度，因此我们需要一个可变长的数组 slice，slice是一个引用类型，底层引用一个数组，当底层数据变化时引用也会变化，引用变化时数组也变化。
slice的使用方式一：直接声明使用
package main
func main() {
// slice的声明和数组类似只是没有长度
var userSlice []string
// 为声明的slice赋值
userSlice = []string{"Lily", "Lucy", "Tom"}
// 声明局部变量并赋值
lilei := "Lilei"
// 向slice中增加数据
userSlice = append(userSlice, lilei)
// 打印slice长度及容量：4 6
println(len(userSlice), cap(userSlice))
}
slice的使用方式二：既然slice底层是个数组我们还可以显示指定引用数组
package main
func main() {
// 声明数组并赋值
userArray := [4]string{"Lily", "Lucy", "Tom", "Jim"}
// 声明slice并指定引用数组的起始结束下标
//包含起始位置，不包含结束位置。
//起始下标不写默认0，例如：userSlice := userArray[:3]
//结束下标不写默认数组长度值即len(userArray)，例如：userSlice := userArray[1:]
userSlice := userArray[1:3]
// 打印slice长度及容量：2 3
println("slice长度及容量：", len(userSlice), cap(userSlice))
// 遍历slice
for i, v := range userSlice {
println(i, v)
}
// 声明变量并赋值
lilei := "Lilei"
// 向slice中增加数据
userSlice = append(userSlice, lilei)
david := "David"
// 向slice中增加数据
userSlice = append(userSlice, david)
// 打印slice长度及容量：3 3
println("打印slice长度及容量：", len(userSlice), cap(userSlice))
println("---------遍历slice----------")
for i, v := range userSlice {
println(i, v)
}
println("---------遍历数组----------")
// 原数组中的Jim丢失了
for i, v := range userArray {
println(i, v)
}
}
slice的使用方式三：通过系统函数make声明
package main
func main() {
// 声明长度为0，容量为10的slice
userSlice := make([]string, 0, 10)
userSlice = append(userSlice, "Lily", "Lucy", "Tom", "Jim")
// slice长度及容量： 4 10
println("slice长度及容量：", len(userSlice), cap(userSlice))
// 遍历slice
for i, v := range userSlice {
println(i, v)
}
}
slice的使用方式四：通过系统函数copy复制slice
package main
func main() {
// 初始化userSrcSlice
userSrcSlice := []string{"Lily", "Lucy", "Tom", "Jim"}
userDstSlice := make([]string, 3, 4)
copy(userDstSlice, userSrcSlice)
/*
打印结果：
0 Lily
1 Lucy
2 Tom
3 Jim
*/
for i, v := range userSrcSlice {
println(i, v)
}
/*
打印结果：
0 Lily
1 Lucy
2 Tom
*/
for i, v := range userDstSlice {
println(i, v)
}
}
2、map
go map 声明一个有初始值的map
package main
func main() {
// 初始化map，键为string类型，值为int类型。初始值："Lily": 10, "Lucy": 15
studentScore := map[string]int{"Lily": 10, "Lucy": 15}
//向map中添加数据
studentScore["Lilei"] = 20
//获取map中指定键的值
score, ok := studentScore["Lilei"]
println(score, ok)
//修改map中的数据
studentScore["Lilei"] = 16
//删除map
delete(studentScore, "Lily")
// 打印map长度
println(len(studentScore))
//遍历map
for k, v := range studentScore {
println(k, v)
}
}
go map 定义一个无初始值的map
package main
func main() {
// 初始化一个不含初始值的map，键为string类型，值为int类型。
studentScore := make(map[string]int)
//向map中添加数据
studentScore["Lilei"] = 20
//获取map中指定键的值
score, ok := studentScore["Lilei"]
println(score, ok)
//修改map中的数据
studentScore["Lilei"] = 16
//删除map
delete(studentScore, "Lily")
// 打印map长度
println(len(studentScore))
//遍历map
for k, v := range studentScore {
println(k, v)
}
}
3.list
list是一个列表数据类型，有两种初始化方式：
1、系统函数list.New()初始化 l := list.New()
2、声明初始化 var l list.List
package main
// 引入go语言list工具包
import "container/list"
func main() {
// 初始化一个list
//l := list.New()
var l list.List
// 向尾部加入数据
l.PushBack("go")
// 向头部加入数据
l.PushFront("golang")
l.PushBack("vue")
// 遍历
// 初始化表达式：e := l.Front() 获取list的第一个数据
// 条件判断表达式：e != nil 判断数据e是否为空，为空循环结束，不为空继续执行循环体
// 迭代表达式：e = e.Next() 获取list的下一个值，然后执行条件表达式
for e := l.Front(); e != nil; e = e.Next() {
// 转换e.Value为字符串
v := e.Value.(string)
println(v)
}
}
本次学习了golang的整形、浮点型、bool类型等基础数据类型和array、struts复合类型以及引用类型的slice、map。
后面还会学习到golang引用类型channel和指针类型。