Go面試題精編100題
Golang精編100題
選擇題
1. 【初級】下面屬於關鍵字的是（）
A. func
B. def
C. struct
D. class
參考答案：AC
2. 【初級】定義一個包內全局字符串變量，下面語法正確的是（）
A. var str string
B. str := ""
C. str = ""
D. var str = ""
參考答案：AD
3. 【初級】通過指針變量 p 訪問其成員變量 name，下面語法正確的是（）
A. p.name
B. (*p).name
C. (&p).name
D. p->name
參考答案：AB
4. 【初級】關於接口和類的說法，下面說法正確的是（）
A. 一個類只需要實現了接口要求的所有函數，我們就說這個類實現了該接口
B. 實現類的時候，只需要關心自己應該提供哪些方法，不用再糾結接口需要拆得多細才合理
C. 類實現接口時，需要導入接口所在的包
D. 接口由使用方按自身需求來定義，使用方無需關心是否有其他模塊定義過類似的接口
參考答案：ABD
5. 【初級】關於字符串連接，下面語法正確的是（）
A. str := ‘abc’ + ‘123’
B. str := "abc" + "123"
C. str ：= ‘123‘ + "abc"
D. fmt.Sprintf("abc%d", 123)
參考答案：BD
6. 【初級】關於協程，下面說法正確是（）
A. 協程和線程都可以實現程序的並發執行
B. 線程比協程更輕量級
C. 協程不存在死鎖問題
D. 通過channel來進行協程間的通信
參考答案：AD
7. 【中級】關於init函數，下面說法正確的是（）
A. 一個包中，可以包含多個init函數
B. 程序編譯時，先執行導入包的init函數，再執行本包內的init函數
C. main包中，不能有init函數
D. init函數可以被其他函數調用
參考答案：AB
8. 【初級】關於循環語句，下面說法正確的有（）
A. 循環語句既支持for關鍵字，也支持while和do-while
B. 關鍵字for的基本使用方法與C/C++中沒有任何差異
C. for循環支持continue和break來控制循環，但是它提供了一個更高級的break，可以選擇中斷哪一個循環
D. for循環不支持以逗號為間隔的多個賦值語句，必須使用平行賦值的方式來初始化多個變量
參考答案：CD
9. 【中級】對於函數定義：
10. func add(args ...int) int {
11. sum :=0
12. for _,arg := range args {
13. sum += arg
14. }
15. returnsum
}
下面對add函數調用正確的是（）
A. add(1, 2)
B. add(1, 3, 7)
C. add([]int{1, 2})
D. add([]int{1, 3, 7}...)
參考答案：ABD
16. 【初級】關於類型轉化，下面語法正確的是（）
A.
17. type MyInt int
18. var i int = 1
var jMyInt = i
B.
type MyIntint
var i int= 1
var jMyInt = (MyInt)i
C.
type MyIntint
var i int= 1
var jMyInt = MyInt(i)
D.
type MyIntint
var i int= 1
var jMyInt = i.(MyInt)
參考答案：C
19. 【初級】關於局部變量的初始化，下面正確的使用方式是（）
A. var i int = 10
B. var i = 10
C. i := 10
D. i = 10
參考答案：ABC
20. 【初級】關於const常量定義，下面正確的使用方式是（）
A.
21. const Pi float64 = 3.14159265358979323846
const zero= 0.0
B.
const (
size int64= 1024
eof = -1
)
C.
const (
ERR_ELEM_EXISTerror = errors.New("element already exists")
ERR_ELEM_NT_EXISTerror = errors.New("element not exists")
)
D.
const u, vfloat32 = 0, 3
const a,b, c = 3, 4, "foo"
參考答案：ABD
22. 【初級】關於布爾變量b的賦值，下面錯誤的用法是（）
A. b = true
B. b = 1
C. b = bool(1)
D. b = (1 == 2)
參考答案：BC
23. 【中級】下面的程序的運行結果是（）
24. func main() {
25. if (true) {
26. defer fmt.Printf("1")
27. } else {
28. defer fmt.Printf("2")
29. }
30. fmt.Printf("3")
}
A. 321
B. 32
C. 31
D. 13
參考答案：C
31. 【初級】關於switch語句，下面說法正確的有（）
A. 條件表達式必須為常量或者整數
B. 單個case中，可以出現多個結果選項
C. 需要用break來明確退出一個case
D. 只有在case中明確添加fallthrough關鍵字，才會繼續執行緊跟的下一個case
參考答案：BD
32. 【中級】 golang中沒有隱藏的this指針，這句話的含義是（）
A. 方法施加的對象顯式傳遞，沒有被隱藏起來
B. golang沿襲了傳統面向對象編程中的諸多概念，比如繼承、虛函數和構造函數
C. golang的面向對象表達更直觀，對於面向過程只是換了一種語法形式來表達
D. 方法施加的對象不需要非得是指針，也不用非得叫this
參考答案：ACD
33. 【中級】 golang中的引用類型包括（）
A. 數組切片
B. map
C. channel
D. interface
參考答案：ABCD
34. 【中級】 golang中的指針運算包括（）
A. 可以對指針進行自增或自減運算
B. 可以通過“&”取指針的地址
C. 可以通過“*”取指針指向的數據
D. 可以對指針進行下標運算
參考答案：BC
35. 【初級】關於main函數（可執行程序的執行起點），下面說法正確的是（）
A. main函數不能帶參數
B. main函數不能定義返回值
C. main函數所在的包必須為main包
D. main函數中可以使用flag包來獲取和解析命令行參數
參考答案：ABCD
36. 【中級】下面賦值正確的是（）
A. var x = nil
B. var x interface{} = nil
C. var x string = nil
D. var x error = nil
參考答案：BD
37. 【中級】關於整型切片的初始化，下面正確的是（）
A. s := make([]int)
B. s := make([]int, 0)
C. s := make([]int, 5, 10)
D. s := []int{1, 2, 3, 4, 5}
參考答案：BCD
38. 【中級】從切片中刪除一個元素，下面的算法實現正確的是（）
A.
39. func (s *Slice)Remove(value interface{})error {
40. for i, v := range *s {
41. if isEqual(value, v) {
42. if i== len(*s) - 1 {
43. *s = (*s)[:i]
44. }else {
45. *s = append((*s)[:i],(*s)[i + 2:]...)
46. }
47. return nil
48. }
49. }
50. return ERR_ELEM_NT_EXIST
}
B.
func (s*Slice)Remove(value interface{}) error {
for i, v:= range *s {
if isEqual(value, v) {
*s =append((*s)[:i],(*s)[i + 1:])
return nil
}
}
returnERR_ELEM_NT_EXIST
}
C.
func (s*Slice)Remove(value interface{}) error {
for i, v:= range *s {
if isEqual(value, v) {
delete(*s, v)
return nil
}
}
returnERR_ELEM_NT_EXIST
}
D.
func (s*Slice)Remove(value interface{}) error {
for i, v:= range *s {
if isEqual(value, v) {
*s =append((*s)[:i],(*s)[i + 1:]...)
return nil
}
}
returnERR_ELEM_NT_EXIST
}
參考答案：D
51. 【初級】對於局部變量整型切片x的賦值，下面定義正確的是（）
A.
52. x := []int{
53. 1, 2, 3,
54. 4, 5, 6,
}
B.
x :=[]int{
1, 2, 3,
4, 5, 6
}
C.
x :=[]int{
1, 2, 3,
4, 5, 6}
D.
x :=[]int{1, 2, 3, 4, 5, 6,}
參考答案：ACD
55. 【初級】關於變量的自增和自減操作，下面語句正確的是（）
A.
56. i := 1
i++
B.
i := 1
j = i++
C.
i := 1
++i
D.
i := 1
i--
參考答案：AD
57. 【中級】關於函數聲明，下面語法錯誤的是（）
A. func f(a, b int) (value int, err error)
B. func f(a int, b int) (value int, err error)
C. func f(a, b int) (value int, error)
D. func f(a int, b int) (int, int, error)
參考答案：C
58. 【中級】如果Add函數的調用代碼為：
59. func main() {
60. var a Integer = 1
61. var b Integer = 2
62. var i interface{} = &a
63. sum := i.(*Integer).Add(b)
64. fmt.Println(sum)
}
則Add函數定義正確的是（）
A.
typeInteger int
func (aInteger) Add(b Integer) Integer {
return a + b
}
B.
typeInteger int
func (aInteger) Add(b *Integer) Integer {
return a + *b
}
C.
typeInteger int
func (a*Integer) Add(b Integer) Integer {
return *a + b
}
D.
typeInteger int
func (a*Integer) Add(b *Integer) Integer {
return *a + *b
}
參考答案：AC
65. 【中級】如果Add函數的調用代碼為：
66. func main() {
67. var a Integer = 1
68. var b Integer = 2
69. var i interface{} = a
70. sum := i.(Integer).Add(b)
71. fmt.Println(sum)
}
則Add函數定義正確的是（）
A.
typeInteger int
func (a Integer)Add(b Integer) Integer {
return a + b
}
B.
typeInteger int
func (aInteger) Add(b *Integer) Integer {
return a + *b
}
C.
typeInteger int
func (a*Integer) Add(b Integer) Integer {
return *a + b
}
D.
typeInteger int
func (a*Integer) Add(b *Integer) Integer {
return *a + *b
}
參考答案：A
72. 【中級】關於GetPodAction定義，下面賦值正確的是（）
73. type Fragment interface {
74. Exec(transInfo *TransInfo) error
75. }
76. type GetPodAction struct {
77. }
78. func (g GetPodAction) Exec(transInfo*TransInfo) error {
79. ...
80. return nil
}
A. var fragment Fragment =new(GetPodAction)
B. var fragment Fragment = GetPodAction
C. var fragment Fragment = &GetPodAction{}
D. var fragment Fragment = GetPodAction{}
參考答案：ACD
81. 【中級】關於GoMock，下面說法正確的是（）
A. GoMock可以對interface打樁
B. GoMock可以對類的成員函數打樁
C. GoMock可以對函數打樁
D. GoMock打樁後的依賴註入可以通過GoStub完成
參考答案：AD
82. 【中級】關於接口，下面說法正確的是（）
A. 只要兩個接口擁有相同的方法列表（次序不同不要緊），那麽它們就是等價的，可以相互賦值
B. 如果接口A的方法列表是接口B的方法列表的子集，那麽接口B可以賦值給接口A
C. 接口查詢是否成功，要在運行期才能夠確定
D. 接口賦值是否可行，要在運行期才能夠確定
參考答案：ABC
83. 【初級】關於channel，下面語法正確的是（）
A. var ch chan int
B. ch := make(chan int)
C. <- ch
D. ch <-
參考答案：ABC
84. 【初級】關於同步鎖，下面說法正確的是（）
A. 當一個goroutine獲得了Mutex後，其他goroutine就只能乖乖的等待，除非該goroutine釋放這個Mutex
B. RWMutex在讀鎖占用的情況下，會阻止寫，但不阻止讀
C. RWMutex在寫鎖占用情況下，會阻止任何其他goroutine（無論讀和寫）進來，整個鎖相當於由該goroutine獨占
D. Lock()操作需要保證有Unlock()或RUnlock()調用與之對應
參考答案：ABC
85. 【中級】 golang中大多數數據類型都可以轉化為有效的JSON文本，下面幾種類型除外（）
A. 指針
B. channel
C. complex
D. 函數
參考答案：BCD
86. 【中級】關於go vendor，下面說法正確的是（）
A. 基本思路是將引用的外部包的源代碼放在當前工程的vendor目錄下面
B. 編譯go代碼會優先從vendor目錄先尋找依賴包
C. 可以指定引用某個特定版本的外部包
D. 有了vendor目錄後，打包當前的工程代碼到其他機器的$GOPATH/src下都可以通過編譯
參考答案：ABD
87. 【初級】 flag是bool型變量，下面if表達式符合編碼規範的是（）
A. if flag == 1
B. if flag
C. if flag == false
D. if !flag
參考答案：BD
88. 【初級】 value是整型變量，下面if表達式符合編碼規範的是（）
A. if value == 0
B. if value
C. if value != 0
D. if !value
參考答案：AC
89. 【中級】關於函數返回值的錯誤設計，下面說法正確的是（）
A. 如果失敗原因只有一個，則返回bool
B. 如果失敗原因超過一個，則返回error
C. 如果沒有失敗原因，則不返回bool或error
D. 如果重試幾次可以避免失敗，則不要立即返回bool或error
參考答案：ABCD
90. 【中級】關於異常設計，下面說法正確的是（）
A. 在程序開發階段，堅持速錯，讓程序異常崩潰
B. 在程序部署後，應恢復異常避免程序終止
C. 一切皆錯誤，不用進行異常設計
D. 對於不應該出現的分支，使用異常處理
參考答案：ABD
91. 【中級】關於slice或map操作，下面正確的是（）
A.
92. var s []int
s =append(s,1)
B.
var mmap[string]int
m["one"]= 1
C.
var s[]int
s =make([]int, 0)
s =append(s,1)
D.
var mmap[string]int
m =make(map[string]int)
m["one"]= 1
參考答案：ACD
93. 【中級】關於channel的特性，下面說法正確的是（）
A. 給一個 nil channel 發送數據，造成永遠阻塞
B. 從一個 nil channel 接收數據，造成永遠阻塞
C. 給一個已經關閉的 channel 發送數據，引起 panic
D. 從一個已經關閉的 channel 接收數據，如果緩沖區中為空，則返回一個零值
參考答案：ABCD
94. 【中級】關於無緩沖和有沖突的channel，下面說法正確的是（）
A. 無緩沖的channel是默認的緩沖為1的channel
B. 無緩沖的channel和有緩沖的channel都是同步的
C. 無緩沖的channel和有緩沖的channel都是非同步的
D. 無緩沖的channel是同步的，而有緩沖的channel是非同步的
參考答案：D
95. 【中級】關於異常的觸發，下面說法正確的是（）
A. 空指針解析
B. 下標越界
C. 除數為0
D. 調用panic函數
參考答案：ABCD
96. 【中級】關於cap函數的適用類型，下面說法正確的是（）
A. array
B. slice
C. map
D. channel
參考答案：ABD
97. 【中級】關於beego框架，下面說法正確的是（）
A. beego是一個golang實現的輕量級HTTP框架
B. beego可以通過註釋路由、正則路由等多種方式完成url路由註入
C. 可以使用bee new工具生成空工程，然後使用bee run命令自動熱編譯
D. beego框架只提供了對url路由的處理，而對於MVC架構中的數據庫部分未提供框架支持
參考答案：ABC
98. 【中級】關於goconvey，下面說法正確的是（）
A. goconvey是一個支持golang的單元測試框架
B. goconvey能夠自動監控文件修改並啟動測試，並可以將測試結果實時輸出到web界面
C. goconvey提供了豐富的斷言簡化測試用例的編寫
D. goconvey無法與go test集成
參考答案：ABC
99. 【中級】關於go vet，下面說法正確的是（）
A. go vet是golang自帶工具go tool vet的封裝
B. 當執行go vet database時，可以對database所在目錄下的所有子文件夾進行遞歸檢測
C. go vet可以使用絕對路徑、相對路徑或相對GOPATH的路徑指定待檢測的包
D. go vet可以檢測出死代碼
參考答案：ACD
100. 【中級】關於map，下面說法正確的是（）
A. map反序列化時json.unmarshal的入參必須為map的地址
B. 在函數調用中傳遞map，則子函數中對map元素的增加不會導致父函數中map的修改
C. 在函數調用中傳遞map，則子函數中對map元素的修改不會導致父函數中map的修改
D. 不能使用內置函數delete刪除map的元素
參考答案：A
101. 【中級】關於GoStub，下面說法正確的是（）
A. GoStub可以對全局變量打樁
B. GoStub可以對函數打樁
C. GoStub可以對類的成員方法打樁
D. GoStub可以打動態樁，比如對一個函數打樁後，多次調用該函數會有不同的行為
參考答案：ABD
102. 【初級】關於select機制，下面說法正確的是（）
A. select機制用來處理異步IO問題
B. select機制最大的一條限制就是每個case語句裏必須是一個IO操作
C. golang在語言級別支持select關鍵字
D. select關鍵字的用法與switch語句非常類似，後面要帶判斷條件
參考答案：ABC
103. 【初級】關於內存泄露，下面說法正確的是（）
A. golang有自動垃圾回收，不存在內存泄露
B. golang中檢測內存泄露主要依靠的是pprof包
C. 內存泄露可以在編譯階段發現
D. 應定期使用瀏覽器來查看系統的實時內存信息，及時發現內存泄露問題
參考答案：BD
填空題
1. 【初級】聲明一個整型變量i__________
參考答案：var i int
2. 【初級】聲明一個含有10個元素的整型數組a__________
參考答案：var a [10]int
3. 【初級】聲明一個整型數組切片s__________
參考答案：var s []int
4. 【初級】聲明一個整型指針變量p__________
參考答案：var p *int
5. 【初級】聲明一個key為字符串型value為整型的map變量m__________
參考答案：var m map[string]int
6. 【初級】聲明一個入參和返回值均為整型的函數變量f__________
參考答案：var f func(a int) int
7. 【初級】聲明一個只用於讀取int數據的單向channel變量ch__________
參考答案：var ch <-chan int
8. 【初級】假設源文件的命名為slice.go，則測試文件的命名為__________
參考答案：slice_test.go
9. 【初級】 go test要求測試函數的前綴必須命名為__________
參考答案：Test
10. 【中級】下面的程序的運行結果是__________
11. for i := 0; i < 5; i++ {
12. defer fmt.Printf("%d ", i)
}
參考答案：4 3 2 1 0
13. 【中級】下面的程序的運行結果是__________
14. func main() {
15. x := 1
16. {
17. x := 2
18. fmt.Print(x)
19. }
20. fmt.Println(x)
}
參考答案：21
21. 【中級】下面的程序的運行結果是__________
22. func main() {
23. strs := []string{"one","two", "three"}
24.
25. for _, s := range strs {
26. go func() {
27. time.Sleep(1 * time.Second)
28. fmt.Printf("%s ", s)
29. }()
30. }
31. time.Sleep(3 * time.Second)
}
參考答案：three threethree
32. 【中級】下面的程序的運行結果是__________
33. func main() {
34. x := []string{"a", "b","c"}
35. for v := range x {
36. fmt.Print(v)
37. }
}
參考答案：012
38. 【中級】下面的程序的運行結果是__________
39. func main() {
40. x := []string{"a", "b","c"}
41. for _, v := range x {
42. fmt.Print(v)
43. }
}
參考答案：abc
44. 【初級】下面的程序的運行結果是__________
45. func main() {
46. i := 1
47. j := 2
48. i, j = j, i
49. fmt.Printf("%d%d\n", i, j)
}
參考答案：21
50. 【初級】下面的程序的運行結果是__________
51. func incr(p *int) int {
52. *p++
53. return *p
54. }
55. func main() {
56. v := 1
57. incr(&v)
58. fmt.Println(v)
}
參考答案：2
59. 【初級】啟動一個goroutine的關鍵字是__________
參考答案：go
60. 【中級】下面的程序的運行結果是__________
61. type Slice []int
62. func NewSlice() Slice {
63. return make(Slice, 0)
64. }
65. func (s* Slice) Add(elem int) *Slice {
66. *s = append(*s, elem)
67. fmt.Print(elem)
68. return s
69. }
70. func main() {
71. s := NewSlice()
72. defer s.Add(1).Add(2)
73. s.Add(3)
}
參考答案：132
判斷題
1. 【初級】數組是一個值類型（）
參考答案：T
2. 【初級】使用map不需要引入任何庫（）
參考答案：T
3. 【中級】內置函數delete可以刪除數組切片內的元素（）
參考答案：F
4. 【初級】指針是基礎類型（）
參考答案：F
5. 【初級】 interface{}是可以指向任意對象的Any類型（）
參考答案：T
6. 【中級】下面關於文件操作的代碼可能觸發異常（）
7. file, err := os.Open("test.go")
8. defer file.Close()
9. if err != nil {
10. fmt.Println("open file failed:",err)
11. return
12. }
...
參考答案：T
13. 【初級】 Golang不支持自動垃圾回收（）
參考答案：F
14. 【初級】 Golang支持反射，反射最常見的使用場景是做對象的序列化（）
參考答案：T
15. 【初級】 Golang可以復用C/C++的模塊，這個功能叫Cgo（）
參考答案：F
16. 【初級】下面代碼中兩個斜點之間的代碼，比如json:"x"，作用是X字段在從結構體實例編碼到JSON數據格式的時候，使用x作為名字，這可以看作是一種重命名的方式（）
17. type Position struct {
18. X int `json:"x"`
19. Y int `json:"y"`
20. Z int `json:"z"`
}
參考答案：T
21. 【初級】通過成員變量或函數首字母的大小寫來決定其作用域（）
參考答案：T
22. 【初級】對於常量定義zero(const zero = 0.0)，zero是浮點型常量（）
參考答案：F
23. 【初級】對變量x的取反操作是~x（）
參考答案：F
24. 【初級】下面的程序的運行結果是xello（）
25. func main() {
26. str := "hello"
27. str[0] = ‘x‘
28. fmt.Println(str)
}
參考答案：F
29. 【初級】 golang支持goto語句（）
參考答案：T
30. 【初級】下面代碼中的指針p為野指針，因為返回的棧內存在函數結束時會被釋放（）
31. type TimesMatcher struct {
32. base int
33. }
34. func NewTimesMatcher(base int) *TimesMatcher{
35. return &TimesMatcher{base:base}
36. }
37. func main() {
38. p := NewTimesMatcher(3)
39. ...
}
參考答案：F
40. 【初級】匿名函數可以直接賦值給一個變量或者直接執行（）
參考答案：T
41. 【初級】如果調用方調用了一個具有多返回值的方法，但是卻不想關心其中的某個返回值，可以簡單地用一個下劃線“_”來跳過這個返回值，該下劃線對應的變量叫匿名變量（）
參考答案：T
42. 【初級】在函數的多返回值中，如果有error或bool類型，則一般放在最後一個（）
參考答案：T
43. 【初級】錯誤是業務過程的一部分，而異常不是（）
參考答案：T
44. 【初級】函數執行時，如果由於panic導致了異常，則延遲函數不會執行（）
參考答案：F
45. 【中級】當程序運行時，如果遇到引用空指針、下標越界或顯式調用panic函數等情況，則先觸發panic函數的執行，然後調用延遲函數。調用者繼續傳遞panic，因此該過程一直在調用棧中重復發生：函數停止執行，調用延遲執行函數。如果一路在延遲函數中沒有recover函數的調用，則會到達該攜程的起點，該攜程結束，然後終止其他所有攜程，其他攜程的終止過程也是重復發生：函數停止執行，調用延遲執行函數（）
參考答案：F
46. 【初級】同級文件的包名不允許有多個（）
參考答案：T
47. 【中級】可以給任意類型添加相應的方法（）
參考答案：F
48. 【初級】 golang雖然沒有顯式的提供繼承語法，但是通過匿名組合實現了繼承（）
參考答案：T
49. 【初級】使用for range叠代map時每次叠代的順序可能不一樣，因為map的叠代是隨機的（）
參考答案：T
50. 【初級】 switch後面可以不跟表達式（）
參考答案：T
51. 【中級】結構體在序列化時非導出變量（以小寫字母開頭的變量名）不會被encode，因此在decode時這些非導出變量的值為其類型的零值（）
參考答案：T
52. 【初級】 golang中沒有構造函數的概念，對象的創建通常交由一個全局的創建函數來完成，以NewXXX來命名（）
參考答案：T
53. 【中級】當函數deferDemo返回失敗時，並不能destroy已create成功的資源（）
54. func deferDemo() error {
55. err := createResource1()
56. if err != nil {
57. return ERR_CREATE_RESOURCE1_FAILED
58. }
59. defer func() {
60. if err != nil {
61. destroyResource1()
62. }
63. }()
64.
65. err = createResource2()
66. if err != nil {
67. return ERR_CREATE_RESOURCE2_FAILED
68. }
69. defer func() {
70. if err != nil {
71. destroyResource2()
72. }
73. }()
74.
75. err = createResource3()
76. if err != nil {
77. return ERR_CREATE_RESOURCE3_FAILED
78. }
79. return nil
}
參考答案：F
80. 【中級】 channel本身必然是同時支持讀寫的，所以不存在單向channel（）
參考答案：F
81. 【初級】 import後面的最後一個元素是包名（）
參考答案：F
最近在很多地方看到了golang的面試題，看到了很多人對Golang的面試題心存恐懼，也是為了復習基礎，我把解題的過程總結下來。
面試題
1 寫出下面代碼輸出內容。
package main
import (
"fmt"
)
funcmain() {
defer_call()
}
funcdefer_call() {
deferfunc() {fmt.Println("打印前")}()
deferfunc() {fmt.Println("打印中")}()
deferfunc() {fmt.Println("打印後")}()
panic("觸發異常")
}
考點：defer執行順序
解答：
defer 是後進先出。
panic 需要等defer 結束後才會向上傳遞。 出現panic恐慌時候，會先按照defer的後入先出的順序執行，最後才會執行panic。
打印後
打印中
打印前
panic: 觸發異常
2 以下代碼有什麽問題，說明原因。
type student struct {
Name string
Age int
}
funcpase_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 := rangestus {
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
}
fork,v:=range m{
println(k,"=>",v.Name)
}
// 正確
for i:=0;i<len(stus);i++ {
m[stus[i].Name] = &stus[i]
}
fork,v:=range m{
println(k,"=>",v.Name)
}
}
3 下面的代碼會輸出什麽，並說明原因
func main() {
runtime.GOMAXPROCS(1)
wg := sync.WaitGroup{}
wg.Add(20) for i := 0; i < 10; i++ {
gofunc() {
fmt.Println("A: ", i)
wg.Done()
}()
}
for i:= 0; i < 10; i++ {
gofunc(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內部指向值拷貝地址。
4 下面代碼會輸出什麽？
type People struct{}func (p *People)ShowA() {
fmt.Println("showA")
p.ShowB()
}
func(p*People)ShowB() {
fmt.Println("showB")
}
typeTeacher struct {
People
}
func(t*Teacher)ShowB() {
fmt.Println("teachershowB")
}
funcmain() {
t := Teacher{}
t.ShowA()
}
考點：go的組合繼承
解答：
這是Golang的組合模式，可以實現OOP的繼承。 被組合的類型People所包含的方法雖然升級成了外部類型Teacher這個組合類型的方法（一定要是匿名字段），但它們的方法(ShowA())調用時接受者並沒有發生變化。 此時People類型並不知道自己會被什麽類型組合，當然也就無法調用方法時去使用未知的組合者Teacher類型的功能。
showAshowB
5 下面代碼會觸發異常嗎？請詳細說明
func main() {
runtime.GOMAXPROCS(1)
int_chan := make(chanint, 1)
string_chan := make(chanstring, 1)
int_chan <- 1
string_chan <- "hello"
select {
case value := <-int_chan:
fmt.Println(value)
casevalue := <-string_chan:
panic(value)
}
}
考點：select隨機性
解答：
select會隨機選擇一個可用通用做收發操作。 所以代碼是有肯觸發異常，也有可能不會。 單個chan如果無緩沖時，將會阻塞。但結合 select可以在多個chan間等待執行。有三點原則：
select 中只要有一個case能return，則立刻執行。
當如果同一時間有多個case均能return則偽隨機方式抽取任意一個執行。
如果沒有一個case能return則可以執行”default”塊。
6 下面代碼輸出什麽？
funccalc(indexstring, a, bint) int {
ret := a+ b
fmt.Println(index,a, b, ret)
return ret
}
funcmain() {
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 320 0 2 22 0 2 21 1 3 4
7 請寫出以下輸入內容
funcmain() {
s := make([]int,5)
s = append(s,1, 2, 3)
fmt.Println(s)
}
考點：make默認值和append
解答：
make初始化是由默認值的哦，此處默認值為0
[00000123]
大家試試改為:
s := make([]int, 0)
s = append(s, 1, 2, 3)
fmt.Println(s)//[1 2 3]
8 下面的代碼有什麽問題?
type UserAges struct {
ages map[string]int
sync.Mutex
}
func(ua*UserAges)Add(name string, age int) {
ua.Lock()
deferua.Unlock()
ua.ages[name] = age
}
func(ua*UserAges)Get(name string)int {
ifage, ok := ua.ages[name]; ok {
return age
}
return-1
}
考點：map線程安全
解答：
可能會出現
fatal error: concurrent mapreadandmapwrite.
修改一下看看效果
func (ua *UserAges)Get(namestring)int {
ua.Lock()
deferua.Unlock()
ifage, ok := ua.ages[name]; ok {
return age
}
return-1
}
9. 下面的叠代會有什麽問題？
func (set *threadSafeSet)Iter()<-chaninterface{} {
ch := make(chaninterface{})
gofunc() {
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() <-chaninterface{} {
//ch := make(chan interface{}) // 解除註釋看看！
ch := make(chaninterface{},len(set.s))
gofunc() {
set.RLock()
forelem,value := range set.s {
ch <- elem
println("Iter:",elem,value)
} close(ch)
set.RUnlock()
}()
return ch
}
funcmain() {
th:=threadSafeSet{
s:[]interface{}{"1","2"},
}
v:=<-th.Iter()
fmt.Sprintf("%s%v","ch",v)
}
10 以下代碼能編譯過去嗎？為什麽？
package main
import ( "fmt")
typePeople interface {
Speak(string) string
}
typeStduent struct{}
func(stu*Stduent)Speak(think string)(talk string) {
ifthink == "bitch" {
talk = "Youare a good boy"
} else {
talk = "hi"
}
return
}
funcmain() {
var peoPeople = Stduent{}
think := "bitch"
fmt.Println(peo.Speak(think))
}
考點：golang的方法集
解答：
編譯不通過！ 做錯了！？說明你對golang的方法集還有一些疑問。 一句話：golang的方法集僅僅影響接口實現和方法表達式轉化，與通過實例或者指針調用方法無關。
11 以下代碼打印出來什麽內容，說出為什麽。
package main
import ( "fmt")
typePeople interface {
Show()
}
typeStudent struct{}
func(stu*Student)Show() {
}
funclive()People {
var stu*Student
return stu
}
funcmain() { if live() == nil
{
fmt.Println("AAAAAAA")
} else {
fmt.Println("BBBBBBB")
}
}
考點：interface內部結構
解答：
很經典的題！ 這個考點是很多人忽略的interface內部結構。 go中的接口分為兩種一種是空的接口類似這樣：
varininterface{}
另一種如題目：
type People interface {
Show()
}
他們的底層結構如下：
type eface struct { //空接口
_type *_type //類型信息
data unsafe.Pointer //指向數據的指針(go語言中特殊的指針類型unsafe.Pointer類似於c語言中的void*)}
typeiface 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) {
caseint:
println("int")
casestring:
println("string")
caseinterface{}:
println("interface")
default:
println("unknown")
}
}
funcGetValue()int {
return1
}
解析
考點：type
編譯失敗，因為type只能使用在interface
13.下面函數有什麽問題？
func funcMui(x,y int)(sum int,error){
returnx+y,nil
}
解析
考點：函數返回值命名
在函數有多個返回值時，只要有一個返回值有指定命名，其他的也必須有命名。 如果返回值有有多個返回值必須加上括號； 如果只有一個返回值並且有命名也需要加上括號； 此處函數第一個返回值有sum名稱，第二個未命名，所以錯誤。
14.是否可以編譯通過？如果通過，輸出什麽？
package mainfunc main() { println(DeferFunc1(1)) println(DeferFunc2(1)) println(DeferFunc3(1))
}func DeferFunc1(i int)(t int) {
t = i deferfunc() {
t += 3
}() return t
}
funcDeferFunc2(i int)int {
t := i deferfunc() {
t += 3
}() return t
}
funcDeferFunc3(i int)(t int) { deferfunc() {
t += i
}() return2}
解析
考點:defer和函數返回值
需要明確一點是defer需要在函數結束前執行。 函數返回值名字會在函數起始處被初始化為對應類型的零值並且作用域為整個函數 DeferFunc1有函數返回值t作用域為整個函數，在return之前defer會被執行，所以t會被修改，返回4; DeferFunc2函數中t的作用域為函數，返回1;DeferFunc3返回3
15.是否可以編譯通過？如果通過，輸出什麽？
funcmain() { list := new([]int)
list = append(list,1)
fmt.Println(list)
}
解析
考點：new
list:=make([]int,0)
16.是否可以編譯通過？如果通過，輸出什麽？
package mainimport "fmt"funcmain() {
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("emptyinterface")
return
}
fmt.Println("non-emptyinterface")
}
funcmain() {
var x *int = nil
Foo(x)
}
解析
考點：interface內部結構
non-emptyinterface
19.是否可以編譯通過？如果通過，輸出什麽？
func GetValue(m map[int]string, id int)(string, bool) {
if _,exist := m[id]; exist {
return"存在數據", true
}
returnnil, false}funcmain() {
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)
funcmain()
{
fmt.Println(x,y,z,k,p)
}
解析
考點：iota
結果:
0 1 zz zz 4
21.編譯執行下面代碼會出現什麽?
package mainvar(
size :=1024
max_size = size*2)
funcmain() {
println(size,max_size)
}
解析
考點:變量簡短模式
變量簡短模式限制：
定義變量同時顯式初始化
不能提供數據類型
只能在函數內部使用
結果：
syntaxerror: unexpected :=
22.下面函數有什麽問題？
package main
const cl = 100
var bl = 123
funcmain() {
println(&bl,bl)
println(&cl,cl)
}
解析
考點:常量
常量不同於變量的在運行期分配內存，常量通常會被編譯器在預處理階段直接展開，作為指令數據使用，
cannot take the address of cl
23.編譯執行下面代碼會出現什麽?
package main
funcmain() {
for i:=0;i<10;i++ {
loop:
println(i)
} gotoloop
}
解析
考點：goto
goto不能跳轉到其他函數或者內層代碼
goto loop jumps intoblock starting at
24.編譯執行下面代碼會出現什麽?
package main
import"fmt"
funcmain() {
typeMyInt1 int
typeMyInt2 = int
var i int =9
var i1MyInt1 = i
var i2MyInt2 = i
fmt.Println(i1,i2)
}
解析
考點：**Go 1.9 新特性 Type Alias **
基於一個類型創建一個新類型，稱之為defintion；基於一個類型創建一個別名，稱之為alias。 MyInt1為稱之為defintion，雖然底層類型為int類型，但是不能直接賦值，需要強轉； MyInt2稱之為alias，可以直接賦值。
結果:
cannot use i (typeint) astype MyInt1 in assignment
25.編譯執行下面代碼會出現什麽?
package main
import"fmt"
typeUser struct {
}
typeMyUser1 User
typeMyUser2 = User
func(iMyUser1)m1(){
fmt.Println("MyUser1.m1")
}
func(iUser)m2(){
fmt.Println("User.m2")
}
funcmain() {
var i1MyUser1
var i2MyUser2
i1.m1()
i2.m2()
}
解析
考點：**Go 1.9 新特性 Type Alias **
因為MyUser2完全等價於User，所以具有其所有的方法，並且其中一個新增了方法，另外一個也會有。 但是
i1.m2()
是不能執行的，因為MyUser1沒有定義該方法。 結果:
MyUser1.m1User.m2
26.編譯執行下面代碼會出現什麽?
package main
import"fmt"
type T1 struct {
}
func(tT1)m1(){
fmt.Println("T1.m1")
}
type T2= T1
typeMyStruct struct {
T1
T2
}
funcmain() {
my:=MyStruct{}
my.m1()
}
解析
考點：**Go 1.9 新特性 Type Alias **
是不能正常編譯的,異常：
ambiguousselectormy.m1
結果不限於方法，字段也也一樣；也不限於type alias，type defintion也是一樣的，只要有重復的方法、字段，就會有這種提示，因為不知道該選擇哪個。 改為:
my.T1.m1()
my.T2.m1()
type alias的定義，本質上是一樣的類型，只是起了一個別名，源類型怎麽用，別名類型也怎麽用，保留源類型的所有方法、字段等。
27.編譯執行下面代碼會出現什麽?
package main
import (
"errors"
"fmt")
varErrDidNotWork = errors.New("did not work")
funcDoTheThing(reallyDoItbool)(errerror) {
ifreallyDoIt {
result, err:= tryTheThing()
if err!= nil || result != "it worked" {
err = ErrDidNotWork
}
} return err
}
functryTheThing()(string,error) {
return"",ErrDidNotWork
}
funcmain() {
fmt.Println(DoTheThing(true))
fmt.Println(DoTheThing(false))
}
解析
考點：變量作用域
因為 if 語句塊內的 err 變量會遮罩函數作用域內的 err 變量，結果：
改為：
func DoTheThing(reallyDoIt bool)(errerror) {
varresult string
ifreallyDoIt {
result, err =tryTheThing()
if err!= nil || result != "it worked" {
err = ErrDidNotWork
}
} return err
}
28.編譯執行下面代碼會出現什麽?
package main
functest() []func() {
varfuns []func()
fori:=0;i<2;i++ {
funs = append(funs,func() {
println(&i,i)
})
} returnfuns
}
funcmain(){
funs:=test()
for_,f:=range funs{
f()
}
}
解析
考點：閉包延遲求值
for循環復用局部變量i，每一次放入匿名函數的應用都是想一個變量。 結果：
0xc042046000 2
0xc042046000 2
如果想不一樣可以改為：
func test() []func() {
varfuns []func()
fori:=0;i<2;i++ {
x:=i
funs = append(funs,func() {
println(&x,x)
})
} returnfuns
}
29.編譯執行下面代碼會出現什麽?
package main
functest(x int)(func(),func()) {
returnfunc() {
println(x)
x+=10
}, func() {
println(x)
}
}
funcmain() {
a,b:=test(100)
a()
b()
}
解析
考點：閉包引用相同變量*
結果：
100
110
30. 編譯執行下面代碼會出現什麽?
package main
import ( "fmt"
"reflect")
funcmain1() {
deferfunc() {
iferr:=recover();err!=nil{
fmt.Println(err)
}else {
fmt.Println("fatal")
}
}()
deferfunc() {
panic("deferpanic")
}()
panic("panic")
}
funcmain() {
deferfunc() {
iferr:=recover();err!=nil{
fmt.Println("++++")
f:=err.(func()string)
fmt.Println(err,f(),reflect.TypeOf(err).Kind().String())
}else {
fmt.Println("fatal")
}
}()
deferfunc() {
panic(func()string {
return "defer panic"
})
}()
panic("panic")
}
解析
考點：panic僅有最後一個可以被revover捕獲
觸發panic("panic")後順序執行defer，但是defer中還有一個panic，所以覆蓋了之前的panic("panic")
Go面試題精編100題