Go 小白的十万个为什么

上篇文章我提出 channel 在什么样的操作下会引发 panic。这篇文章就让我们来总结一下小白在 go 中经常会问的十万个为什么。

string

假设我们要修改类型为字符串变量的某个字符,如果是之前世界上最伟大的语言,那么可以直接这样(差点忘本不会写php了):

<?php

$name = "test";
$name[0] = "T";
var_dump($name);
// string(4) "Test"

在 go 中是不允许使用索引下标操作字符串变量中的字符的,会直接编译错误。

// 不被允许
  x := "test"
  x[0] = 'T'
  //cannot assign to x[0]

一般要修改我会转换成 byte。

package main
import "fmt"

func main() {
  s := "test"
  bytes := []byte(s)
  bytes[0] = 'T'
  fmt.Println("s的值:", string(bytes))
  // s的值: Test
}

array

我们来看这样一段程序,

import "fmt"
func main() {
  a := [3]int{10, 20, 30}
  changeArray(a)
  fmt.Println("a的值:", a)
}

func changeArray(items [3]int) {
  items[2] = 50
}
// a的值: [10 20 30]

答案并不会是 [10,20,30]。因为上面把数组传递给函数时,数组将会被复制,是一个值传递,那么之后的修改当然和之前的没有关系。

当然你可以传递数组指针,这样他们指向的就是同一个地址了。

func main() {
  a := [3]int{10, 20, 30}
  changeArray(&a)
  fmt.Println("a的值:", a)
}

//数组是值传递
func changeArray(items *[3]int) {
  items[2] = 50
}
//a的值: [10 20 50]

或者可以使用 slice。

package main

import "fmt"

func main() {
  s := []int{10, 20, 30}
  changeSlice(s)
  fmt.Println("s的值是:",s)
}
func changeSlice(items []int) {
  items[2] = 50
}
// s的值是: [10 20 50]

slice 本质上不存储任何数据,它只是描述基础数组的一部分。slice 在底层的结构是,

type slice struct {
  array unsafe.Pointer // 底层数组的指针位置
  len   int // 切片当前长度
  cap   int //容量,当容量不够时,会触发动态扩容的机制
}

当传递的是 slice,并且切片的底层结构 array 的值还是指向同一个数组指针地址时,对数组元素的修改会相互影响。

slice

看看下面的代码,

package main

import "fmt"

func main() {
  data := cutting()
  fmt.Printf("data's len:%v,cap:%v\n", len(data), cap(data))
}

func cutting() []int {
  val := make([]int, 1000)
  fmt.Printf("val's len:%v,cap:%v\n ", len(val), cap(val))
  return val[0:10]
}
// val's len:1000,cap:1000
// data's len:10,cap:1000

就像上面说的,当在原有 slice 的基础上截取出新的 sliceslice 将会引用原切片的底层数组。如果是一个大的切片,会导致内存的浪费。

我们可以通过额外定义一个容量大小合适的变量,然后通过 copy 操作。

package main

import "fmt"

func main() {
  data := cutting()
  fmt.Printf("data's len:%v,cap:%v\n", len(data), cap(data))
}
func cutting() []int {
  val := make([]int, 1000)
  fmt.Printf("val's len:%v,cap:%v\n ", len(val), cap(val))
  res := make([]int, 10)
  copy(res, val)
  return res
}

//val's len:1000,cap:1000
// data's len:10,cap:10

copy

既然上面出现了 copy,那么我们来看看 copy

package main

import "fmt"

func main() {
  var test1, test2 []int
  test1 = []int{1, 2, 3}
  copy(test2, test1)
  fmt.Println("test2 的值:", test2)
}
// test2 的值: []

为什么会这样?

copy 复制的元素数目是两个切片中最小的长度。当前 test1test2 的最小长度为 test2 的0,因此最终返回空切片,我们可以为 test2 分配长度。

package main

import "fmt"

func main() {
  var test1, test2 []int
  test1 = []int{1, 2, 3}
  test2=make([]int,len(test1))
  copy(test2,test1)
  fmt.Println("test2 的值:",test2)
}
// test2 的值: [1 2 3]

range

我们来看下面的代码,

package main

import "fmt"

func main() {
  res := []int{1, 2, 3}
  for _, item := range res {
    item *= 10
  }
  fmt.Println("res:", res)
}
// res: [1 2 3]

最终的值并没有想象中的 [10,20,30]。为什么?

因为在 go 中 range 第二个返回值实际上是一个值拷贝。

这也告诉我们当遍历切片类型为结构体时,需要避免这样的操作,此操作会消耗大量的内存,我们可以通过索引下标搞定。

package main

import "fmt"

func main() {
  res := []int{1, 2, 3}
  for index, _ := range res {
    res[index] *= 10
  }
  fmt.Println("res:", res)
  // res: [10 20 30]
}

struct

我们经常会使用 “==” 去判断两个结构体是否相等,比如,

package main

import "fmt"

type User struct {
  Name string
  Age  int

}
func main() {
  user1 := User{}
  user2 := User{}
  fmt.Println(user1 == user2)
  // true
}

这样是没问题的,如果我往结构体加一个这样的字段呢?

package main

import "fmt"

type User struct {
  Name string
  Age  int
  IsChild func(age int) bool
}

func main() {
  user1 := User{}
  user2 := User{}
  fmt.Println(user1 == user2)
  // invalid operation: user1 == user2 (struct containing func(int) bool cannot be compared)
}

直接报编译错误,为什么?

如果结构体中的任一字段不具有可比性,那么使用 “==” 运算符会导致编译出错。上面我加的 IsChild 字段类型为闭包函数显然不具备可比性。

groutine

package main

import (
  "fmt"
)

func main() {
  var hi string
  go func() {
    hi = "golang"
  }()
  fmt.Println(hi)
}

以上输出什么?

大概率啥都没有,因为在子协程给 hi 变量赋值前,主协程大概率先打印,然后运行结束,接着整个程序结束了。

用最愚蠢的方法让主协程停一下。

package main

import (
  "fmt"
  "time"
)

func main() {
  var hi string
  go func() {
    hi = "golang"
  }()
  time.Sleep(10 * time.Millisecond)
  fmt.Println(hi)
  //golang
}

再来看这题,

package main

import (
  "fmt"
  "sync"
)

func main() {
  var wg sync.WaitGroup
  for i := 0; i < 5; i++ {
    wg.Add(1)
    go func() {
      fmt.Println("值是:", i)
      wg.Done()
    }()
  }
  wg.Wait()
}

每次运行,答案都不相同,但是大概率都是5。这里的操作存在数据竞争,即 data race。这种情况发生的条件是,当两个或两个以上 groutine 并发地访问同一个变量并且有一个访问是写入时,就会引发 data race

可以通过命令行新增参数 -race 运行检测。
图片

修复的方式也会简单,在启动 groutine 时使用局部变量并将数字作为参数传递。

package main

import (
  "fmt"
  "sync"
)
func main() {
  var wg sync.WaitGroup
  for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(item int) {
      fmt.Println("值是:", item)
      wg.Done()
    }(i)
  }
  wg.Wait()
}

recover()

在 go 中可以使用 recover() 函数捕获 panic,但是我们也需要注意它的用法,以下使用姿势都是错误的。

package main

import "fmt"

func main() {
  recover()
  panic("make error")
}
// 错误姿势
package main

import "fmt"


func main() {
  doRecover()
  panic("make error")
}

func doRecover() {
  defer func() {
    if err := recover(); err != nil {
      fmt.Println("出错了")
    }
  }()
}
// 错误姿势
package main

import "fmt"


func main() {
  defer func() {
    defer func() {
      if err := recover(); err != nil {
        fmt.Println(err)
      }
    }()
  }()
  panic("make error")
}
// 错误姿势

它只有在延迟函数中直接调用才能生效。

package main

import "fmt"

func main() {
  defer func() {
    if err := recover(); err != nil {
      fmt.Println(err)
    }
  }()
  panic("make error")
}
// 正确姿势

还有好多错误姿势没有列举,你有不一样的错误操作嘛?欢迎下方留言一起讨论。

如果文章对你有所帮助,点赞、转发、留言都是一种支持!
图片

本作品采用《CC 协议》,转载必须注明作者和本文链接
吴亲库里
讨论数量: 2
kinyou
package main
import "fmt"

func main() {
  s := "go语言"
  bytes := []byte(s)
  bytes[3] = 'L'
  fmt.Println("s的值:", string(bytes))
  // s的值: Test
}

如果修改为这样, 会出现啥那 ?

2个月前 评论

需要修改string类型,转[]rune()更科学吧。

2个月前 评论
kinyou 2个月前

讨论应以学习和精进为目的。请勿发布不友善或者负能量的内容,与人为善,比聪明更重要!