go语言学习（基本数据类型）

值类型：

int/uint ：根据系统确定是32还是64位。此外还有int8/uint8、int16/uint16、int32/uint32、int64/uint64

byte:字节型，相当于uint8。

float：go语言中没有double型，因为已经有了float32/float64，分别精确到小数点后面7、15位。

uintptr:保存32bit或64bit指针，应该是保存指针的地址

数组array：

数组是有类型的，比如var a [10]int= [10]int{1}，a的类型为[10]int。

数组之间可以比较相等==或者不相等（!=），前提是类型相同。如果数组间类型相同且内容依次都一致，那么两个数组相等；如果两个数组类型相同，内容不一致，那么数组不相等。

数组间赋值是值拷贝，会拷贝整个数组的所有元素给另一个数组，而不是引用拷贝，这点和C很不一样！！！

string

有地方说string是不可变的。这里要从string的内部结构说起：

 type StringHeader struct {
     Data uintptr
     Len  int
 }

string内部是一个指向某块内存的指针，加上内存块的长度。这里说的string不可变指的是uintptr指向的内存块的内容不可变，但是其指向可以变，用C语言描述一下就是：

const T *uintptr;

struct

struct是值类型。struct的声明和初始化如下：

     type Person struct {
         Name string
         Age  int
     }//struct声明

     a := Person{
         Age:  1,
         Name: "hao",
     }//直接初始化赋值，每个赋值语句后面要有逗号

     b := Person{}    //空结构体

go语言中没有继承的概念，只有组合的概念，下面是个小例子：

 type Person struct {
     Name string
     Age  int
 }

 type teacher struct {
     Person
     field string
 }

 type student struct {
     Person
     score int
 }

 func main() {
     a := student{
         score:  100,
         Person: Person{"guhao", 18},
     }
     fmt.Println(a)
 }

struct中的method

go没有class，只有struct。但是struct中提供了method方法，但不支持重载。写法与函数类似，这样一个struct就和method绑定了起来。method可以访问struct的所有字段，事实上go语言struct字段的可见性是针对真个package而言的。

 type A struct {
     Name string
 }

 type B struct {
     Name string
 }

 func main() {
     a := A{
         Name: "gu",
     }
     a.Print("hao")
 }

 func (a A) Print(arg string) { //(a A)表示接收者，arg代表方法的参数
     fmt.Println(a.Name, arg)
 }

基础类型起别名

go语言中可以给基础类型起别名，类似于C语言一样。下面的例子是给int起了个别名TZ，然后给这个别名绑定了print方法：

 type TZ int

 func (a *TZ) print() {
     fmt.Println("TZ:", *a)
 }
 func main() {
     var a TZ = 100
     a.print()

     var b int
     b = a    //错误
     b.print()  //错误
 }

虽然TZ是int的别名，但两者不能直接赋值，需要显式的类型强制转换。go语言将这两者视为不同的类型。

 var b int = 99
 a = TZ(b)
 a.print()

引用类型：

引用类型有三种：slice\map和channel

slice

slice其实是一个结构体，其中包含了指向底层数组的指针、长度、容量。所以改变slice的值也会改变对应的指向的底层数组。

slice不支持==，或者!=

map

map内部实现是hashtable， 定义如下m:=make(map[int]string)，每一级map需要单独初始化，否则直接用对二级map赋值会报错，而且是运行时候的错误，编译时无法发现。

 func main() {
     m := make(map[int]map[int]string)
     a, ok := m[2][1]
     if !ok {
         m[2] = make(map[int]string)
     }
     a = "A"
     fmt.Println(a, ok)
 }

此外，map是引用类型，需要用make定义。而且map自动扩容，我需要学习。map的key必须支持==和!=操作（废话，不然怎么做通过key去查找）。

channel

接口类型

interface

函数类型

func：函数也是一种类型，因为go语言的函数可以赋值给变量。不支持嵌套，重载和默认参数。支持closure。

 func closure(x int) func(int) int {
     fmt.Printf("%p\n", &x)
     return func(y int) int {
         fmt.Printf("%p\n", &x)
         return x + y
     }
 }

 func main() {
     x := 1
     fc := closure(x)
     fc(100)
     fc(200)
 }

我打印了三次调用的x的地址，打印的结果显示三次调用用到的x的值都是一样的，所以闭包对的x不是值拷贝，而是引用（应该是为了节约空间）。

defer语句

go语言特有的，执行顺序和定义顺序相反，先定义的语句后执行。

此外还支持panic和recover

panic和recover

 func A() {
     fmt.Println("A")
 }

 func B() {
     defer func() {
         if err := recover(); err != nil {
             fmt.Println("recover in B")
         }
     }()
     panic("Panic in B")
 }

 func C() {
     fmt.Println("C")
 }

 func main() {
     A()
     B()
     C()
 }

panic会导致程序中断，执行完了panic之后就不执行其他语句了，除非我们在panic执行前先注册了defer语句。因此recover登场了。recover必须和defer一起使用。可以帮助程序恢复执行。以上代码执行结构如下：

类型转换只能显式转换，不能隐式转换

 var a int =
 var f float32 = float32(a)

 枚举类型

枚举类型必须定义在const块内.

1、const块内默认下一条使用上一条语句

2、枚举值与iota出现的次数无关，与出现的位置有关：iota出现的位置代表了其值，默认从0开始。

 const (
     a = 'A'
     b
     c
     d = iota
     e = 'B'
     f = iota
     g
 )

 func main() {
     fmt.Println(a) //输出65
     fmt.Println(b) //输出65
     fmt.Println(c) //输出65
     fmt.Println(d) //输出3
     fmt.Println(e) //输出66
     fmt.Println(f) //输出5
     fmt.Println(g) //输出6
 }

运算符

有算术运算符和逻辑运算符、位运算符，写法和C语言一致。

多了一个专门为channel准备的运算符<-

A

recover in B

C

new和make

new返回的是指针，不会初始化变量，只是把新申请的空间内容值为零。用C语言写类似下面：

 T *obj=(T*)malloc(sizeof(T));
 memset(obj, , sizeof(T));

但并不是很准确，因为go语言中不同变量类型的零值不一样，比如bool的零值为false，int为零值为0，string的零值为空串，指针的零值是nil。所以下面这段代码p==nil

var p *[]int = new([]int) 

内建函数make(T, args)与new(T)的用途不一样。它只用来创建slice，map和channel，并且返回一个初始化的(而不是置零)，类型为T的值（而不是*T）。之所以有所不同，是因为这三个类型的背后引用了使用前必须初始化的数据结构。例如，slice是一个三元描述符，包含一个指向数据（在数组中）的指针，长度，以及容量，在这些项被初始化之前，slice都是nil的。对于slice，map和channel，make初始化这些内部数据结构，并准备好可用的值。

内存管理

特别值得注意的是，局部变量不是所有的都分配在stack中（new出来的对象当然在heap上），如果一个函数的局部变量返回后依然被使用，那么这个变量分配在heap上，而不是stack上。