基础：
1、变量赋值
2、常量赋值，itoa使用
3、string
4、循环和选择结构
5、switch语句
6、array, slice和map
函数：
7、函数格式
8、函数可以返回多个返回值
9、defer的使用（在函数退出时调用）
10、panic，recover和defer
1、变量赋值
var a a = 12 a := 12 a,b :=12,23
2、常量赋值，itoa使用
const( a = iota b )
3、string
go中string是常量，只能用双引号来表示。
a := "this is string"
a[0] = 'c' (这个是错误的，会报错)
如果要做上面的操作应该这样：
a := "this is string" c := []bytes(a) c[0] = 'c' d := string(c)
4、循环和选择结构
go中没有do while，循环结构只有for。选择结构有if和switch
if语句
if err := file.Chmod(777); err != nil { return err }
切结：左括号必须和if在同一行，因此
if err := file.Chmod(777); err != nil { //这个在Go语句中是非法的 return err }
for循环
sum := 0 for i := 0; i < 10; i++ { sum += i }
list := []string{"aaa", "bbb", "ccc"} for _,v := range list{ fmt.Print("%s", v) }
//这里使用了一个range，key和value分别是int和string类型，key是序号，从0开始，value是值
5、switch语句
switch和其他语言差不多，只有一个，它不需要break，查询到一个满足条件的，执行，然后跳出
switch a { case "test1": fmt.Print("test1") case "test2","test3": fmt.Print("testOhter") default: fmt.Print("NoTest") }
6、array, slice和map
array就是平时使用的数组，和C语言中的数组是一样的
var a [10]int a[0] = 1 a[1] = 2
二维数组：
a := [2][2]int{{1,2}, {3,4}}
slice和array接近，slice理解为array的指针，使用make进行内存分配
sl := make([]int, 10)
array和slice的转换的说明使用摘录《学习go语言》的一段：
想要扩展slice，append和copy两个内建函数。
（PS：区别内建函数和第三方库函数的区别是，内建函数是小写字母开头，如copy()，第三方库函数是首字母大写，如fmt.Print()）
map结构是一个hash映射
ages := map[string]int { "lili" : 13, "nick":23, "jacky":55, }
这里注意一下，很多语言在列出这样结构的时候，最后一个逗号往往都要求省略（55后面的逗号），但是Go语言中这个逗号是必须的。
7、函数格式
func GetMsg(i int) (r string) { fmt.Println(i) r = "hi" return r }
func说明这个是个函数
GetMsg是函数名
(i int) 函数接收一个int参数
(r string) 函数返回一个string类型返回值
8、函数可以返回多个返回值
func GetMsg(i int) (r string, err string) { fmt.Println(i) r = "hi" err = "no err" return r,err }
9、defer的使用
defer的意思是"在函数退出时调用"，特别用于对文件进行读写操作的时候，需要在open之后要调用close操作，将close操作使用defer
func ReadFile(filePath string)(){ file.Open(filePath) defer file.Close() if true { file.Read() } else { return false } }
这样写的意思是在file.Open后不立即调用close，当return false的时候调用file.Close().这样就有效避免了C语言中的内存泄露问题。
10、panic，recover和defer
Panic和Recover我们就将他们看成是其他语言中的throw和catch
例子：
package main import "fmt" func main() { f() fmt.Println("Returned normally from f.") } func f() { defer func() { if r := recover(); r != nil { fmt.Println("Recovered in f", r) } }() fmt.Println("Calling g.") g(0) fmt.Println("Returned normally from g.") } func g(i int) { if i > 3 { fmt.Println("Panicking!") panic(fmt.Sprintf("%v", i)) } defer fmt.Println("Defer in g", i) fmt.Println("Printing in g", i) g(i + 1) }
返回了：
Calling g. Printing in g 0 Printing in g 1 Printing in g 2 Printing in g 3 Panicking! Defer in g 3 Defer in g 2 Defer in g 1 Defer in g 0 Recovered in f 4 Returned normally from f.
Panic抛出了信息，并且跳出函数。Recover接受到了信息，并且继续处理。
