2023版golang面试题100道(slice)

面试题合集目录

整型切片如何初始化？

s1 := make([]int, 0)
s2 := make([]int, 5, 10)
s3 := []int{1, 2, 3}

nil切片和空切片指向的地址一样？

func main() {var s1 []ints2 := make([]int, 0)s3 := make([]int, 0)data1 := (*reflect.SliceHeader)(unsafe.Pointer(&s1)).Datadata2 := (*reflect.SliceHeader)(unsafe.Pointer(&s2)).Datadata3 := (*reflect.SliceHeader)(unsafe.Pointer(&s3)).Datafmt.Printf("s1 data:%+v\n", data1)fmt.Printf("s2 data:%+v\n", data2)fmt.Printf("s3 data:%+v\n", data3)fmt.Printf("s1:s2=>%t\n", data1 == data2)fmt.Printf("s2:s3=>%t\n", data2 == data3)
}//输出
s1 data:0
s2 data:824634859200
s3 data:824634859200
s1:s2=>false
s2:s3=>true

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

//切片的数据结构
type SliceHeader struct {Data uintptr //引用数组指针地址Len  intCap  int
}

nil切片和空切片最大的区别在于指向的数组引用地址是不一样的。

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

并不是，所有切片的大小相同；三个字段（一个uintptr，两个int）。切片中的第一个字段是指向切片底层数组的指针，这是切片的存储空间，第二个字段是切片的长度，第三个字段是容量。将一个slice变量分配给另一个变量只会复制三个机器字。所以拷贝大切片跟小切片的代价应该是一样的。

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

type SliceHeader struct {Data uintptrLen  intCap  int
}

大切片跟小切片的区别无非就是 Len 和 Cap的值比小切片的这两个值大一些，如果发生拷贝，本质上就是拷贝上面的三个字段。

数组和切片的区别是什么?

切片是指针类型，数组是值类型；
数组的长度是固定的，而切片长度可以任意调整（切片是动态的数组）；
数组只有长度一个属性，而切片比数组多了一个容量（cap)属性；
切片的底层也是数组实现的。

数组和切片在传递的时候的区别？

数组在默认情况下是“非引用类型传递”；
切片进行的是“引用类型传递”。

Go语言是如何实现切片扩容的？

func main() {arr := make([]int, 0)oldCap := cap(arr)fmt.Println("len 为", len(arr), "cap 为", cap(arr))for i := 0; i < 2000; i++ {arr = append(arr, i)if oldCap != cap(arr) {fmt.Println("len 为", len(arr), "cap 为", cap(arr))oldCap = cap(arr)}}
}//输出
len 为 0 cap 为 0
len 为 1 cap 为 1
len 为 2 cap 为 2
len 为 3 cap 为 4
len 为 5 cap 为 8
len 为 9 cap 为 16
len 为 17 cap 为 32
len 为 33 cap 为 64
len 为 65 cap 为 128
len 为 129 cap 为 256
len 为 257 cap 为 512
len 为 513 cap 为 848
len 为 849 cap 为 1280
len 为 1281 cap 为 1792
len 为 1793 cap 为 2560

以go 1.18+来说，
原来的slice 容量oldcap小于256的时候，新 slice 的容量newcap是oldcap 的2倍；
当oldcap容量大于等于 256 的时候，newcap会有个计算公式
newcap += (newcap + 3*threshold) / 4
再对 newcap 作了一个内存对齐，这个和内存分配策略相关。进行内存对齐之后，新 slice 的容量是要大于等于按照前半部分生成的newcap。部分源码

func growslice(et *_type, old slice, cap int) slice {// ...newcap := old.capdoublecap := newcap + newcapif cap > doublecap {newcap = cap} else {const threshold = 256if old.cap < threshold {newcap = doublecap} else {for 0 < newcap && newcap < cap {newcap += (newcap + 3*threshold) / 4}if newcap <= 0 {newcap = cap}}}// ...capmem = roundupsize(uintptr(newcap) * goarch.PtrSize)newcap = int(capmem / goarch.PtrSize)// ...
}

json库对nil slice和空slice的处理是一致的吗？

json库对nil slice和空slice的处理是不一致的，
因为nil slice只是声明了slice，却没有给实例化的对象。

    var f1 []stringf2 := make([]string, 0)json1, _ := json.Marshal(Person{f1})json2, _ := json.Marshal(Person{f2})fmt.Printf("%s\n", string(json1))fmt.Printf("%s\n", string(json2))//输出
{"Friends":null}
{"Friends":[]}

json库对nil slice编码为null,
json库对空slice编码为[]。

golang slice的底层实现？

切片是基于数组实现的，它的底层是数组，它自己本身非常小，可以理解为对底层数组的抽象。因为基于数组实现，所以它的底层的内存是连续分配的，效率非常高，还可以通过索引获得数据，可以迭代以及垃圾回收优化。

切片本身并不是动态数组或者数组指针。它内部实现的数据结构通过指针引用底层数组，设定相关属性将数据读写操作限定在指定的区域内。切片本身是一个只读对象，其工作机制类似数组指针的一种封装。

切片对象非常小，是因为它是只有3个字段的数据结构:

type SliceHeader struct {Data uintptr //指向底层数组的指针Len  int    //切片的长度Cap  int     //切片的容量
}

扩容前后的slice是否相同？

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