golang学习之golang数据类型（上）

---

一、基本数据类型

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和指针类型。