这是我参与「第三届青训营 -后端场」笔记创作活动的的第1篇笔记。 主要介绍Go语言中的数据类型，并简单介绍一下几种常用类型的使用。

一 Go语言基本数据类型

1 整形

int      uint
int8     uint8
int16    uint16
int32    uint32
int64    uint64 
 
int 和 uint 在32位机器上是4字节，在64位机器上是8字节 

使用math包获取整形值的最大值和最小值
math.MaxInt      math.MinInt
math.MaxInt32    math.MinInt32 
math.MaxInt64    math.MinInt64

2 浮点型

float32    float64

3 复数

complex32   complex64
如: 1+2i

4 布尔值

bool 1字节
可取值: true  false

5 字符

byte    uint8   一个ASCII码字符 
rune    int32   一个UTF-8字符

6 字符串

string

7 指针类型

如:
var p1 *int
var p2 *string

二 其他数据类型

1 数组

如: var arr [2]int

2 slice

初始化
如: var sli []int 
    sli = make([]int, 0)   // 必须先分配内存才能使用
或: sli := make([]int, 3)  // 0, 0, 0

增: sli = append(sli, 2, 3, 4)  // 0, 0, 0, 2, 3, 4 
删: sli = append(sli[:3], sli[4:]) // 0, 0, 0, 3, 4
改: sli[0] = 1   // 1, 0, 0, 3, 4
查: 遍历
浅拷贝: sli2 := sli[:3]     // sli和sli2共用一个底层数组
深拷贝: sli3 := make([]int, 3)
        copy(sli3, sli[:3]) // sli和sli3不共用底层数组
        
        
扩展应用
1 使用slice用作stack, 和C++中的stack对比
stack<int> s;      <---->  s := make([]int, 0)
s.push(1);         <---->  s = append(s, 1)
s.pop();           <---->  s = s[:len(s)-1]  // 需要判断len(s)是否为0
int x = s.top();   <---->  x := s[len(s)-1]  // 需要判断len(s)是否为0

2 使用slice用作queue, 和C++中的queue对比
queue<int> q;      <---->  q := make([]int, 0)
q.push(1);         <---->  q = append(q, 1)
q.pop();           <---->  q = q[1:]  // 需要判断len(q)是否为0
int x = q.front(); <---->  x := q[0]  // 需要判断len(q)是否为0
int y = q.back();  <---->  y := q[len(q)-1]  // 同上

slice实现的stack比queue更高效，原因是queue删除操作中，
会把后面的元素整体向前移动赋值，因为使用的是一个底层数组

3 map

如: var m map[int]int       // 必须先分配内存才能使用
    m = make(map[int]int)
或: m := make(map[int]int)  // 可不指明空间大小

增: m[1] = 10; m[2] = 20    // m{1:10, 2:20}
删: delete(m, 1)            // m{2:20}
改: m[2] = 10               // m{2:10}
查: v1,ok := m[1]  // 0, false  未找到也不会插入，和C++中的map区别
    v2,ok := m[2]  // 10, true

扩展应用
1 使用map用作set, 和C++中的set对比
set<int> st;     <---->   st := make(map[int]struct{})
st.insert(1);    <---->   st[1] = struct{}{}
st.remove(1);    <---->   delete(st, 1)
st.find(1);      <---->  _, ok := st[1]

空结构体不占空间，因此使用空结构体作为map的value

4 channel

无缓冲channel: ch := make(chan int)
有缓冲channel: ch := make(chan int, 1)

5 struct

如:
type user struct{
    name string
    age  int
}
u := user{"小明", 19}

6 func()

 func add(a,b int) int {
     return a+b
 }
 
 var f func(int, int) int
 f = add
 fmt.Println(f(1,3))  // 4

7 interface

1、interface{} 可表示任意类型, 使用 .() 可以进行类型断言

    func printInt(a interface{}) {
        if value, ok := a.(int); ok {
		fmt.Println(value)
        } else {
		fmt.Println("输入不是整数")
        }
    }
    
    func main() {
        printInt(1)    // 1
        printInt("1")  // 输入不是整数
    }

2、用作多态

 type A interface {
     f()
 }

 type B struct{}
 func (b B) f() {
     fmt.Println("B...")
 }

 type C struct{}
 func (c C) f() {
     fmt.Println("C...")
 }

 func print(a A) { 
 // 接受一个A对象作为参数
 // B, C实现了A接口，因此B, C对象均可作为参数传入 
     a.f()
 }

 func main() {
     print(B{})  // B...
     print(C{})  // C...
 }

总结

Go语言除了上述数据类型之外，还有一些容器类型，
如container包中的list、heap、ring，这部分内容留待后续更新。

本文只是简单介绍了一下Go语言数据类型的种类，
对各数据类型的使用细节没有进行太过详细的介绍，
后续有时间继续对各类型的使用细节进行更新。