原文 https://goquiz.github.io/

slice

以下代码执行结果

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. func main() {
  8.     s := []int{1, 2, 3}
  9.     ss := s[1:]
  10.     ss = append(ss, 4)
  12.     for _, v := range ss {
  13.         v += 10
  14.     }
  16.     for i := range ss {
  17.         ss[i] += 10
  18.     }
  20.     fmt.Println(s)  // [1,2,3]
  21. }

短变量声明

Assuming x is declared and y is not declared, which clauses below are correct?
假设声明了x，未声明y，以下哪些句子是正确的？

  1. // 假设声明了x，未声明y，
  2. x, _ := f()     // := 短变量声明，要求至少有一个新变量
  3. x, _ = f()
  4. x, y := f()
  5. x, y = f()
  8. func main() {
  9.     var x int
  10.     // x, _ := f() // := 要求至少有一个新变量
  11.     // x, _ = f()
  13.     // x, y := f() // 正常声明与定义， y是新的变量
  14.     x, y = f() // y 未定义
  15.     fmt.Println(x)
  16.     fmt.Println(y)
  18. }

nil

执行以下代码时将显示什么？并解释为什么println（InitType（）== nil）无法编译？

  2. type S struct{}
  4. func (s S) F() {}
  6. type IF interface {
  7.     F()
  8. }
  10. func InitType() S {
  11.     var s S
  12.     return s
  13. }
  15. func InitPointer() *S {
  16.     var s *S
  17.     return s
  18. }
  19. func InitEfaceType() interface{} {
  20.     var s S
  21.     return s
  22. }
  24. func InitEfacePointer() interface{} {
  25.     var s *S
  26.     return s
  27. }
  29. func InitIfaceType() IF {
  30.     var s S
  31.     return s
  32. }
  34. func InitIfacePointer() IF {
  35.     var s *S
  36.     return s
  37. }
  39. func main() {
  40.     println(InitType() == nil) // nil 不能转换为 struct 类型比较
  41.     // println(InitPointer() == nil)      // true   接口与引用类型（slice、指针、map、chan和函数）指针的零值是 nil
  42.     // println(InitEfaceType() == nil)    // false
  43.     // println(InitEfacePointer() == nil) // false
  44.     // println(InitIfaceType() == nil)    // false
  45.     // println(InitIfacePointer() == nil) //false
  46. }

map

修正以下代码代中

  2. func main() {
  3.     // var m map[string]int
  4.     // m["a"] = 1
  5.     // if v := m["b"]; v != 0 { // v 未找到，默认返回 int零值，无法与nil值比较
  6.     //     println(v)
  7.     // }
  9.     m := make(map[string]int)
  10.     m["a"] = 1
  11.     // if v, ok := m["b"]; ok {
  12.     //     println(v)
  13.     // }
  15.     // if v := m["b"]; v == 0 {   // v 原始0值， 与零值无法分别
  16.     //     println(v)
  17.     // }
  18. }

pointer

赶写a和b行中的空白，以在咻打印的输出为 foo

  2. type S struct {
  3.     m string
  4. }
  6. func f() *S {
  7.     return &S{"foo"}
  8. }
  10. func main() {
  11.     p := *f()
  12.     print(p.m)
  13. }

接口 interface{} pointers

在ABCD中，哪个存在语法问题

  2. type S struct {
  3. }
  5. func f(x interface{}) {}
  7. func g(x *interface{}) {} // 指针接收者
  9. func main() {
  10.     s := S{}
  11.     p := &s
  13.     f(s) //a
  14.     g(s) //b
  15.     f(p) //c
  16.     g(p) //d
  18.     /*
  19.        λ go run main.go
  20.        # command-line-arguments
  21.        .\main.go:41:3: cannot use s (type S) as type *interface {} in argument to g:
  22.                *interface {} is pointer to interface, not interface
  23.        .\main.go:43:3: cannot use p (type *S) as type *interface {} in argument to g:
  24.                *interface {} is pointer to interface, not interface
  25.     */
  27.     /*
  28.     go语言圣经 p123
  29.     总结，在合法的方法调用表达式中，只有符合下面三种形式的语句才能成立：
  30.     1. 实参接收者和形参接收者是同一个类型，比如都是 T 或者 *T
  31.         形参、实参接收都类型相同
  32.     2. 实参接收者是 T类型的变量，而形参接收者是 *T类型（编译器会隐式地获取变量的地址）
  33.         形参是*T指针接收者时，实参必须是 T类型的变量
  34.     3. 实参接收者是 *T类型，而形参接收者是 T类型。（编译器会隐式地解引用接收者，获得实际的取值）
  35.         形参是 T类型，实参*T可以编译
  36.     /*
  37. }

临时指针 Temporary Pointer

解释为什么下面的打印输出为333， 并修改A行以确保打印出012

  2. const N = 3
  4. func main() {
  5.     // m := make(map[int]*int)
  7.     // for i := 0; i < N; i++ {
  8.     //     m[i] = &i
  9.     // }
  11.     // for _, v := range m {
  12.     //     print(*v)
  13.     // }
  15.     // output: 333
  17.     m := make(map[int]*int)
  19.     for i := 0; i < N; i++ {
  20.         v := int(i) // 强制类型转换
  21.         m[i] = &v   // 取 v的地址
  22.     }
  23.     fmt.Printf("%v\n", m)
  25.     for _, v := range m {
  26.         fmt.Println(*v)
  27.     }
  29. }

修改下面的代码，退出外部的for循环

  2. func main() {
  3.     // for i := 0; i < 3; i++ {
  4.     //     for j := 0; j < 3; j++ {
  5.     //         fmt.Println(i, ", ", j, " ")
  6.     //         break
  7.     //     }
  8.     // }
  9.     // fmt.Println()
  11. outer:
  12.     for i := 0; i < 3; i++ {
  13.         for j := 0; j < 3; j++ {
  14.             fmt.Println(i, ", ", j, " ")
  15.             break outer
  16.         }
  17.     }
  18. }

全局变量

要将g声明为全局变量，下面的哪些句子是正确的

  1. var g   // 没类型
  2. var g G
  3. var g = G{}
  4. g := G{} // 错， 只能用在func中

延迟函数

修正以下代码中的错误

  2. func main() {
  3.     f, err := os.Open("test.txt")
  4.     // defer f.Close()
  6.     if err != nil {
  7.         return
  8.     }
  9.     defer f.Close()
  11.     b, err := ioutil.ReadAll(f)
  12.     fmt.Println(string(b))
  13. }

panic堆

以下代码输出什么

  2. func f1() {
  3.     defer fmt.Println("f1-begin")
  4.     f2()
  5.     defer fmt.Println("f1-end")
  6. }
  8. func f2() {
  9.     defer fmt.Println("f2-begin")
  10.     f3()
  11.     defer fmt.Println("f2-end")
  12. }
  14. func f3() {
  15.     defer fmt.Println("f3-begin")
  16.     panic(0)
  17.     defer fmt.Println("f3-end")
  18. }
  20. func main() {
  21.     f1()
  22. }
  24. /*
  25. 一个defer语句就是一个变通的函数或者方法调用，
  26. 函数和参数表达式会在语句执行时求值，
  27. 无论正常（return/函数执行完毕），还是不正常(panic), 实际的调用都推迟到包含 defer语句的函数结束后才执行
  28. f3-begin
  29. f2-being
  30. f1-being
  31. panic
  32. */

recover

image.png

如果 defer(recover) 调用时发生宕机，recover可以终止当前的宕机状态，并且返回宕机的值
如果 recover 在其他任何情况下运行，则它没有任何效果且返回nil

执行以下代码时将显示什么？执行以下代码后，退出代码是什么？

  2. func f() {
  3.     defer func() {
  4.         if r := recover(); r != nil {
  5.             log.Printf("recover: %#v", r)
  6.         }
  7.     }()
  8.     panic(1)
  9.     panic(2)
  10. }
  12. func main() {
  13.     f()
  14. }
  17. /*
  18. D:\projects\gocode\gostudy\demo04 (master -> origin)
  19. λ go run main.go
  20. 2019/10/22 20:45:06 recover: 1
  21. */

type shadowing

  2. type S1 struct {
  3. }
  5. func (s1 S1) f() {
  6.     fmt.Println("S1.fn()")
  7. }
  9. func (s1 S1) g() {
  10.     fmt.Println("S1.g()")
  11. }
  13. type S2 struct {
  14.     S1
  15. }
  17. func (s2 S2) f() {
  18.     fmt.Println("S2.fn()")
  19. }
  21. type I interface {
  22.     f()
  23. }
  25. func printType(i I) {
  26.     fmt.Printf("%T\n", i)
  27.     if s1, ok := i.(S1); ok {
  28.         s1.f()
  29.         s1.g()
  30.     }
  32.     if s2, ok := i.(S2); ok {
  33.         s2.f()
  34.         s2.g()
  35.     }
  36. }
  38. func main() {
  39.     printType(S1{})
  40.     printType(S2{})
  41. }
  44. /*
  45. D:\projects\gocode\gostudy\demo04 (master -> origin)           
  46. λ go run main.go                                               
  47. main.S1                                                        
  48. S1.fn()                                                        
  49. S1.g()                                                         
  50. main.S2                                                        
  51. S2.fn()                                                        
  52. S1.g()                                                         
  54. */

参考

https://goquiz.github.io/