go面试题

1.json包在使用的时候，结构体里的变量不加tag能不能正常转成json里的字段？

• 如果变量首字母小写，则为private。无论如何不能转，因为取不到反射信息。
• 如果变量首字母大写，则为public。
  不加tag，可以正常转为json里的字段，json内字段名跟结构体内字段原名一致。
  加了tag，从struct转json的时候，json的字段名就是tag里的字段名，原字段名已经没用。

2.拷贝大切片一定比小切片代价大吗？

并不是，所有切片的大小相同；三个字段（Data uintptr，Len int，Cap int）。切片中的第一个字是指向切片底层数组的指针，这是切片的存储空间，第二个字段是切片的长度，第三个字段是容量。将一个 slice 变量分配给另一个变量只会复制三个机器字。所以大切片跟小切片的区别无非就是 Len 和 Cap的值比小切片的这两个值大一些，如果发生拷贝，本质上就是拷贝上面的三个字段。

3.翻转含有中文、数字、英文字母的字符串，如"你好abc123"

• rune关键字，从golang源码中看出，它是int32的别名（-2^31 ~ 2^31-1），比起byte（-128～127），可表示更多的字符。
• 由于rune可表示的范围更大，所以能处理一切字符，当然也包括中文字符。在平时计算中文字符，可用rune。
• 因此将字符串转为rune的切片，再进行翻转，完美解决。

package mainimport"fmt"func main() {src := "你好abc啊哈哈"dst := reverse([]rune(src))fmt.Printf("%v\n", string(dst))
}func reverse(s []rune) []rune {for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {s[i], s[j] = s[j], s[i]}return s
}

4.对已经关闭的的 chan 进行读写，会怎么样？为什么？

1. 读已经关闭的 chan 能一直读到东西，但是读到的内容根据通道内关闭前是否有元素而不同。

   如果 chan 关闭前，buffer 内有元素还未读 , 会正确读到 chan 内的值，且返回的第二个 bool 值（是否读成功）为 true。
   如果 chan 关闭前，buffer 内有元素已经被读完，chan 内无值，接下来所有接收的值都会非阻塞直接成功，返回 channel 元素的零值，但是第二个 bool 值一直为 false。
   

2. 写已经关闭的 chan 会 panic: “send on closed channel”

5.for循环select时，如果通道已经关闭会怎么样？如果select中的case只有一个，又会怎么样？

• for循环select时，如果其中一个case通道已经关闭，则每次都会执行到这个case。
• 如果select里边只有一个case，而这个case被关闭了，则会出现死循环。

6.以下代码会发生死循环吗？

package mainimport "fmt"func main() {s := []int{1,2,3,4,5}for _, v:=range s {s =append(s, v)fmt.Printf("len(s)=%v\n",len(s))}
}

• 不会死循环，for range其实是golang的语法糖，在循环开始前会获取切片的长度 len(切片)，然后再执行len(切片)次数的循环。代码运行输出 len(s)=6到10

7.nil切片和空切片的区别

• nil切片和空切片指向的地址不一样。
  nil空切片引用数组指针地址为0（无指向任何实际地址）
  空切片的引用数组指针地址是有的，且固定为一个值

切片的数据结构为：

type SliceHeader struct {Data uintptr  //引用数组指针地址Len  int     // 切片的目前使用长度Cap  int     // 切片的容量
}

8.知道golang的内存逃逸吗？什么情况下会发生内存逃逸？

内存逃逸：

golang程序变量会携带有一组校验数据，用来证明它的整个生命周期是否在运行时完全可知。如果变量通过了这些校验，它就可以在栈上分配。否则就说它 逃逸 了，必须在堆上分配。

能引起变量逃逸到堆上的典型情况：

1. 在方法内把局部变量指针返回 局部变量原本应该在栈中分配，在栈中回收。但是由于返回时被外部引用，因此其生命周期大于栈，则溢出。
2. 发送指针或带有指针的值到 channel 中。 在编译时，是没有办法知道哪个 goroutine 会在 channel 上接收数据。所以编译器没法知道变量什么时候才会被释放。
3. 在一个切片上存储指针或带指针的值。 一个典型的例子就是 []*string 。这会导致切片的内容逃逸。尽管其后面的数组可能是在栈上分配的，但其引用的值一定是在堆上。
4. slice 的背后数组被重新分配了，因为 append 时可能会超出其容量( cap )。 slice 初始化的地方在编译时是可以知道的，它最开始会在栈上分配。如果切片背后的存储要基于运行时的数据进行扩充，就会在堆上分配。
5. 在 interface 类型上调用方法(例如调用fmtPrintln(a intetface{}))。 在 interface 类型上调用方法都是动态调度的 —— 方法的真正实现只能在运行时知道。想像一个 io.Reader 类型的变量 r , 调用 r.Read(b) 会使得 r 的值和切片b 的背后存储都逃逸掉，所以会在堆上分配。

9.字符串转成byte数组，会发生内存拷贝吗？

字符串转成切片，会产生拷贝。严格来说，只要是发生类型强转都会发生内存拷贝。

频繁的内存拷贝操作听起来对性能不大友好。有没有什么办法可以在字符串转成切片的时候不用发生拷贝呢？

package mainimport ("fmt""reflect""unsafe"
)func main() {a :="aaa"ssh := *(*reflect.StringHeader)(unsafe.Pointer(&a))b := *(*[]byte)(unsafe.Pointer(&ssh))  fmt.Printf("%v",b)
}

解释：
StringHeader 是字符串在go的底层结构。

type StringHeader struct {Data uintptrLen  int
}

SliceHeader 是切片在go的底层结构。

type SliceHeader struct {Data uintptrLen  intCap  int
}

那么如果想要在底层转换二者，只需要把 StringHeader 的地址强转成 SliceHeader 就行。那么go有个很强的包叫 unsafe 。
1.unsafe.Pointer(&a)方法可以得到变量a的地址。
2.(*reflect.StringHeader)(unsafe.Pointer(&a)) 可以把字符串a转成底层结构的形式。
3.(*[]byte)(unsafe.Pointer(&ssh)) 可以把ssh底层结构体转成byte的切片的指针。
4.再通过 *转为指针指向的实际内容。