Go 语言学习笔记

1. go没有static关键字

面向对象编程中,尽量对函数进行封装,对于没有函数变量的对象,使用static关键字尤其方便。
go中没有static关键字,必须每次new一个出来。

type Handler struct {
}

func NewHandler() *Handler {
    h := &Handler{}
    return h
}

func (*Handler) Method_1 (){
    
}

func (*Handler) Method_2 () {
    
}

2. go没有while; do...while循环

go语言里面的for循环比较灵活

func main(){
    for {
        fmt.Printf("while true\n")
        break
    }

    for i:=0; i < 5; i = i + 1 {
        fmt.Printf("while data:%d\n", i)
    }

    i := 0
    for i < 5 {
        fmt.Printf("while ok:%d\n", i)
        i = i + 1
    }
}

3. go每个协程都必须捕获panic

go中每个协程都必须捕获panic, 否则任何一个协程问题,都会导致整个程序dump掉。

func no_panic_get(a, b int){
    /* //每个go协程都必须捕获panic, 否则整个程序都会panic
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("no_panic_get, err:%v\n", r)
        }
    }()
    */
    c :=  a / b
    fmt.Printf("no_panic_get res:%v\n", c)
}

func main(){
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("exec failed, err:%v\n", r)
        } else {
            fmt.Printf("exec success\n")
        }
    }()

    go no_panic_get(1,0)    //no_panic_get没有捕获panic, 程序直接panic崩溃
    time.Sleep(time.Duration(5 * time.Second))
}

4. go中巧用defer函数逆序执行

defer函数,是在函数最后执行的。
属于先申明,后执行原则;多个defer,申明时入栈,出栈时执行,也就是逆序执行。
只要第一个申明的defer,作为最后一个捕获panic程序执行就可以。

func main(){
    defer func() {
        fmt.Printf("defer func1\n")
    } ()

    defer func() {
        fmt.Printf("defer func2\n")
    } ()

    fmt.Printf("main func\n")
}

5. go中巧用interface

interface类似C/C++中的void*类型,可以将任何类型转为interface类型。
不同的是, interface可以确定保存的是那种类型的数据. 使用 v.(type)

type A struct {
    age int
    sex string
}

type B struct {
    peer []string
    name string
}

func main(){
    aData := &A{age:19}
    bData := &B{[]string{"zhangsan", "lisi"},"wang"}

    ctx := make(map[string]interface{}) //容器
    ctx["1"] = aData
    ctx["2"] = bData
    for _, v := range ctx {
        switch v.(type) {
        case *A:
            fmt.Printf("type A %v\n", v)
        case *B:
            fmt.Printf("type B %v\n", v)
        default:
            fmt.Printf("type unkown\n")
        }
    }
}

6. go注意大小写

go中大小写区分访问权限, 在定义函数,定义变量时需要注意。
小写变量,不能被json序列化。
小写函数,外部不能访问。
go1.4 之前版本中, map[int]string, 因为key是int不能正确序列号。

type Stu struct {
    Age int
    Name string
}
func main(){
    ctx := make(map[int]*Stu)
    ctx[1] = &Stu{12,"li"}  //按照定义顺序初始化
    ctx[2] = &Stu{ Age:18}  //初始化部分字段; 其他字段默认值
    jsonres, _ := json.Marshal(ctx)
    result := string(jsonres)
    fmt.Printf("%s\n", result)

    newctx := make(map[int]*Stu)
    if err := json.Unmarshal([]byte(result), &newctx); err == nil { //第二个参数需要是一个指针
        for k, v := range newctx{
            fmt.Printf("k:%v val:%v\n", k, v)
        }
    }
}

7. go中变量申明后都有默认值

在go语言中,任何类型在声明后没有赋值的情况下,都对应一个零值。

  • 整形如int8、byte、int16、uint、uintprt等,默认值为0
  • 浮点类型如float32、float64,默认值为0
  • 布尔类型bool的默认值为false
  • 复数类型如complex64、complex128,默认值为0+0i
  • 字符串string的默认值为""
  • 错误类型error的默认值为nil
  • 对于一些复合类型,如指针、切片、字典、通道、接口,默认值为nil。而数组的默认值要根据其数据类型来确定。例如:var a [4]int,其默认值为[0 0 0 0]

8. go中可以使用fmt构造一个error类型返回

go语言函数是支持多返回值的,因此在写go函数时,都会带一个error类型返回值表示是否有错误。
可以使用fmt构造一个error返回。

func getError() error {
    a := 1
    b := 0
    return fmt.Errorf("a/b is not vaild, a:%d b:%d", a, b)
}
func main(){
    fmt.Printf("err[%v]", getError())
}

posted on 2019-04-06 17:09 旭东的博客 阅读(...) 评论(...) 编辑 收藏

导航