通過golang小案例,瞭解golang程式常見機制

x1aoda1 發表於 2021-03-04
Go

目錄

程式碼理解及糾錯

1、defer和panic執行先後順序

package main

 import (
     "fmt"
 )

 func main() {
     defer_call()
 }

func defer_call() {
    defer func() { fmt.Println("列印前") }()
    defer func() { fmt.Println("列印中") }()
    defer func() { fmt.Println("列印後") }()
    panic("觸發異常")
}
    列印後
    列印中
    列印前
    panic: 觸發異常

defer 的執行順序是後進先出。當出現 panic 語句的時候,會先按照 defer 的後進先出的順序執行,最後才會執行panic

2、for迴圈元素副本問題

func main() {

     slice := []int{0,1,2,3}
     m := make(map[int]*int)

     for key,val := range slice {
         m[key] = &val
         
        // 正確寫法
        // value := val
        // m[key] = &value
     }
     


    for k,v := range m {
        fmt.Println(k,"->",*v)
    }
}
    0 -> 3
    1 -> 3
    2 -> 3
    3 -> 3

這是新手常會犯的錯誤寫法,for range 迴圈的時候會建立每個元素的副本,而不是元素的引用,所以 m[key] = &val 取的都是變數 val 的地址,所以最後 map 中的所有元素的值都是變數 val 的地址,因為最後 val 被賦值為3,所有輸出都是3

3、slice追加元素問題

// 1.
 func main() {
     s := make([]int, 5)
     s = append(s, 1, 2, 3)
     fmt.Println(s)
 }

// 2.
 func main() {
    s := make([]int,0)
    s = append(s,1,2,3,4)
    fmt.Println(s)
}

兩段程式碼分別輸出:

    [0 0 0 0 0 1 2 3]
    [1 2 3 4]

append 向 slice 新增元素,第一段程式碼常見的錯誤是 [1 2 3],需要注意。

4、返回值命名問題

    // 第二個返回值未命名錯誤
    func funcMui(x,y int)(sum int,error){
        return x+y,nil
    }

在函式有多個返回值時,只要有一個返回值有命名,其他的也必須命名。如果有多個返回值必須加上括號();如果只有一個返回值且命名也必須加上括號()。這裡的第一個返回值有命名 sum,第二個沒有命名,所以錯誤。

5、用new初始化內建型別問題

func main() {
    list := new([]int)
    list = append(list, 1)
    fmt.Println(list)
}

不能通過編譯,new([]int) 之後的 list 是一個 *[]int 型別的指標,不能對指標執行 append 操作。可以使用 make() 初始化之後再用。同樣的,map 和 channel 建議使用 make() 或字面量的方式初始化,不要用 new() 。

6、切片append另外一個切片問題

func main() {
    s1 := []int{1, 2, 3}
    s2 := []int{4, 5}
    s1 = append(s1, s2)
    fmt.Println(s1)
}

不能通過編譯。append() 的第二個引數不能直接使用 slice,需使用 … 操作符,將一個切片追加到另一個切片上:append(s1,s2…)。或者直接跟上元素,形如:append(s1,1,2,3)。

7、全域性變數用:=宣告問題

var(
    size := 1024
    max_size = size*2
)

func main() {
    fmt.Println(size,max_size)
}

:=只能在函式內部使用

8、結構體比較問題

func main() {
    sn1 := struct {
        age  int
        name string
    }{age: 11, name: "qq"}
    sn2 := struct {
        age  int
        name string
    }{age: 11, name: "qq"}

    if sn1 == sn2 {
        fmt.Println("sn1 == sn2")
    }

    sm1 := struct {
        age int
        m   map[string]string
    }{age: 11, m: map[string]string{"a": "1"}}
    sm2 := struct {
        age int
        m   map[string]string
    }{age: 11, m: map[string]string{"a": "1"}}

    if sm1 == sm2 {
        fmt.Println("sm1 == sm2")
    }
}

編譯不通過 invalid operation: sm1 == sm2;

  • 結構體只能比較是否相等,但是不能比較大小。
  • 相同型別的結構體才能夠進行比較,結構體是否相同不但與屬性型別有關,還與屬性順序相關
  • 如果 struct 的所有成員都可以比較,則該 struct 就可以通過 == 或 != 進行比較是否相等,比較時逐個項進行比較,如果每一項都相等,則兩個結構體才相等,否則不相等;

那什麼是可比較的呢,常見的有 bool、數值型、字元、指標、陣列等。像切片、map、函式等是不能比較的。 具體可以參考 Go 說明文件。

9、iota的使用

const (
     x = iota
     _
     y
     z = "zz"
     k 
     p = iota
 )

func main()  {
    fmt.Println(x,y,z,k,p)
}

編譯通過,輸出:0 2 zz zz 5。知識點:iota 的使用.

  • 每次 const 出現時,都會讓 iota 初始化為0
  • iota出現後,下面的變數無初始值,會按照iota自增長
  • 下劃線_可以跳過該行iota的增長,iota還是按行增長的,知道遇到不為const和_的其他變數

10、介面型別斷言使用

func GetValue() int {
     return 1
 }

 func main() {
     i := GetValue()
     switch i.(type) {
     case int:
         println("int")
     case string:
        println("string")
     case interface{}:
        println("interface")
     default:
        println("unknown")
    }
}

編譯失敗。考點:型別選擇,型別選擇的語法形如:i.(type),其中 i 是介面,type 是固定關鍵字,需要注意的是,只有介面型別才可以使用型別選擇。

11、不同型別相加問題

func main() {  
    a := 5
    b := 8.1
    fmt.Println(a + b)
}

a 的型別是 int,b 的型別是 float,兩個不同型別的數值不能相加,編譯報錯。可以使用型別強轉來相加

12、陣列型別比較問題

func main() {
    a := [2]int{5, 6}
    b := [3]int{5, 6}
    if a == b {
        fmt.Println("equal")
    } else {
        fmt.Println("not equal")
    }
}

Go 中的陣列是值型別,可比較,另外一方面,陣列的長度也是陣列型別的組成部分,所以 a 和 b 是不同的型別,是不能比較的,所以編譯錯誤。

13、map刪除不存在的值和獲取不存在的值

func main() {  
    s := make(map[string]int)
    delete(s, "h")
    fmt.Println(s["h"])
}

刪除 map 不存在的鍵值對時,不會報錯,相當於沒有任何作用;獲取不存在的減值對時,返回值型別對應的零值,所以返回 0。

14、格式化輸出問題

func main() {  
    i := -5
    j := +5
    fmt.Printf("%+d %+d", i, j)
}

%d表示輸出十進位制數字,+表示輸出數值的符號。

15、結構體優先呼叫外層方法

type People struct{}

func (p *People) ShowA() {
    fmt.Println("showA")
    p.ShowB()
}
func (p *People) ShowB() {
    fmt.Println("showB")
}

type Teacher struct {
    People
}

func (t *Teacher) ShowB() {
    fmt.Println("teacher showB")
}

func main() {
    t := Teacher{}
    t.ShowB()
}

外部型別通過巢狀可以繼承內部結構體的方法,外部型別還可以定義自己的屬性和方法,甚至可以定義與內部相同的方法,這樣內部型別的方法就會被“遮蔽”。這個例子中的 ShowB() 就是同名方法。

16、defer引數傳遞副本

func hello(i int) {  
    fmt.Println(i)
}
func main() {  
    i := 5
    defer hello(i)
    i = i + 10
}

這個例子中,hello() 函式的引數在執行defer語句的時候會儲存一份副本,在實際呼叫 hello() 函式時用,所以是輸出5

17、字串只讀

func main() {
    str := "hello"
    str[0] = 'x'
    fmt.Println(str)
}

Go 語言中的字串是隻讀的。所以編譯錯誤compilation error

18、整數強轉字串

func main() {  
    i := 65
    fmt.Println(string(i))
}

UTF-8 編碼中,十進位制數字 65 對應的符號是 A。輸出A

19、切片長度問題

func main() {

    s := [3]int{1, 2, 3}
    a := s[:0]
    b := s[:2]
    c := s[1:2:cap(s)]
}

a長度是0,容量是3;

b長度是2,容量是3;

c長度是1,容量是2;cap(s)雖然是3,但是子切片的容量不能大於底層陣列的長度

擷取操作有帶 2 個或者 3 個引數,形如:[i:j] 和 [i:j:k],假設擷取物件的底層陣列長度為 l。在操作符 [i:j] 中,如果 i 省略,預設 0,如果 j 省略,預設底層陣列的長度,擷取得到的切片長度和容量計算方法是 j-i、l-i。操作符 [i:j:k],k 主要是用來限制切片的容量,但是不能大於陣列的長度 l,擷取得到的切片長度和容量計算方法是 j-i、k-i。

20、閉包引用和匿名函式問題

type Person struct {
    age int
}

func main() {
    person := &Person{28}

    // 1. 
    defer fmt.Println(person.age)

    // 2.
    defer func(p *Person) {
        fmt.Println(p.age)
    }(person)  

    // 3.
    defer func() {
        fmt.Println(person.age)
    }()

    person.age = 29
}

1.person.age 此時是將 28 當做 defer 函式的引數,會把 28 快取在棧中,等到最後執行該 defer 語句的時候取出,即輸出 28;

2.defer 快取的是結構體 Person{28} 的地址,最終 Person{28} 的 age 被重新賦值為 29,所以 defer 語句最後執行的時候,依靠快取的地址取出的 age 便是 29,即輸出 29;

3.閉包引用,輸出 29;

又由於 defer 的執行順序為先進後出,即 3 2 1,所以輸出 29 29 28。

21、錯吧字串和nil比較的問題

package main
import (
    "fmt"
)
func main() {
    var x string = nil // 錯誤1
    if x == nil { // 錯誤2
        x = "default"
    }
    fmt.Println(x)
}

golang 的字串型別是不能賦值 nil 的,也不能跟 nil 比較。

22、return後的defer無效問題

var a bool = true
func main() {
    defer func(){
        fmt.Println("1")
    }()
    if a == true {
        fmt.Println("2")
        return
    }
    defer func(){
        fmt.Println("3")
    }()
}

輸出2 1; defer 關鍵字後面的函式或者方法想要執行必須先註冊,return 之後的 defer 是不能註冊的, 也就不能執行後面的函式或方法

23、切片共享底層陣列,append擴容後生成新的陣列

func main() {

    s1 := []int{1, 2, 3}
    s2 := s1[1:]
    s2[1] = 4
    fmt.Println(s1)
    s2 = append(s2, 5, 6, 7)
    fmt.Println(s1)
}
[1 2 4]

[1 2 4]

1、golang 中切片底層的資料結構是陣列。當使用 s1[1:] 獲得切片 s2,和 s1 共享同一個底層陣列,這會導致 s2[1] = 4 語句影響 s1。

2、append 操作會導致底層陣列擴容,生成新的陣列,因此追加資料後的 s2 不會影響 s1。

24、map無序問題

func main() {
    m := map[int]string{0:"zero",1:"one"}
    for k,v := range m {
        fmt.Println(k,v)
    }
}
# 由於map無序,所以輸出結果為
0 zero
1 one
# 或者
1 one
0 zero

25、defer巢狀其他函式問題

func main() {
    a := 1
    b := 2
    defer calc("1", a, calc("10", a, b))
    a = 0
    defer calc("2", a, calc("20", a, b))
    b = 1
}

func calc(index string, a, b int) int {
    ret := a + b
    fmt.Println(index, a, b, ret)
    return ret
}
10 1 2 3
20 0 2 2
2 0 2 2
1 1 3 4

defer會預先把需要的值存起來,如果該值是一個函式的返回,會先計算。之後再按照defer倒序輸出

26、指標接收者實現介面,值無法呼叫問題

type People interface {
    Speak(string) string
}

type Student struct{}

func (stu *Student) Speak(think string) (talk string) {
    if think == "speak" {
        talk = "speak"
    } else {
        talk = "hi"
    }
    return
}

func main() {
    var peo People = Student{}
    think := "speak"
    fmt.Println(peo.Speak(think))
}

編譯失敗;原因是基礎面試題26點,注意事項第二點。如果是值接收者,實體型別的值和指標都可以實現對應的介面;如果是指標接收者,那麼只有型別的指標能夠實現對應的介面

27、介面賦值為nil問題

type People interface {
    Show()
}

type Student struct{}

func (stu *Student) Show() {

}

func main() {

    var s *Student
    if s == nil {
        fmt.Println("s is nil")
    } else {
        fmt.Println("s is not nil")
    }
    var p People = s
    if p == nil {
        fmt.Println("p is nil")
    } else {
        fmt.Println("p is not nil")
    }
}
s is nil

p is not nil

這道題看似有點詫異,我們分配給變數 p 的值明明是 nil,然而 p 卻不是 nil。記住一點,當且僅當動態值和動態型別都為 nil 時,介面型別值才為 nil。上面的程式碼,給變數 p 賦值之後,p 的動態值是 nil,但是動態型別卻是 *Student,是一個 nil 指標,所以相等條件不成立

28、go中不同型別不能比較

func main() {
    fmt.Println([...]int{1} == [2]int{1})
    fmt.Println([]int{1} == []int{1})
}

有兩處錯誤:

1、go 中不同型別是不能比較的,而陣列長度是陣列型別的一部分,所以 […]int{1} 和 [2]int{1} 是兩種不同的型別,不能比較;

2、切片是不能比較的;

29、迴圈且追加切片

func main() {
    v := []int{1, 2, 3}
    for i := range v {
        v = append(v, i)
    }
}

fmt.Println(v)
[1 2 3 0 1 2]

不會出現死迴圈,能正常結束。迴圈次數在迴圈開始前就已經確定,迴圈內改變切片的長度,不影響迴圈次數。注意,這點跟java不一樣

public class Test {

    public static void main(String[] args) {
        List<Integer> lss = new ArrayList<>();
        lss.add(1);
        lss.add(2);
        lss.add(3);
        for (Integer integer : lss) {
            lss.add(integer);
        }

        System.out.println(JSON.toJSON(lss));
    }
}
# java的這段迴圈,會報錯
Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at com.dtstack.common.test.main(test.java:22)

30、協程閉包引用問題

func main() {

    var m = [...]int{1, 2, 3}

    for i, v := range m {
        go func() {
            fmt.Println(i, v)
        }()
        
        // 正確寫法
        // go func(i,v int) {
        //     fmt.Println(i, v)
        // }(i,v)
    }

    time.Sleep(time.Second * 3)
}
2 3
2 3
2 3

各個 goroutine 中輸出的 i、v 值都是 for range 迴圈結束後的 i、v 最終值,而不是各個goroutine啟動時的i, v值。可以理解為閉包引用,使用的是上下文環境的值。

31、陣列傳遞給for迴圈也是值拷貝

func main() {
    var a = [5]int{1, 2, 3, 4, 5}
    var r [5]int

    for i, v := range a {
    // for i, v := range &a {
        if i == 0 {
            a[1] = 12
            a[2] = 13
        }
        r[i] = v
    }
    fmt.Println("r = ", r)
    fmt.Println("a = ", a)
}
r =  [1 2 3 4 5]
a =  [1 12 13 4 5]

可以對陣列的地址進行for迴圈,或者使用切片都可

func main() {
	var a = []int{1, 2, 3, 4, 5}
	var r [5]int

	for i, v := range a {
		if i == 0 {
			a[1] = 12
			a[2] = 13
		}
		r[i] = v
	}
	fmt.Println("r = ", r)
	fmt.Println("a = ", a)
}
r =  [1 12 13 4 5]
a =  [1 12 13 4 5]

32、切片擴容生成新的底層陣列

func change(s ...int) {
    s = append(s,3)
}

func main() {
    slice := make([]int,5,5)
    slice[0] = 1
    slice[1] = 2
    // 觸發擴容
    change(slice...)
    fmt.Println(slice)
    // 新切片長度為2,容量為5。不會觸發擴容,所以會改變底層陣列
    change(slice[0:2]...)
    fmt.Println(slice)
}
[1 2 0 0 0]
[1 2 3 0 0]

Go 提供的語法糖…,可以將 slice 傳進可變函式,不會建立新的切片。第一次呼叫 change() 時,append() 操作使切片底層陣列發生了擴容,原 slice 的底層陣列不會改變;第二次呼叫change() 函式時,使用了操作符[i,j]獲得一個新的切片,假定為 slice1,它的底層陣列和原切片底層陣列是重合的,不過 slice1 的長度、容量分別是 2、5,所以在 change() 函式中對 slice1 底層陣列的修改會影響到原切片。

33、通道channal和select機制

func main() {
    runtime.GOMAXPROCS(1)
    int_chan := make(chan int, 1)
    string_chan := make(chan string, 1)
    int_chan <- 1
    string_chan <- "hello"
    select {
    case value := <-int_chan:
        fmt.Println(value)
    case value := <-string_chan:
        panic(value)
    }
}

select 會隨機選擇一個可用通道做收發操作,所以可能觸發異常,也可能不會。

34、常量定址問題

const i = 100
var j = 123

func main() {
    fmt.Println(&j, j)
    fmt.Println(&i, i)
}

常量不同於變數的在執行期分配記憶體,常量通常會被編譯器在預處理階段直接展開,作為指令資料使用,所以常量無法定址。

35、協程間排程問題

func main() {
     ch := make(chan int, 100)
     // A
     go func() {              
         for i := 0; i < 10; i++ {
             ch <- i
         }
     }()
     // B
    go func() {
        for {
            a, ok := <-ch
            if !ok {
                fmt.Println("close")
                return
            }
            fmt.Println("a: ", a)
        }
    }()
    close(ch)
    fmt.Println("ok")
    time.Sleep(time.Second * 10)
}

程式會拋異常。先定義下,第一個協程為 A 協程,第二個協程為 B 協程;當 A 協程還沒起時,主協程已經將 channel 關閉了,當 A 協程往關閉的 channel 傳送資料時會 panic,panic: send on closed channel。

36、nil的map不能直接賦值,nil的切片可以用append增加元素

func main() {

    var s []int
    s = append(s,1)

    var m map[string]int
    m["one"] = 1  // 報錯
}

37、常量預設賦值問題

const (
     x uint16 = 120
     y
     s = "abc"
     z
 )
 func main() {
    fmt.Printf("%T %v\n", y, y)
    fmt.Printf("%T %v\n", z, z)
}
    uint16 120
    string abc

38、結構體變數可匯出,json反序列化

type People struct {
     name string `json:"name"`
}
func main() {
     js := `{
         "name":"seekload"
     }`
     var p People
     err := json.Unmarshal([]byte(js), &p)
     if err != nil {
        fmt.Println("err: ", err)
        return
    }
    fmt.Println(p)
}
{}

結構體訪問控制,因為 name 首字母是小寫,導致其他包不能訪問,所以輸出為空結構體。

39、結構體雖然值傳遞,引用欄位仍然可操作底層結構

type T struct {
    ls []int
}
func foo(t T) {
    t.ls[0] = 100
}
func main() {
    var t = T{
        ls: []int{1, 2, 3},
    }
    foo(t)
    fmt.Println(t.ls[0])
}
100

呼叫 foo() 函式時雖然是傳值,但 foo() 函式中,欄位 ls 依舊可以看成是指向底層陣列的指標。

40、函式只能和nil比較,不能同其他函式比較

func main() {
    var fn1 = func() {}
    var fn2 = func() {}
    if fn1 != fn2 {
       println("fn1 not equal fn2")
    }
}
invalid operation: fn1 != fn2 (func can only be compared to nil)

41、recover捕獲panic,函式遇panic就不會往下執行

func f() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("recover:%#v", r)
        }
    }()
    panic(1)
    panic(2)
}

func main() {
    f()
}
recover:1

當程式 panic 時就不會往下執行,可以使用 recover() 捕獲 panic 的內容。這裡panic(2)得不到執行

42、WaitGroup的wait和add和done問題

func main() {
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        fmt.Println("1")
        wg.Done()
        wg.Add(1)
    }()
    wg.Wait()
}

協程裡面,使用 再次wg.Add(1) 但是沒有其他協程 wg.Done(),導致 panic()。

43、切片共享底層陣列及擴容問題

func main() {
    a := [3]int{0, 1, 2}
    s := a[1:2] // {1}

    s[0] = 11 // 由於共享底層陣列,所以a變為{0, 11, 2} s變為{11}
    s = append(s, 12) // a變為{0, 11, 12} s變為{11, 12}
    s = append(s, 13) // 超過cap,s發生擴容,不再共享a的底層陣列 s變為{11, 12, 13} a仍為{0, 11, 12}
    s[0] = 21 // s變為{21, 12, 13} 底層陣列不共享a,a仍然為{0, 11, 12}

    fmt.Println(a)
    fmt.Println(s)
}
    [0 11 12]
    [21 12 13]

44、切片拷貝問題

func main() {
    var src, dst []int
    src = []int{1, 2, 3}
    copy(dst, src) 
    fmt.Println(dst)
}
[]

copy(dst, src) 函式返回 len(dst)、len(src) 之間的最小值。如果想要將 src 完全拷貝至 dst,必須給 dst 分配足夠的記憶體空間。

可以預分配空間拷貝,或者使用append函式拷貝

func main() {
    var src, dst []int
    src = []int{1, 2, 3}
    dst = make([]int, len(src))
    n := copy(dst, src)
    fmt.Println(n,dst)
}
func main() {
    var src, dst []int
    src = []int{1, 2, 3}
    dst = append(dst, src...)
    fmt.Println("dst:", dst)
}

45、go的鎖不可重入

var mu sync.Mutex
var chain string

func main() {
    chain = "main"
    A()
    fmt.Println(chain)
}
func A() {
    mu.Lock()
    defer mu.Unlock()
    chain = chain + " --> A"
    B()
}

func B() {
    chain = chain + " --> B"
    C()
}

func C() {
    mu.Lock()
    defer mu.Unlock()
    chain = chain + " --> C"
}
fatal error: all goroutines are asleep - deadlock!

會fatal error錯誤。使用 Lock() 加鎖後,不能再繼續對其加鎖,直到利用 Unlock() 解鎖後才能再加鎖。

46、結構體帶有鎖,在賦值的之後會一併賦值當前鎖狀態

type MyMutex struct {
    count int
    sync.Mutex
}

func main() {
    var mu MyMutex
    mu.Lock()
    var mu1 = mu
    mu.count++
    mu.Unlock()
    mu1.Lock()
    mu1.count++
    mu1.Unlock()
    fmt.Println(mu.count, mu1.count)
}
fatal error: all goroutines are asleep - deadlock!

加鎖後複製變數,會將鎖的狀態也複製,所以 mu1 其實是已經加鎖狀態,再加鎖會死鎖。