编程技术-Go基础面经大全(持续补充中)

Go基础

1. 基础特性

1. Go的优势

   • 天生支持并发，性能高。

   • 单一的标准代码格式，比其他语言更具可读性。

   • 自动垃圾收集机制比Java和Python更有效，因为它与程序同时执行。

2. Go数据类型

   • int, string, float, bool, array, slice, map, channel, pointer, struct, interface, method

3. go中的25个关键字

   • 程序声明2个：
     package import
   • 程序实体声明和定义8个：
     var const type func struct map chan interface
   • 程序流程控制15个：
     for range continue break select switch case default if else fallthrough defer go goto return

4. Go程序中的包是什么？

   • 项目中包含go源文件以及其它包的目录，源文件中的函数、变量、类型都存储在该包中
   • 每个源文件都属于一个包，该包在文件顶部使用 package packageName 声明
   • 当我们在源文件中引用第三包时，需要还用 import packageName

5. Go支持什么形式的类型转换？如何实现整数转为浮点数

   • go支持显示类型转换，即严格强制类型转换

   • a := 15
     b := float64(a)
     fmt.Println(b, reflect.TypeOf(b))  
     

2. 初级语法

1. = 和 := 的区别？

   • := 声明+赋值= 仅赋值

   • var foo int
     foo = 10
     // 等价于
     foo := 10
     

2. 指针的作用？

   • 指针用来保存变量的地址。

   • 例如:

   • var x =  5
     var p *int = &x
     fmt.Printf("x = %d",  *p) // x 可以用 *p 访问*
     

   • *运算符，也称为解引用运算符，用于访问地址中的值。

   • ＆运算符，也称为地址运算符，用于返回变量的地址。

3. Go 允许多个返回值吗？

   • 允许

   • func swap(x, y string) (string, string) {
             
        return y, x
     }
     
     func main() {
             
        a, b := swap("A", "B")
        fmt.Println(a, b) // B A
     }
     

4. Go 有异常类型吗？

   • Go 没有异常类型，只有错误类型（Error），通常使用返回值来表示异常状态。

   • f, err := os.Open("test.txt")
     if err != nil {
             
         log.Fatal(err)
     }
     

5. 什么是协程（Goroutine）?

   • Goroutine 是与其他函数或方法同时运行的函数或方法。 Goroutines 可以被认为是轻量级的线程。 与线程相比，创建 Goroutine 的开销很小。 Go应用程序同时运行数千个 Goroutine 是非常常见的做法。

6. 如何高效地拼接字符串?

   • Go 语言中，字符串是只读的，也就意味着每次修改操作都会创建一个新的字符串。如果需要拼接多次，应使用 strings.Builder，最小化内存拷贝次数。

   • var str strings.Builder
     for i := 0; i < 1000; i++ {
             
         str.WriteString("a")
     }
     fmt.Println(str.String())
     

7. 什么是 rune 类型?

   • ASCII 码只需要 7 bit 就可以完整地表示，但只能表示英文字母在内的128个字符，为了表示世界上大部分的文字系统，发明了 Unicode， 它是ASCII的超集，包含世界上书写系统中存在的所有字符，并为每个代码分配一个标准编号（称为Unicode CodePoint），在 Go 语言中称之为 rune，是 int32 类型的别名。

   • Go 语言中，字符串的底层表示是 byte (8 bit) 序列，而非 rune (32 bit) 序列。例如下面的例子中 语 和 言 使用 UTF-8 编码后各占 3 个 byte，因此 len(“Go语言”) 等于 8，当然我们也可以将字符串转换为 rune 序列。

   • fmt.Println(len("Go语言")) // 8
     fmt.Println(len([]rune("Go语言"))) // 4
     

8. Go 支持默认参数或可选参数吗？

   • Go 语言不支持可选参数（python 支持），也不支持方法重载（java支持）。

9. 如何交换 2 个变量的值？

   1. a, b := "A", "B"
      a, b = b, a
      fmt.Println(a, b) // B A
      

10. Go 语言 tag 的用处？

    1. tag 可以理解为 struct 字段的注解，可以用来定义字段的一个或多个属性。框架/工具可以通过反射获取到某个字段定义的属性，采取相应的处理方式。tag 丰富了代码的语义，增强了灵活性。

    2. 例如：

    3. package main
       
       import "fmt"
       import "encoding/json"
       
       type Stu struct {
               
       	Name string `json:"stu_name"`
       	ID   string `json:"stu_id"`
       	Age  int    `json:"-"`
       }
       
       func main() {
               
       	buf, _ := json.Marshal(Stu{
               "Tom", "t001", 18})
       	fmt.Printf("%s\n", buf)
       }
       

    4. 这个例子使用 tag 定义了结构体字段与 json 字段的转换关系，Name -> stu_name, ID -> stu_id，忽略 Age 字段。很方便地实现了 Go 结构体与不同规范的 json 文本之间的转换。

11. 字符串打印时，%v 和 %+v 的区别

    • %v 和 %+v 都可以用来打印 struct 的值，区别在于 %v 仅打印各个字段的值，%+v 还会打印各个字段的名称。

    • type Stu struct {
              
      	Name string
      }
      
      func main() {
              
      	fmt.Printf("%v\n", Stu{
              "Tom"}) // {Tom}
      	fmt.Printf("%+v\n", Stu{
              "Tom"}) // {Name:Tom}
      }
      

    • 但如果结构体定义了 String() 方法，%v 和 %+v 都会调用 String() 覆盖默认值。

12. Go 语言中如何表示枚举值(enums)?

    • 通常使用常量(const) 来表示枚举值。

    • type StuType int32
      
      const (
      	Type1 StuType = iota
      	Type2
      	Type3
      	Type4
      )
      
      func main() {
              
      	fmt.Println(Type1, Type2, Type3, Type4) // 0, 1, 2, 3
      }
      

    • 参考 What is an idiomatic way of representing enums in Go? - StackOverflow

13. 空 struct{} 的用途?

    • 使用空结构体 struct{} 可以节省内存，一般作为占位符使用，表明这里并不需要一个值。

      1. fmt.Println(unsafe.Sizeof(struct{
                   }{
                   })) // 0
         

    • 比如使用 map 表示集合时，只关注 key，value 可以使用 struct{} 作为占位符。如果使用其他类型作为占位符，例如 int，bool，不仅浪费了内存，而且容易引起歧义。

      1. type Set map[string]struct{
                   }
         
         func main() {
                   
         	set := make(Set)
         
         	for _, item := range []string{
                   "A", "A", "B", "C"} {
                   
         		set[item] = struct{
                   }{
                   }
         	}
         	fmt.Println(len(set)) // 3
         	if _, ok := set["A"]; ok {
                   
         		fmt.Println("A exists") // A exists
         	}
         }
         

    • 再比如，使用信道(channel)控制并发时，我们只是需要一个信号，但并不需要传递值，这个时候，也可以使用 struct{} 代替。

      1. func main() {
                   
         	ch := make(chan struct{
                   }, 1)
         	go func() {
                   
         		<-ch
         		// do something
         	}()
         	ch <- struct{
                   }{
                   }
         	// ...
         }
         

    • 再比如，声明只包含方法的结构体。

      1. type Lamp struct{
                   }
         
         func (l Lamp) On() {
                   
                 println("On")
         
         }
         func (l Lamp) Off() {
                   
                 println("Off")
         }
         

14. go中的cap函数可以作用于哪些内容？

    • 可作用于的类型有：

      • 数组（array）
      • 切片（slice）
      • 通道（channel）

    • 查看他们的容量大小，而不是装的数据大小

15. go语言中new的作用是什么？

    • 使用new函数来分配内存空间
    • 传递给new函数的是一个类型，而不是一个值
    • 返回值是指向这个新分配的地址的指针

16. go语言中的make作用是什么？

    • 分配内存空间并进行初始化, 返回值是该类型的实例而不是指针
    • make只能接收三种类型当做参数：slice、map、channel

17. 总结make和new的区别？

    1. new可以接收任意内置类型当做参数，返回的是对应类型的指针
    2. make只能接收slice、map、channel当做参数，返回值是对应类型的实例

18. 如何在运行时检查变量类型？

    • 类型开关(Type Switch)是在运行时检查变量类型的最佳方式。

    • 类型开关按类型而不是值来评估变量。每个 Switch 至少包含一个 case 用作条件语句

    • 如果没有一个 case 为真，则执行 default。

19. switch case fallthrough default使用场景

    • func main() {
              
          var a int
          for i := 0; i < 10; i++{
              
              a = rand.Intn(100)
              switch {
              
                  case a >= 80:
                  fmt.Println("优秀", a)
                  fallthrough // 强制执行下一个case
                  case a >= 60:
                  fmt.Println("及格", a)
                  fallthrough
                  default:
                  fmt.Println("不及格", a)
              }
          }
      }
      

20. fmt包中Printf、Sprintf、Fprintf都是格式化输出，有什么不同？

    • 虽然这三个函数都是格式化输出，但是输出的目标不一样

      • Printf输出到控制台
      • Sprintf结果赋值给返回值
      • FprintF输出到指定的io.Writer接口中

    • 例如：

      • func main() {
                  
            var a int = 15
            file, _ := os.OpenFile("test.log", os.O_CREATE|os.O_APPEND, 0644)
            // 格式化字符串并输出到文件
            n, _ := fmt.Fprintf(file, "%T:%v:%p", a, a, &a)
            fmt.Println(n)
        }
        

21. go语言中的数组和切片的区别是什么？

    • 数组：
      1. 数组固定长度，数组长度是数组类型的一部分，所以[3]int和[4]int是两种不同的数组类型
      2. 数组类型需要指定大小，不指定也会根据初始化，自动推算出大小，大小不可改变，数组是通过值传递的
    • 切片：
      1. 切片的长度可改变，切片是轻量级的数据结构，三个属性：指针、长度、容量
      2. 不要指定切片的大小，切片也是值传递只不过切片的一个属性指针指向的数据不变，所以看起来像引用传递
      3. 切片可以通过数组来初始化也可以通过make函数来初始化，初始化时的len和cap相等，然后进行扩容
      4. 切片扩容的时候会导致底层的数组复制，也就是切片中的指针属性会发生变化
      5. 切片也是拷贝，在不发生扩容时，底层使用的是同一个数组，当对其中一个切片append的时候, 该切片长度会增加
         但是不会影响另外一个切片的长度
      6. copy函数将原切片拷贝到目标切片，会导致底层数组复制，因为目标切片需要通过make函数来声明初始化内存，然后
         将原切片指向的数组元素拷贝到新切片指向的数组元素
    • 重点：数组保存真正的数据，切片值保存数组的指针和该切片的长度和容量
    • append函数如果切片容量足够的话，只会影响当前切片的长度，数组底层不会复制，不会影响与数组关联的其它切片的长度
    • copy直接会导致数组底层复制。

22. go语言中值传递和地址传递（引用传递）如何运行？有什么区别？举例说明

    • 值传递会把参数的值复制一份放到对应的函数里，两个变量的地址不同，不可互相修改
    • 地址传递会把参数的地址复制一份放到对应的函数里，两个变量的地址相同，可以互相修改
    • 例如：数组传递就是值传递，而切片传递就是数组的地址传递（本质上切片值传递，只不过是保存的数据地址相同）

23. go中的参数传递、引用传递

    • go语言中的所有的传参都是值传递（传值），都是一个副本，一个拷贝，

    • 因为拷贝的内容有时候是非引用类型（int, string, struct）等，这样在函数中就无法修改原内容数据

    • 有的是引用类型（指针、slice、map、chan），这样就可以修改原内容数据

    • go中的引用类型包含slice、map、chan,它们有复杂的内部结构，除了申请内存外，还需要初始化相关属性

    • 内置函数new计算类型大小，为其分配零值内存，返回指针。

    • 而make会被编译器翻译成具体的创建函数，由其分配内存并初始化成员结构，返回对象而非指针

24. go中数组和切片在传递时有什么区别？

    • 数组是值传递
    • 切片地址传递（引用传递）

25. go中slice的底层实现

    • 切片是基于数组实现的，它的底层是数组，它本身非常小，它可以理解为对底层数组的抽闲
    • 因为基于数组实现，所以它的底层内存是连续分配的，效率非常高，还可以通过索引获取数据
    • 切片本身并不是动态数组或数组指针，它内部实现的数据结构体通过指针引用底层数组
    • 设定相关属性将读写操作限定在指定的区域内，切片本身是一个只读对象，其工作机制类似于数组指针的一种封装
    • 切片对象非常小，因为它只有三个字段的数据结构：指向底层数组的指针、切片的长度、切片的容量

26. go中slice的扩容机制，有什么注意点？

    • 首先判断，如果新申请的容量大于2倍的旧容量，最终容量就是新申请的容量
    • 否则判断，如果旧切片的长度小于1024，最终容量就是旧容量的两倍
    • 否则判断，如果旧切片的长度大于等于1024，则最终容量从旧容量开始循环增加原来的1/4,直到最终容量大于新申请的容量
    • 如果最终容量计算值溢出，则最终容量就是新申请的容量

27. go中是如何实现切片扩容的？[答案有误，需要重新确定]

    • 当容量小于1024时，每次扩容容量翻倍，当容量大于1024时，每次扩容加25%.

    • func main() {
              
          s1 := make([]int, 0)
          for i := 0; i < 3000; i++{
              
              fmt.Println("len =", len(s1), "cap = ", cap(s1))
              s1 = append(s1, i)
          }
      }
      

28. 扩容前后的slice是否相同？

    • 情况一：
      1. 原来数组还有容量可以扩容（实际容量没有填充完），这种情况下，扩容之后的切片还是指向原来的数组
      2. 对一个切片的操作可能影响多个指针指向相同地址的切片
    • 情况二：
      1. 原来数组的容量已经达到了最大值，在扩容，go默认会先开辟一块内存区域，把原来的值拷贝过来
      2. 然后再执行append操作，这种情况丝毫不影响原数组
    • 注意：要复制一个slice最好使用copy函数

29. 如何判断 2 个字符串切片（slice) 是相等的？

    • go 语言中可以使用反射 reflect.DeepEqual(a, b) 判断 a、b 两个切片是否相等，但是通常不推荐这么做，使用反射非常影响性能。

    • 通常采用的方式如下，遍历比较切片中的每一个元素（注意处理越界的情况）。

      1. func StringSliceEqualBCE(a, b []string) bool {
                   
             if len(a) != len(b) {
                   
                 return false
             }
         
             if (a == nil) != (b == nil) {
                   
                 return false
             }
         
             b = b[:len(a)]
             for i, v := range a {
                   
                 if v != b[i] {
                   
                     return false
                 }
             }
         
             return true
         }
         

30. 看下面代码defer的执行顺序是什么？defer的作用和特点是什么？

    • 在普通函数或方法前加上defer关键字，就完成了defer所需要的语法，当defer语句被执行时，跟在defer语句后的函数会被延迟执行

    • 知道包含该defer语句的函数执行完毕，defer语句后的函数才会执行，无论包含defer语句的函数是通过return正常结束，还是通过panic导致的异常结束

    • 可以在一个函数中执行多条defer语句，由于在栈中存储，所以它的执行顺序和声明顺序相反

    • 多个 defer 语句，遵从后进先出(Last In First Out，LIFO)的原则，最后声明的 defer 语句，最先得到执行。defer 在 return 语句之后执行，但在函数退出之前，defer 可以修改返回值。

    • 例子：

    • func test() int {
              
      	i := 0
      	defer func() {
              
      		fmt.Println("defer1")
      	}()
      	defer func() {
              
      		i += 1
      		fmt.Println("defer2")
      	}()
      	return i
      }
      
      func main() {
              
      	fmt.Println("return", test())
      }
      // defer2
      // defer1
      // return 0
      

    • 这个例子中，可以看到 defer 的执行顺序：后进先出。但是返回值并没有被修改，这是由于 Go 的返回机制决定的，执行 return 语句后，Go 会创建一个临时变量保存返回值，因此，defer 语句修改了局部变量 i，并没有修改返回值。那如果是有名的返回值呢？

    • func test() (i int) {
              
      	i = 0
      	defer func() {
              
      		i += 1
      		fmt.Println("defer2")
      	}()
      	return i
      }
      
      func main() {
              
      	fmt.Println("return", test())
      }
      // defer2
      // return 1
      

    • 这个例子中，返回值被修改了。对于有名返回值的函数，执行 return 语句时，并不会再创建临时变量保存，因此，defer 语句修改了 i，即对返回值产生了影响。

31. defer的常用场景

    • defer语句经常被用于处理成对的操作打开/关闭，链接/断开连接，加锁/释放锁
    • 通过defer机制，不论函数逻辑多复杂，都能保证在任何执行路径下，资源被释放
    • 释放资源的defer语句应该直接跟在请求资源处理错误之后
    • 注意：defer一定要放在请求资源处理错误之后

32. defer语句中通过recover捕获panic例子

    • 注意要在defer后函数里的recover()

    • func main() {
              
          defer func() {
              
              err := recover()
              fmt.Println(err)
          }()
          defer fmt.Println("first defer")
          defer fmt.Println("second defer")
          defer fmt.Println("third defer")
          fmt.Println("哈哈哈哈")
          panic("abc is an error")
      }
      

33. 哈希概念讲解

    • 哈希表又称为散列表，由一个直接寻址表和一个哈希函数组成

    • 由于哈希表的大小是有限的而要存储的数值是无限的，因此对于任何哈希函数,都会出现两个不同元素映射到相同位置的情况，这种情况叫做哈希冲突

    • 通过拉链法解决哈希冲突：

      • 哈希表每个位置都连接一个链表，当冲突发生是，冲突的元素将会被加到该位置链表的最后

    • 哈希表的查找速度起决定性作用的就是哈希函数: 除法哈希发、乘法哈希法、全域哈希法

    • 哈希表的应用？

      • 字典与集合都是通过哈希表来实现的
      • md5曾经是密码学中常用的哈希函数，可以把任意长度的数据映射为128位的哈希值

34. go中的map底层实现

    • go中map的底层实现就是一个散列表，因此实现map的过程实际上就是实现散列表的过程
    • 在这个散列表中，主要出现的结构体由两个，一个是hmap、一个是bmap
    • go中也有一个哈希函数，用来对map中的键生成哈希值
    • hash结果的低位用于把k/v放到bmap数组中的哪个bmap中
    • 高位用于key的快速预览，快速试错

35. go中的map如何扩容

    • 翻倍扩容：如果map中的键值对个数/桶的个数>6.5，就会引发翻倍扩容
    • 等量扩容：当B<=15时，如果溢出桶的个数>=2的B次方就会引发等量扩容
    • 当B>15时，如果溢出桶的个数>=2的15次方时就会引发等量扩容

36. go中map的查找

    • go中的map采用的是哈希查找表，由哈希函数通过key和哈希因此计算出哈希值，
    • 根据hamp中的B来确定放到哪个桶中，如果B=5，那么就根据哈希值的后5位确定放到哪个桶中
    • 在用哈希值的高8位确定桶中的位置，如果当前的bmap中未找到，则去对应的overflow bucket中查找
    • 如果当前map处于数据搬迁状态，则优先从oldbuckets中查找

37. 如何判断 map 中是否包含某个 key ？

    • if val, ok := dict["foo"]; ok {
              
          //do something here
      }
      

    • dict[“foo”] 有 2 个返回值，val 和 ok，如果 ok 等于 true，则说明 dict 包含 key “foo”，val 将被赋予 “foo” 对应的值。

2. 代码输出

2.1 常量与变量

1. 下面代码的输出是：

   func main() {
         
   	const (
   		a, b = "golang", 100
   		d, e
   		f bool = true
   		g
   	)
   	fmt.Println(d, e, g)
   }
   

   答案：

   golang 100 true
   

   在同一个 const group 中，如果常量定义与前一行的定义一致，则可以省略类型和值。编译时，会按照前一行的定义自动补全。即等价于

   gofunc main() {
         	
       const (		
           a, b = "golang", 100	
           d, e = "golang", 100	
           f bool = true	
           g bool = true	
       )
       fmt.Println(d, e, g)
   }
   

2. 下面代码输出是：

   func main() {
         
   	const N = 100
   	var x int = N
   
   	const M int32 = 100
   	var y int = M
   	fmt.Println(x, y)
   }
   

   答案：

   编译失败：cannot use M (type int32) as type int in assignment
   Go 语言中，常量分为无类型常量和有类型常量两种，const N = 100，属于无类型常量，赋值给其他变量时，如果字面量能够转换为对应类型的变量，则赋值成功，例如，var x int = N。但是对于有类型的常量 const M int32 = 100，赋值给其他变量时，需要类型匹配才能成功，所以显示地类型转换：
   var y int = int(M)
   

3. 下面代码的输出是：

   func main() {
         
   	var a int8 = -1
   	var b int8 = -128 / a
   	fmt.Println(b)
   }
   

   答案：

   -128
   int8 能表示的数字的范围是 [-2^7, 2^7-1]，即 [-128, 127]。-128 是无类型常量，转换为 int8，再除以变量 -1，结果为 128，常量除以变量，结果是一个变量。变量转换时允许溢出，符号位变为1，转为补码后恰好等于 -128。
   对于有符号整型，最高位是是符号位，计算机用补码表示负数。补码 = 原码取反加一。
   例如：-1 :  11111111
   00000001(原码)    11111110(取反)    11111111(加一)
   -128：    
   10000000(原码)    01111111(取反)    10000000(加一)
   -1 + 1 = 011111111 + 00000001 = 00000000(最高位溢出省略)
   -128 + 127 = -110000000 + 01111111 = 11111111
   

4. 下面代码输出是：

   func main() {
         
   	const a int8 = -1
   	var b int8 = -128 / a
   	fmt.Println(b)
   }
   

   答案：

   编译失败：constant 128 overflows int8
   -128 和 a 都是常量，在编译时求值，-128 / a = 128，两个常量相除，结果也是一个常量，常量类型转换时不允许溢出，因而编译失败。
   

2.2 作用域

1. 下列代码输出是:

   func main() {
         
   	var err error
   	if err == nil {
         
   		err := fmt.Errorf("err")
   		fmt.Println(1, err)
   	}
   	if err != nil {
         
   		fmt.Println(2, err)
   	}
   }
   

   答案：

   1 err
   := 表示声明并赋值，= 表示仅赋值。
   变量的作用域是大括号，因此在第一个 if 语句 if err == nil 内部重新声明且赋值了与外部变量同名的局部变量 err。对该局部变量的赋值不会影响到外部的 err。因此第二个 if 语句 if err != nil 不成立。所以只打印了 1 err。
   

2.3 defer 延迟调用

1. 下列代码输出：

   type T struct{
         }
   
   func (t T) f(n int) T {
         
   	fmt.Print(n)
   	return t
   }
   
   func main() {
         
   	var t T
   	defer t.f(1).f(2)
   	fmt.Print(3)
   }
   

   答案：

   132
   defer 延迟调用时，需要保存函数指针和参数，因此链式调用的情况下，除了最后一个函数/方法外的函数/方法都会在调用时直接执行。也就是说 t.f(1) 直接执行，然后执行 fmt.Print(3)，最后函数返回时再执行 .f(2)，因此输出是 132。
   

2. func f(n int) {
         
   	defer fmt.Println(n)
   	n += 100
   }
   
   func main() {
         
   	f(1)
   }
   

   答案：

   1
   打印 1 而不是 101。defer 语句执行时，会将需要延迟调用的函数和参数保存起来，也就是说，执行到 defer 时，参数 n(此时等于1) 已经被保存了。因此后面对 n 的改动并不会影响延迟函数调用的结果。
   

3. func main() {
         
   	n := 1
   	defer func() {
         
   		fmt.Println(n)
   	}()
   	n += 100
   }
   

   答案：

   101
   匿名函数没有通过传参的方式将 n 传入，因此匿名函数内的 n 和函数外部的 n 是同一个，延迟执行时，已经被改变为 101。
   

4. func main() {
         
   	n := 1
   	if n == 1 {
         
   		defer fmt.Println(n)
   		n += 100
   	}
   	fmt.Println(n)
   }
   

   答案：

   101
   1
   先打印 101，再打印 1。defer 的作用域是函数，而不是代码块，因此 if 语句退出时，defer 不会执行，而是等 101 打印后，整个函数返回时，才会执行。
   

3. 中级语法

1. go两个接口之间可以存在什么关系？

   • 如果两个接口有相同的方法列表，那么他俩就是等价的，可以相互赋值
   • 接口A可以嵌套到接口B里面，那么接口B就有了自己的方法列表+接口A的方法列表

2. 什么是 goroutine，你如何停止它？

   • goroutine是协程/轻量级线程/用户态线程，不同于传统的内核态线程

   • 占用资源特别少，创建和销毁只在用户态执行不会到内核态，节省时间

   • 创建goroutine需要使用go关键字

   • 可以向goroutine发送一个信号通道来停止它，goroutine内部需要检查信号通道

   • 例子：

   • func main() {
             
         var wg sync.WaitGroup // 等待组进行多个任务的同步，可以保证并发环境中完成指定数量的任务，每个sync.WaitGroup值在内部维护着一个计数，此计数的初始默认值为0
         var exit = make(chan bool)
         wg.Add(1) // 等待组的计数器+1
         go func() {
             
             for {
             
                 select {
             
                 case <-exit:  // 接收到信号后return退出当前goroutine
                     fmt.Println("goroutine接收到信号退出了！")
                     wg.Done() // 等待组的计数器-1
                     return
                 default:
                     fmt.Println("还没有接收到信号")
                 }
             }
         }()
         exit <- true
         wg.Wait() // 当等待组计数器不等于0时阻塞，直到变为0
     }
     

3. go中同步锁（也叫互斥锁）有什么特点，作用是什么？何时使用互斥锁，何时使用读写锁？

   • 当一个goroutine获得了Mutex（互斥锁）后，其它goroutine就只能乖乖等待，除非该goroutine释放Mutex

   • RWMutext（读写互斥锁）在读锁占用的情况下会阻止写，但不会阻止读，在写锁占用的情况下，会阻止任何其它goroutine进来

   • 无论是读还是写，整个锁相当于由该goroutine独占

   • 作用：保证资源在使用时的独有性，不会因为并发导致数据错乱，保证系统稳定性

   • 案例：

     • package main
       import (
           "fmt"
           "sync"
           "time"
       )
       var (
           num = 0
           lock = sync.RWMutex{
                 }  // 耗时：100+毫秒
           //lock = sync.Mutex{}  // 耗时：50+毫秒
       )
       func main() {
                 
           start := time.Now()
           go func() {
                 
               for i := 0; i < 100000; i++{
                 
                   lock.Lock()
                   //fmt.Println(num)
                   num++
                   lock.Unlock()
               }
           }()
           for i := 0; i < 100000; i++{
                 
               lock.Lock()
               //fmt.Println(num)
               num++
               lock.Unlock()
           }
           fmt.Println(num)
           fmt.Println(time.Now().Sub(start))
       }
       

   • 总结：

     • 如果对数据写的比较多，使用Mutex同步锁/互斥锁性能更高
     • 如果对数据读的比较多，使用RWMutex读写锁性能更高

4. goroutine案例（两个goroutine，一个负责输出数字，另一个负责输出26个英文字母，格式如下：12ab34cd56ef78gh … yz）

   • package main
     import (
     	"fmt"
     	"sync"
     	"unicode/utf8"
     )
     // 案例：两个goroutine，一个负责输出数字，另一个负责输出26个英文字母，格式如下：12ab34cd56ef78gh ... yz
     var (
     	wg = sync.WaitGroup{
             }  // 和第五题很相关。申明等待组
     	chNum = make(chan bool)
     	chAlpha = make(chan bool)
     )
     func main() {
             
     	go func() {
             
     		i := 1
     		for {
             
     			<-chNum // 接到信号，运行该goroutine
     			fmt.Printf("%v%v", i, i + 1)
     			i += 2
     			chAlpha <- true // 发送信号
     		}
     	}()
     	wg.Add(1) // 等待组的计数器+1
     	go func() {
             
     		str := "abcdefghigklmnopqrstuvwxyz"
     		i := 0
     		for {
             
     			<-chAlpha // 接到信号，运行该goroutine
     			fmt.Printf("%v", str[i:i+2])
     			i += 2
     			if i >= utf8.RuneCountInString(str){
             
     				wg.Done() // 等待组的计数器-1
     				return
     			}
     			chNum <- true // 发送信号
     		}
     	}()
     	chNum <- true // 发送信号
     	wg.Wait() // 等待组的计数器不为0时，阻塞main进程，直到等待组的计数器为0
     }
     

5. 介绍一下channel

   • go中不要通过共享内存来通信，而要通过通信实现共享内存
   • go中的csp并发模型，中文名通信顺序进程，就是通过goroutine和channel实现的
   • channel收发遵循先进先出，分为有缓冲通道（异步通道），无缓冲通道（同步通道）

6. go中channel的特性

   • 给一个nil的channel发送数据，会造成永久阻塞
   • 从一个nil的channel接收数据，会造成永久阻塞
   • 给一个已经关闭的channel发送数据，会造成panic
   • 从一个已经关闭的channel接收数据，如果缓冲区为空，会返回零值
   • 无缓冲的channel是同步的，有缓冲的channel是异步的
   • 关闭一个nil channel会造成panic

7. channel中ring buffer的实现

   1. channel中使用了ring buffer（环形缓冲区）来缓存写入数据，
   2. ring buffer有很多好处，而且非常适合实现FiFo的固定长度队列
   3. channel中包含buffer、sendx、recvx
   4. recvx指向最早被读取的位置，sendx指向再次写入时插入的位置

8. go语言中，channel通道有什么特点，需要注意什么？

   • 总结：

     • 给一个nil channel发送数据时会一直堵塞
     • 从一个nil channel接收数据时会一直阻塞
     • 给一个已关闭的channel发送数据时会panic
     • 从一个已关闭的channel中读取数据时，如果channel为空，则返回通道中类型的零值

   • 案例：

     • package main
       import (
       	"fmt"
       	"sync"
       )
       func main() {
                 
       	var wg sync.WaitGroup // 等待组
       	var ch chan int // nil channel
       	var ch1 = make(chan int) // 创建channel
       	fmt.Println(ch, ch1)  // <nil> 0xc000086060
       	wg.Add(1) // 等待组的计数器+1
       	go func() {
                 
       		//ch <- 15  // 如果给一个nil的channel发送数据会造成永久阻塞
       		//<-ch  // 如果从一个nil的channel中接收数据也会造成永久阻塞
       		ret := <-ch1
       		fmt.Println(ret)
       		ret = <-ch1  // 从一个已关闭的通道中接收数据，如果缓冲区中为空，则返回该类型的零值
       		fmt.Println(ret)
       		wg.Done() // 等待组的计数器-1
       	}()
       	go func() {
                 
       		//close(ch1)
       		ch1 <- 15  // 给一个已关闭通道发送数据就会包panic错误
       		close(ch1)
       	}()
       	wg.Wait() // 等待组的计数器不为0时阻塞
       }
       

9. go中channel缓冲有什么特点？

   • 无缓冲的通道是同步的，有缓冲的通道是异步的

10. 写一个定时任务，每秒执行一次

    • func main() {
              
          t1 := time.NewTicker(time.Second * 1) // 创建一个周期定时器
          var i = 1
          for {
              
              if i == 10{
              
                  break
              }
              select {
              
                  case <-t1.C:  // 一秒执行一次的定时任务
                  task1(i)
                  i++
              }
          }
      }
      func task1(i int) {
              
          fmt.Println("task1执行了---", i)
      }
      

4. 基础应用

1. 如何关闭 HTTP 的响应体的？

   • 直接在处理 HTTP 响应错误的代码块中，直接关闭非 nil 的响应体；

   • 手动调用 defer 来关闭响应体。

   • 正确示例：

     • func main() {
           resp, err := http.Get("http://www.baidu.com") // 发出请求并返回请求结果
       
           // 关闭 resp.Body 的正确姿势
           if resp != nil {
             	defer resp.Body.Close()
           }
       
           checkError(err) // 检查错误，省略写法
           defer resp.Body.Close()	// 手动调用defer来关闭响应体
       
           body, err := ioutil.ReadAll(resp.Body) // 一次性读写文件的全部数据
           checkError(err)
       
           fmt.Println(string(body))
       }
       

2. 是否主动关闭过http连接，为啥要这样做？

   • 有关闭，不关闭会程序可能会消耗完 socket 描述符。有如下2种关闭方式：

     • 直接设置请求变量的 Close 字段值为 true，每次请求结束后就会主动关闭连接。

     • 设置 Header 请求头部选项 Connection: close，然后服务器返回的响应头部也会有这个选项，此时 HTTP 标准库会主动断开连接

     • // 主动关闭连接
       func main() {
                 
           req, err := http.NewRequest("GET", "http://golang.org", nil)
           checkError(err)
       
           req.Close = true // 直接设置请求变量的Close字段值为true,每次请求结束后主动关闭连接
           //req.Header.Add("Connection", "close") // 等效的关闭方式
       
           resp, err := http.DefaultClient.Do(req)
           if resp != nil {
                 
               defer resp.Body.Close()
           }
           checkError(err)
       
           body, err := ioutil.ReadAll(resp.Body)
           checkError(err)
       
           fmt.Println(string(body))
       }
       

   • 你可以创建一个自定义配置的 HTTP transport(传输) 客户端，用来取消 HTTP 全局的复用连接。

     • func main() {
                 
           tr := http.Transport{
                 DisableKeepAlives: true} // 自定义配置传输客户端，用来取消HTTP全部的复用连接。
           client := http.Client{
                 Transport: &tr}
       
           resp, err := client.Get("https://golang.google.cn/")
           if resp != nil {
                 
               defer resp.Body.Close()
           }
           checkError(err)
       
           fmt.Println(resp.StatusCode) // 200
       
           body, err := ioutil.ReadAll(resp.Body)
           checkError(err)
       
           fmt.Println(len(string(body)))
       }
       

3. 解析 JSON 数据时，默认将数值当做哪种类型?

   • 在 encode/decode JSON 数据时，Go 默认会将数值当做 float64 处理。

   • func main() {
             
         var data = []byte(`{"status": 200}`)
         var result map[string]interface{
             }
     
         if err := json.Unmarshal(data, &result); err != nil {
             
           	log.Fatalln(err)
         }
     }
     

     解析出来的 200 是 float 类型。

4. JSON 标准库对 nil slice 和 空 slice 的处理是一致的吗?

   • 首先 JSON 标准库对 nil slice 和 空 slice 的处理是不一致。

   • 通常错误的用法，会报数组越界的错误，因为只是声明了slice，却没有给实例化的对象。

     var slice []int // nil slice
     slice[1] = 0
     

     此时slice的值是nil，这种情况可以用于需要返回slice的函数，当函数出现异常的时候，保证函数依然会有nil的返回值。

     empty slice 是指slice不为nil，但是slice没有值，slice的底层的空间是空的，此时的定义如下：

     slice := make([]int,0）// 空slice，没有值，空间也是空的
     slice := []int{
             }
     

     当我们查询或者处理一个空的列表的时候，这非常有用，它会告诉我们返回的是一个列表，但是列表内没有任何值。总之，nil slice 和 empty slice是不同的东西,需要我们加以区分的。

5. 扩展了解

1. go convey是什么，一般用来做什么？

   • go convey是一个支持golang的单元测试框架
   • 能够自动监控文件修改并启动测试，并可以将测试结果实时输出到web界面
   • 提供了丰富的断言简化测试用例的编写

2. 说说go语言的beego框架

   • beego 是一个 golang 实现的轻量级HTTP框架
   • beego 可以通过注释路由、正则路由等多种方式完成 url 路由注入
   • 可以使用 bee new 工具生成空工程，然后使用 bee run 命令自动热编译

3. GoStub的作用是什么？

   • GoStub也是一种测试框架：

     • GoStub 可以对全局变量打桩

     • GoStub 可以对函数打桩

     • GoStub 不可以对类的成员方法打桩

     • GoStub 可以打动态桩，比如对一个函数打桩后，多次调用该函数会有不同的行为

6.参考

1. Go 语言笔试面试题汇总 | 极客面试 | 极客兔兔 (geektutu.com)
2. 极客时间-轻松学习，高效学习-极客邦 (geekbang.org)

整理不易，给个赞吧！~~~