Go语言的使用有什么优势，哪些坑要注意

Go 需要注意的坑

需要注意的坑

Go 的优势在于方便的协程编程，在网络处理这一块性能强。但是 Go 语言为了追求使用上的简单，和其他语言有很多的不同，这里列出一些主要注意的坑：

1、类可能偶然实现了某个接口（它正好包含这个接口的实现），实现的语义可能与接口契约所期望的不同。

2、:= 和 = 容易混淆

3、类的零值问题，Map 如果是零值，它可以查询但是不能赋值

4、引用类型的值传递，仍然会修改原始值。哪些是引用类型

5、slice 陷阱，容量足够的情况下是引用传递

6、nil 接口值

坑 2~ 坑 6 的代码示例如下：

package main
import (
    "fmt"
    "time"
)
func catchError() {
    
    if err := recover();
 err != nil {

        fmt.Println(err)
    }

}

func hole2() {
    
    a := 1
    if time.Now().Year() >
 2020 {

        a := 2 // 一不小心加了一个冒号
        println(a)
    }

    println(a)
}

func hole3() {

    defer catchError()
    var m0 map[string]string
    println("key:", m0["key"])
    m0["key"] = "val" // 报错：assignment to entry in nil map
}

type Hole4 struct {

    Name    string
    Slices  []string
    MyMap   map[string]string
    Channel chan int
}

func hole4() {

    a := Hole4{

        Name:    "a",
        Slices:  []string{
"a"}
,
        MyMap:   map[string]string{
"key": "a"}
,
        Channel: make(chan int),
    }

    go func() {

        for n := range a.Channel {

            fmt.Println(n)
        }

    }
()
    b := a
    b.Name = "b"
    b.Slices[0] = "b"
    b.MyMap["key"] = "b"
    b.Channel - 999
    fmt.Println(a)
    fmt.Println(b)
}

func hole5() {

    slice1 := make([]string, 1, 1)
    slice1[0] = "1"
    temp1 := slice1
    temp1 = append(temp1, "1")
    temp1[0] = "2"
    fmt.Println(slice1)
    slice9 := make([]string, 1, 9)
    slice9[0] = "1"
    temp2 := slice9
    temp2 = append(temp2, "1")
    temp2[0] = "2"
    fmt.Println(slice9)
}

type Cache interface {

    Name()
}

type RedisCache struct{
}

func (RedisCache) Name() {
}

func hole6() {

    defer catchError()
    var redis1 *RedisCache = nil
    var redis2 Cache = redis1
    if redis2 != nil {

        println("entering...")
        redis2.Name() // 报错：nil pointer dereference
    }

}

func main() {

    hole2()
    hole3()
    hole4()
    hole5()
    hole6()
}