基础知识

1， 变量

var v1 int

var v2 string

var v3 [10]int    // 数组

var v4 []int      // 数组切片

var v5 struct {

    f int

}

var v6 *int     // 指针

var v7 map[string]int  // map，key为string类型，value为int类型

var v8 func(a int) int

2，常量

const Pi float64 = 3.14159265358979323846  

const zero = 0.0             // 无类型浮点常量

const (

    size int64 = 1024

    eof = -1                // 无类型整型常量

)  

const u, v float32 = 0, 3    // u = 0.0, v = 3.0，常量的多重赋值

const a, b, c = 3, 4, "foo"

// a = 3, b = 4, c = "foo", 无类型整型和字符串常量

const (

    Sunday = iota

    Monday

    Tuesday

    Wednesday

    Thursday

    Friday

    Saturday

    numberOfDays 

)

3，类型

Go语言内置以下这些基础类型：  

 布尔类型：bool。

 整型：int8、byte、int16、int、uint、uintptr等。

 浮点类型：float32、float64。

 复数类型：complex64、complex128。

 字符串：string。

 字符类型：rune。

 错误类型：error。

此外，Go语言也支持以下这些复合类型：

 指针（pointer）

 数组（array）

 切片（slice）

 字典（map）

 通道（chan）

 结构体（struct）

 接口（interface）

不一一列举，找几个有代表性的介绍一下：

1）字符串：var str string   // 声明一个字符串变量

str = "Hello world" // 字符串赋值

ch := str[0]   // 取字符串的第一个字符

fmt.Printf("The length of \"%s\" is %d \n", str, len(str))  

fmt.Printf("The first character of \"%s\" is %c.\n", str, ch)  

输出结果为：

The length of "Hello world" is 11   

The first character of "Hello world" is H.

2）字符：在Go语言中支持两个字符类型，一个是byte（实际上是uint8的别名），代表UTF-8字符串的单个字节的值；另一个是rune，代表单个Unicode字符。关于rune相关的操作，可查阅Go标准库的unicode包。另外unicode/utf8包也提供了UTF8和Unicode之间的转换。出于简化语言的考虑，Go语言的多数API都假设字符串为UTF-8编码。尽管Unicode字符在标准库中有支持，但实际上较少使用。

3）数组：

[32]byte       // 长度为32的数组，每个元素为一个字节

[2*N] struct { x, y int32 } // 复杂类型数组

[1000]*float64    // 指针数组

[3][5]int     // 二维数组

[2][2][2]float64    // 等同于[2]([2]([2]float64))  

需要特别注意的是，在Go语言中数组是一个值类型（value type）。所有的值类型变量在赋值和作为参数传递时都将产生一次复制动作。如果将数组作为函数的参数类型，则在函数调用时该参数将发生数据复制。因此，在函数体中无法修改传入的数组的内容，因为函数内操作的只是所传入数组的一个副本。

4）数组切片：

基于数组创建切片

    // 先定义一个数组

    var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

    // 基于数组创建一个数组切片

    var mySlice []int = myArray[:5]

直接创建切片

    创建一个初始元素个数为5的数组切片，元素初始值为0：

    mySlice1 := make([]int, 5)  

    创建一个初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间：

    mySlice2 := make([]int, 5, 10)  

    直接创建并初始化包含5个元素的数组切片：

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

数组切片支持Go语言内置的cap()函数和len()函数，cap()函数返回的是数组切片分配的空间大小，而len()函数返回的是数组切片中当前所存储的元素个数。

基于切片创建切片：

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

    newSlice := oldSlice[:3] // 基于oldSlice的前3个元素构建新数组切片

切片复制：

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

slice2 := []int{5, 4, 3}  

copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中

copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置

5）map

创建了一个键类型为string、值类型为PersonInfo的map:

myMap = make(map[string] PersonInfo)

也可以选择是否在创建时指定该map的初始存储能力，下面的例子创建了一个初始存储能力为100的map:

myMap = make(map[string] PersonInfo, 100)

删除：delete(myMap, 键)

4，流程控制：

 选择，即根据条件跳转到不同的执行序列；

 循环，即根据条件反复执行某个序列，当然每一次循环执行的输入输出可能会发生变化；  

 跳转，即根据条件返回到某执行序列。

Go语言支持如下的几种流程控制语句：

 条件语句，对应的关键字为if、else和else if；

 选择语句，对应的关键字为switch、case和select（将在介绍channel的时候细说）；

 循环语句，对应的关键字为for和range；

 跳转语句，对应的关键字为goto。

特别注意，Go语言的几个关键字：break、continue和fallthrough

5，函数：

不定参数函数：

func myfunc(args ...int) {

    for _, arg := range args {

     fmt.Println(arg)

    }  

}

闭包函数，defer关键字使用，内置函数panic()和recover()