Go知识点

基础：

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接受到了信息，并且继续处理。