# 概述

Golang 的数据类型按存储方式分为两大类：
1. 值类型

int
float
bool
string
struct
数组

2. 引用类型

指针
slice
map
channel
interface

由于 channel 和 interface 涉及更加高级的编程模式，此处不做介绍。

# 值类型数据

值类型数据的特点：
（1）变量直接存储值。
（2）值类型的数据存储在栈内存空间中，栈在函数调用完内存会被释放。

# 整型数 int

	// 1. 声明时赋值
	var a int = 10
	// 2. 声明时赋值
	a := 10
	// 3. 先声明，后赋值
	var a int
	a = 10

# 浮点型 float32/float64

	// 1. 声明时赋值
	var a float32 = 0.1
	// 2. 声明时赋值
	a := 0.1
	// 3. 先声明，后赋值
	var a float32
	a = 0.1

# 定长数组

	// 声明时需要确定长度
	var arr [3]int
	arr := [3]int{1,2,3}

# 字符串 string

	// 1. 声明时赋值
	var s string = "abc"
	// 2. 声明时赋值
	s := "abc"
	// 3. 先声明，后赋值
	var s string
	s = "abc"

# 结构体 struct

结构体声明

	type rectangle struct {
	length float64
	width float64
	color string
	}

结构体实例化

	// 1. 实例化时赋值
	var rec = rectangle{10.4, 25.10, "red"}
	// 2. 实例化时赋值
	rec := ranctangle{10.4, 25.10, "red"}
	// 3. 先实例化后赋值
	var rec rectangle
	rec.length = 10.4
	rec.width = 25.10
	rec.color = "red"
	// 4.new () 关键字
	rec := new(rectangle)
	rec.length = 10.4
	rec.width = 25.10
	rec.color = "red"

# 指针类型数据

指针类型数据的特点：
（1）引用类型变量存储的是一个地址，这个地址存储数据的值。
（2）引用数据类型的数据存储在堆内存空间中，通过 GC 回收。

# 指针

	var a int = 10
	// 1. 声明时赋值
	pa := &a
	// 2. 声明时赋值
	var pa int* = &a
	// 3. 先声明再赋值
	var pa int*
	pa = &a

# slice 切片（动态数组）

空切片

	var slice1 []int
	slice1 := make([]int ,0)
	slice1 := []int{}

make()分配空间

	// 长度和容量都是 5
	slice1 := make([]int, 5)
	// 长度为 3，容量为 5
	slice1 := make([]int,3 ,5)

直接赋值

slice1 := []int{1,2,3,4,5}

截取

slice2 := slice1[1:3]

append()追加

slice1 = append(slice1, 20)

值得注意的是，append 追加后的长度是可以超过 slice 的容量 cap 的，此时 slice 将会动态扩容。在切片的容量小于 1000 个元素时，总是会成倍地增加容量。一旦元素个数超过 1000，容量的增长因子会设为 1.25，也就是会每次增加 25% 的容量。

slice后追加slice

slice3 = append(slice1, slice2)

遍历切片

	//range 关键字
	for index, value := range slice1 {
	fmt.Printf("index: %d value: %d\n", index, value)
	}
	// 传统迭代
	for index := 0; index < len(slice1); index++ {
	fmt.Printf("index: %d value: %d\n", index, slice[index])
	}

切片拷贝copy()

count := copy(slice1, slice2)

这行代码表示将 slice2 拷贝到 slice1 中。
若 slice2 比 slice1 长，则截断；若 slice2 比 slice1 短，则全部拷贝。
其中返回值 count 为拷贝成功的元素个数。

# map

map声明

	// 先声明，再使用 make () 开辟空间
	var map1 map[string]string
	map1 = make(map[string]string, 10)
	map1["one"] = "java"
	map1["two"] = "c++"
	map1["three"] = "python"
	// 直接使用 make 声明
	map2 := make(map[int]string)
	map2[1] = "java"
	map2[2] = "c++"
	map2[3] = "python"
	// 声明时直接赋值
	map3 := map[string]string {
	"one": "php",
	"two": "c++",
	"three": "python",
	} // 最后一定要有逗号

map遍历

	for key, value := range map1 {
	fmt.Println("key = ", key)
	fmt.Println("value = ", value)
	}

map删除

delete(map1, "one")

map修改

map1["one"] = "rust"

golang