一日一学_Go从错误中学习基础一

在写Go代码时，多少会出一些错误，我把这些常见错误整理出来。一是再次让自己重新认识Golang，进行不足的学习。二是分享出来让更多人认识Golang。

短声明使用

短声明只能出现在函数内部。

func(){ 
  a := 10
}()

短声明的重新声明。
官方解释:Unlike regular variable declarations, a short variable declaration may redeclare variables provided they were originally declared earlier in the same block (or the parameter lists if the block is the function body) with the same type, and at least one of the non-blank variables is new. As a consequence, redeclaration can only appear in a multi-variable short declaration. Redeclaration does not introduce a new variable; it just assigns a new value to the original.
翻译:与常规变量声明不同，短变量声明可以重新声明变量，前提是它们最初在相同块中声明的（如函数体）具有相同类型，并且至少有一个非空变量。因此，重新声明只能出现在多变量短声明中。重新声明不引入新的变量; 它只是为原始值分配一个新值。

func main() {
      c:=10
      c:=23
  //----上面短声明使用错误，重声明只能出现在多变量短声明中---
    a := 10
    fmt.Println(&a, a)
    a, b := 15, 39
    fmt.Println(&a, a, b)
}

打印结果。

 0xc082002278 10
 0xc082002278 15 39

短声明作用域。

坑

    func() (err error) {
        a, err := 1, errors.New(" a error") // a是新创建变量，err是被赋值
        if err != nil {
            return // 正确返回err
        }
              //  ------------------------------------------------
        if b, err := 2,  errors.New("b error"); err != nil { // 此刻if语句中err被重新创建
            return     // if语句中的err覆盖外面的err，导致编译
                      //  错误 (err is shadowed during return。)
        } else {
            fmt.Println(b)
        }
        return
    }()

上面的代码，由于 := 导致的作用域的原因出现错误，需要注意一下如果 := 左边的某个变量在外部的作用域已经定义，在里面的赋值会导致屏蔽掉外部的变量，创建一个新的变量在当前的作用域使用。如果需要更改外部的变量进行赋值=。

字符串效率

Go语言中字符串是不可变的（类似java和c#）。使用诸如a += b形式连接字符串效率低下，尤其在一个循环内部使用这种形式。这会导致大量的内存开销和拷贝。应该使用一个字符数组代替字符串，或将字符串内容写入一个缓存中。如下:

  str := func() string {
      var b bytes.Buffer
      for i := 0; i < 10; i++ {
          b.WriteString("wuxiao" + i)
      }
      return b.String()
  }()

defer使用

defer延时调用。

感觉很高大上

当一个函数调用有关键字 defer 的函数（变量）时, 那么这个 defer 函数（变量）会推迟到当前函数即将返回前执行。例如:

func(){
     a := 1
     defer fmt.Println("deder print:", a)
     a++
     fmt.Println("a add print:", a)
}()

需要注意, 使用 defer 关键字的函数中如果有参数，此参数定义时就确定了。
打印结果。

  a add print: 2
  deder print: 1

因此 defer fmt.Println("deder print:", a)调用时, a 的值已经确定了, 所有a等于1。

有一个有意思的例子更能加深对defer的理解。

func add(x int) int {
    return x + x
}

func result(x int) (r int) {
    defer func() {
        r += x
    }()
    return add(x)
}

func main() {
    fmt.Println(result(3))
}

强调一点: defer 关键字函数调用的执行顺序是外层函数设置返回值之后, 将要返回之前。
所有打印结果是9。

真年轻

之前写代码犯了一个错误如下:

  for _, file := range files {
     if f, err = os.Open(file); err != nil {
         return
     }
     defer f.Close()
     // 假设处理文件
     f.doSomething(data)
 }

代码没什么问题啊，没犯错啊！！！
no，会导致循环结尾的defer还没有执行，文件没有及时关闭！

  for _, file := range files {
     if f, err = os.Open(file); err != nil {
         return
     }
     // 假设处理文件
     f.doSomething(data)
     //正确做法
     f.Close()
 }

接口类型使用

type tester interface {
    test()
}

func testFun(n *tester) {
    n.test() // 编译错误:n.test未定义
}

哎呀为什么？？？

查了很多资料，接口类型本是一个指针，所有不能使用一个指针指向一个接口类型。

不懂

为了能更好理解interface，我们用一个demo了解interface内存做了什么。

type tester interface{
      test()
}
func testing() tester {
    var t tester
    return t
}
func main(){
    tester := testing()
    if tester == nil    //执行结果true
}

interface内存状态

简单查看interface源码与之对应，初始化interface内存会创建tab与data。

type iface struct {
    tab *itab
    data unsafe.Pointer
}

tab代表接口表，是一种保存有关接口和底层类型的结构：

type itab struct {
    inter *interfacetype
    _type *_type
    link *itab
    bad int32
    unused int32
    fun [1]uintptr // variable sized
}

从上面内存和源码可以看出interface确实是指针类型
还有一个坑需要与上面的内存图interface内存状态对应学习，代码与内存状态图如下:

type tester interface{
      test()
}
func testing() tester {
    var t *testIml //实现tester接口
    return t
}
func main(){
    tester := testing()
    if tester == nil    //执行结果false
}

接口实现后的内存状态图

总结:

• 从这俩个接口的内部结构我们可出，如果对实现接口的变量进行非空判断会出现自己不想要的结果，以后避免犯错。

有疑问加站长微信联系（非本文作者）