最近在很多地方看到了golang的面試題，看到了很多人對Golang的面試題心存恐懼，也是為了複習基礎，我把解題的過程總結下來。

面試題

1. 寫出下面程式碼輸出內容。

package main

import (
    "fmt"
)

func main() {
    defer_call()
}

func defer_call() {
    defer func() { fmt.Println("列印前") }()
    defer func() { fmt.Println("列印中") }()
    defer func() { fmt.Println("列印後") }()

    panic("觸發異常")
}
 

考點：defer執行順序

解答： defer 是後進先出。 panic 需要等defer 結束後才會向上傳遞。 出現panic恐慌時候，會先按照defer的後入先出的順序執行，最後才會執行panic。

列印後 列印中 列印前 panic: 觸發異常

1. 以下程式碼有什麼問題，說明原因。

type student struct {
    Name string
    Age  int
}

func pase_student() {
    m := make(map[string]*student)
    stus := []student{
        {Name: "zhou", Age: 24},
        {Name: "li", Age: 23},
        {Name: "wang", Age: 22},
    }
    for _, stu := range stus {
        m[stu.Name] = &stu
    }

}
 

考點：foreach 解答： 這樣的寫法初學者經常會遇到的，很危險！ 與Java的foreach一樣，都是使用副本的方式。所以m[stu.Name]=&stu實際上一致指向同一個指標， 最終該指標的值為遍歷的最後一個struct的值拷貝。 就像想修改切片元素的屬性：

for _, stu := range stus {
    stu.Age = stu.Age+10
}

也是不可行的。 大家可以試試打印出來：

func pase_student() {
    m := make(map[string]*student)
    stus := []student{
        {Name: "zhou", Age: 24},
        {Name: "li", Age: 23},
        {Name: "wang", Age: 22},
    }
    // 錯誤寫法
    for _, stu := range stus {
        m[stu.Name] = &stu
    }

    for k,v:=range m{
        println(k,"=>",v.Name)
    }

    // 正確
    for i:=0;i<len(stus);i++  {
        m[stus[i].Name] = &stus[i]
    }
    for k,v:=range m{
        println(k,"=>",v.Name)
    }
}
 

1. 下面的程式碼會輸出什麼，並說明原因

func main() {
    runtime.GOMAXPROCS(1)
    wg := sync.WaitGroup{}
    wg.Add(20)
    for i := 0; i < 10; i++ {
        go func() {
            fmt.Println("A: ", i)
            wg.Done()
        }()
    }
    for i := 0; i < 10; i++ {
        go func(i int) {
            fmt.Println("B: ", i)
            wg.Done()
        }(i)
    }
    wg.Wait()
}

考點：go執行的隨機性和閉包 解答： 誰也不知道執行後列印的順序是什麼樣的，所以只能說是隨機數字。 但是A:均為輸出10，B:從0~9輸出(順序不定)。 第一個go func中i是外部for的一個變數，地址不變化。遍歷完成後，最終i=10。 故go func執行時，i的值始終是10。

第二個go func中i是函式引數，與外部for中的i完全是兩個變數。 尾部(i)將發生值拷貝，go func內部指向值拷貝地址。

1. 下面程式碼會輸出什麼？

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.ShowA()
}

考點：go的組合繼承 解答： 這是Golang的組合模式，可以實現OOP的繼承。 被組合的型別People所包含的方法雖然升級成了外部型別Teacher這個組合型別的方法（一定要是匿名欄位），但它們的方法(ShowA())呼叫時接受者並沒有發生變化。 此時People型別並不知道自己會被什麼型別組合，當然也就無法呼叫方法時去使用未知的組合者Teacher型別的功能。

showA
showB

1. 下面程式碼會觸發異常嗎？請詳細說明

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隨機性 解答： select會隨機選擇一個可用通用做收發操作。 所以程式碼是有肯觸發異常，也有可能不會。 單個chan如果無緩衝時，將會阻塞。但結合 select可以在多個chan間等待執行。有三點原則：

select 中只要有一個case能return，則立刻執行。 當如果同一時間有多個case均能return則偽隨機方式抽取任意一個執行。 如果沒有一個case能return則可以執行”default”塊。 6. 下面程式碼輸出什麼？

func calc(index string, a, b int) int {
    ret := a + b
    fmt.Println(index, a, b, ret)
    return ret
}

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
}

考點：defer執行順序 解答： 這道題類似第1題 需要注意到defer執行順序和值傳遞 index:1肯定是最後執行的，但是index:1的第三個引數是一個函式，所以最先被呼叫calc("10",1,2)==>10,1,2,3 執行index:2時,與之前一樣，需要先呼叫calc("20",0,2)==>20,0,2,2 執行到b=1時候開始呼叫，index:2==>calc("2",0,2)==>2,0,2,2 最後執行index:1==>calc("1",1,3)==>1,1,3,4

10 1 2 3
20 0 2 2
2 0 2 2
1 1 3 4

1. 請寫出以下輸入內容

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

考點：make預設值和append 解答： make初始化是由預設值的哦，此處預設值為0

[0 0 0 0 0 1 2 3] 大家試試改為:

s := make([]int, 0)
s = append(s, 1, 2, 3)
fmt.Println(s)//[1 2 3]

1. 下面的程式碼有什麼問題?

type UserAges struct {
	ages map[string]int
	sync.Mutex
}

func (ua *UserAges) Add(name string, age int) {
	ua.Lock()
	defer ua.Unlock()
	ua.ages[name] = age
}

func (ua *UserAges) Get(name string) int {
	if age, ok := ua.ages[name]; ok {
		return age
	}
	return -1
}

考點：map執行緒安全 解答： 可能會出現fatal error: concurrent map read and map write. 修改一下看看效果

func (ua *UserAges) Get(name string) int {
    ua.Lock()
    defer ua.Unlock()
    if age, ok := ua.ages[name]; ok {
        return age
    }
    return -1
}
9. 下面的迭代會有什麼問題？
func (set *threadSafeSet) Iter() <-chan interface{} {
	ch := make(chan interface{})
	go func() {
		set.RLock()

		for elem := range set.s {
			ch <- elem
		}

		close(ch)
		set.RUnlock()

	}()
	return ch
}

考點：chan快取池 解答： 看到這道題，我也在猜想出題者的意圖在哪裡。 chan?sync.RWMutex?go?chan快取池?迭代? 所以只能再讀一次題目，就從迭代入手看看。 既然是迭代就會要求set.s全部可以遍歷一次。但是chan是為快取的，那就代表這寫入一次就會阻塞。 我們把程式碼恢復為可以執行的方式，看看效果

package main

import (
    "sync"
    "fmt"
)


//下面的迭代會有什麼問題？

type threadSafeSet struct {
    sync.RWMutex
    s []interface{}
}

func (set *threadSafeSet) Iter() <-chan interface{} {
    // ch := make(chan interface{}) // 解除註釋看看！
    ch := make(chan interface{},len(set.s))
    go func() {
        set.RLock()

        for elem,value := range set.s {
            ch <- elem
            println("Iter:",elem,value)
        }

        close(ch)
        set.RUnlock()

    }()
    return ch
}

func main()  {

    th:=threadSafeSet{
        s:[]interface{}{"1","2"},
    }
    v:=<-th.Iter()
    fmt.Sprintf("%s%v","ch",v)
}

1. 以下程式碼能編譯過去嗎？為什麼？

package main

import (
	"fmt"
)

type People interface {
	Speak(string) string
}

type Stduent struct{}

func (stu *Stduent) Speak(think string) (talk string) {
	if think == "bitch" {
		talk = "You are a good boy"
	} else {
		talk = "hi"
	}
	return
}

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

考點：golang的方法集 解答： 編譯不通過！ 做錯了！？說明你對golang的方法集還有一些疑問。 一句話：golang的方法集僅僅影響介面實現和方法表示式轉化，與通過例項或者指標呼叫方法無關。

1. 以下程式碼打印出來什麼內容，說出為什麼。

package main

import (
	"fmt"
)

type People interface {
	Show()
}

type Student struct{}

func (stu *Student) Show() {

}

func live() People {
	var stu *Student
	return stu
}

func main() {
	if live() == nil {
		fmt.Println("AAAAAAA")
	} else {
		fmt.Println("BBBBBBB")
	}
}

考點：interface內部結構 解答： 很經典的題！ 這個考點是很多人忽略的interface內部結構。 go中的介面分為兩種一種是空的介面類似這樣：

var in interface{} 另一種如題目：

type People interface {
    Show()
}

他們的底層結構如下：

type eface struct {      //空介面
    _type *_type         //型別資訊
    data  unsafe.Pointer //指向資料的指標(go語言中特殊的指標型別unsafe.Pointer類似於c語言中的void*)
}
type iface struct {      //帶有方法的介面
    tab  *itab           //儲存type資訊還有結構實現方法的集合
    data unsafe.Pointer  //指向資料的指標(go語言中特殊的指標型別unsafe.Pointer類似於c語言中的void*)
}
type _type struct {
    size       uintptr  //型別大小
    ptrdata    uintptr  //字首持有所有指標的記憶體大小
    hash       uint32   //資料hash值
    tflag      tflag
    align      uint8    //對齊
    fieldalign uint8    //嵌入結構體時的對齊
    kind       uint8    //kind 有些列舉值kind等於0是無效的
    alg        *typeAlg //函式指標陣列，型別實現的所有方法
    gcdata    *byte
    str       nameOff
    ptrToThis typeOff
}
type itab struct {
    inter  *interfacetype  //介面型別
    _type  *_type          //結構型別
    link   *itab
    bad    int32
    inhash int32
    fun    [1]uintptr      //可變大小 方法集合
}

可以看出iface比eface 中間多了一層itab結構。 itab 儲存_type資訊和[]fun方法集，從上面的結構我們就可得出，因為data指向了nil 並不代表interface 是nil， 所以返回值並不為空，這裡的fun(方法集)定義了介面的接收規則，在編譯的過程中需要驗證是否實現介面 結果：

BBBBBBB 12.是否可以編譯通過？如果通過，輸出什麼？

func main() {
	i := GetValue()

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

}

func GetValue() int {
	return 1
}

解析 考點：type

編譯失敗，因為type只能使用在interface

13.下面函式有什麼問題？

func funcMui(x,y int)(sum int,error){
    return x+y,nil
}

解析 考點：函式返回值命名 在函式有多個返回值時，只要有一個返回值有指定命名，其他的也必須有命名。 如果返回值有有多個返回值必須加上括號； 如果只有一個返回值並且有命名也需要加上括號； 此處函式第一個返回值有sum名稱，第二個未命名，所以錯誤。

14.是否可以編譯通過？如果通過，輸出什麼？

package main

func main() {

	println(DeferFunc1(1))
	println(DeferFunc2(1))
	println(DeferFunc3(1))
}

func DeferFunc1(i int) (t int) {
	t = i
	defer func() {
		t += 3
	}()
	return t
}

func DeferFunc2(i int) int {
	t := i
	defer func() {
		t += 3
	}()
	return t
}

func DeferFunc3(i int) (t int) {
	defer func() {
		t += i
	}()
	return 2
}

解析 考點:defer和函式返回值 需要明確一點是defer需要在函式結束前執行。 函式返回值名字會在函式起始處被初始化為對應型別的零值並且作用域為整個函式 DeferFunc1有函式返回值t作用域為整個函式，在return之前defer會被執行，所以t會被修改，返回4; DeferFunc2函式中t的作用域為函式，返回1; DeferFunc3返回3

15.是否可以編譯通過？如果通過，輸出什麼？

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

解析 考點：new list:=make([]int,0)

16.是否可以編譯通過？如果通過，輸出什麼？

package main

import "fmt"

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

解析 考點：append append切片時候別漏了'...'

17.是否可以編譯通過？如果通過，輸出什麼？

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")
	}
}

解析 考點:結構體比較 進行結構體比較時候，只有相同型別的結構體才可以比較，結構體是否相同不但與屬性型別個數有關，還與屬性順序相關。

sn3:= struct {
    name string
    age  int
}{age:11,name:"qq"}

sn3與sn1就不是相同的結構體了，不能比較。 還有一點需要注意的是結構體是相同的，但是結構體屬性中有不可以比較的型別，如map,slice。 如果該結構屬性都是可以比較的，那麼就可以使用“==”進行比較操作。

可以使用reflect.DeepEqual進行比較

if reflect.DeepEqual(sn1, sm) {
    fmt.Println("sn1 ==sm")
}else {
    fmt.Println("sn1 !=sm")
}

所以編譯不通過： invalid operation: sm1 == sm2

18.是否可以編譯通過？如果通過，輸出什麼？

func Foo(x interface{}) {
	if x == nil {
		fmt.Println("empty interface")
		return
	}
	fmt.Println("non-empty interface")
}
func main() {
	var x *int = nil
	Foo(x)
}

解析 考點：interface內部結構

non-empty interface 19.是否可以編譯通過？如果通過，輸出什麼？

func GetValue(m map[int]string, id int) (string, bool) {
	if _, exist := m[id]; exist {
		return "存在資料", true
	}
	return nil, false
}
func main()  {
	intmap:=map[int]string{
		1:"a",
		2:"bb",
		3:"ccc",
	}

	v,err:=GetValue(intmap,3)
	fmt.Println(v,err)
}

解析 考點：函式返回值型別 nil 可以用作 interface、function、pointer、map、slice 和 channel 的“空值”。但是如果不特別指定的話，Go 語言不能識別型別，所以會報錯。報:cannot use nil as type string in return argument.

20.是否可以編譯通過？如果通過，輸出什麼？

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

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

解析 考點：iota 結果:

0 1 zz zz 4

21.編譯執行下面程式碼會出現什麼?

package main
var(
    size :=1024
    max_size = size*2
)
func main()  {
    println(size,max_size)
}

解析 考點:變數簡短模式 變數簡短模式限制：

定義變數同時顯式初始化 不能提供資料型別 只能在函式內部使用 結果：

syntax error: unexpected := 22.下面函式有什麼問題？

package main
const cl  = 100

var bl    = 123

func main()  {
    println(&bl,bl)
    println(&cl,cl)
}

解析 考點:常量 常量不同於變數的在執行期分配記憶體，常量通常會被編譯器在預處理階段直接展開，作為指令資料使用，

cannot take the address of cl 23.編譯執行下面程式碼會出現什麼?

package main

func main()  {

    for i:=0;i<10 ;i++  {
    loop:
        println(i)
    }
    goto loop
}

解析 考點：goto goto不能跳轉到其他函式或者內層程式碼

goto loop jumps into block starting at 24.編譯執行下面程式碼會出現什麼?

package main
import "fmt"

func main()  {
    type MyInt1 int
    type MyInt2 = int
    var i int =9
    var i1 MyInt1 = i
    var i2 MyInt2 = i
    fmt.Println(i1,i2)
}

解析 考點：**Go 1.9 新特性 Type Alias ** 基於一個型別建立一個新型別，稱之為defintion；基於一個型別建立一個別名，稱之為alias。 MyInt1為稱之為defintion，雖然底層型別為int型別，但是不能直接賦值，需要強轉； MyInt2稱之為alias，可以直接賦值。

結果:

cannot use i (type int) as type MyInt1 in assignment 25.編譯執行下面程式碼會出現什麼?

package main
import "fmt"

type User struct {
}
type MyUser1 User
type MyUser2 = User
func (i MyUser1) m1(){
    fmt.Println("MyUser1.m1")
}
func (i User) m2(){
    fmt.Println("User.m2")
}

func main() {
    var i1 MyUser1
    var i2 MyUser2
    i1.m1()
    i2.m2()
}

解析 考點：**Go 1.9 新特性 Type Alias ** 因為MyUser2完全等價於User，所以具有其所有的方法，並且其中一個新增了方法，另外一個也會有。 但是

i1.m2() 是不能執行的，因為MyUser1沒有定義該方法。 結果:

MyUser1.m1
User.m2

26.編譯執行下面程式碼會出現什麼?

package main

import "fmt"

type T1 struct {
}
func (t T1) m1(){
    fmt.Println("T1.m1")
}
type T2 = T1
type MyStruct struct {
    T1
    T2
}
func main() {
    my:=MyStruct{}
    my.m1()
}

解析 考點：**Go 1.9 新特性 Type Alias ** 是不能正常編譯的,異常：

ambiguous selector my.m1 結果不限於方法，欄位也也一樣；也不限於type alias，type defintion也是一樣的，只要有重複的方法、欄位，就會有這種提示，因為不知道該選擇哪個。 改為:

my.T1.m1()
my.T2.m1()

type alias的定義，本質上是一樣的型別，只是起了一個別名，源型別怎麼用，別名型別也怎麼用，保留源型別的所有方法、欄位等。

27.編譯執行下面程式碼會出現什麼?

package main

import (
    "errors"
    "fmt"
)

var ErrDidNotWork = errors.New("did not work")

func DoTheThing(reallyDoIt bool) (err error) {
    if reallyDoIt {
        result, err := tryTheThing()
        if err != nil || result != "it worked" {
            err = ErrDidNotWork
        }
    }
    return err
}

func tryTheThing() (string,error)  {
    return "",ErrDidNotWork
}

func main() {
    fmt.Println(DoTheThing(true))
    fmt.Println(DoTheThing(false))
}

解析 考點：變數作用域 因為 if 語句塊內的 err 變數會遮罩函式作用域內的 err 變數，結果：

改為：

func DoTheThing(reallyDoIt bool) (err error) {
    var result string
    if reallyDoIt {
        result, err = tryTheThing()
        if err != nil || result != "it worked" {
            err = ErrDidNotWork
        }
    }
    return err
}
28.編譯執行下面程式碼會出現什麼?
package main

func test() []func()  {
    var funs []func()
    for i:=0;i<2 ;i++  {
        funs = append(funs, func() {
            println(&i,i)
        })
    }
    return funs
}

func main(){
    funs:=test()
    for _,f:=range funs{
        f()
    }
}

解析 考點：閉包延遲求值 for迴圈複用區域性變數i，每一次放入匿名函式的應用都是想一個變數。 結果：

0xc042046000 2 0xc042046000 2 如果想不一樣可以改為：

func test() []func()  {
    var funs []func()
    for i:=0;i<2 ;i++  {
        x:=i
        funs = append(funs, func() {
            println(&x,x)
        })
    }
    return funs
}
29.編譯執行下面程式碼會出現什麼?
package main

func test(x int) (func(),func())  {
    return func() {
        println(x)
        x+=10
    }, func() {
        println(x)
    }
}

func main()  {
    a,b:=test(100)
    a()
    b()
}

解析 考點：閉包引用相同變數* 結果：

100 110 30.編譯執行下面程式碼會出現什麼?

package main

import (
    "fmt"
    "reflect"
)

func main1()  {
    defer func() {
       if err:=recover();err!=nil{
           fmt.Println(err)
       }else {
           fmt.Println("fatal")
       }
    }()

    defer func() {
        panic("defer panic")
    }()
    panic("panic")
}

func main()  {
    defer func() {
        if err:=recover();err!=nil{
            fmt.Println("++++")
            f:=err.(func()string)
            fmt.Println(err,f(),reflect.TypeOf(err).Kind().String())
        }else {
            fmt.Println("fatal")
        }
    }()

    defer func() {
        panic(func() string {
            return  "defer panic"
        })
    }()
    panic("panic")
}

解析 考點：panic僅有最後一個可以被revover捕獲 觸發panic("panic")後順序執行defer，但是defer中還有一個panic，所以覆蓋了之前的panic("panic")

defer panic