自学内容网 自学内容网
自学内容网 > 正文

【Golang 面试基础题】每日 5 题（五）

🕗 发布于 2024-07-24 09:54 面试  职场和发展  开发语言  后端  golang  

✍个人博客：Pandaconda-CSDN博客
📣专栏地址：http://t.csdnimg.cn/UWz06

📚专栏简介：在这个专栏中，我将会分享 Golang 面试中常见的面试题给大家~
❤️如果有收获的话，欢迎点赞👍收藏📁，您的支持就是我创作的最大动力💪

 21. Go array 和 slice 的区别？

 1. 数组长度不同

  • 数组初始化必须指定长度，并且长度就是固定的。

  • 切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

 2. 函数传参不同

  • 数组是值类型，将一个数组赋值给另一个数组时，传递的是一份深拷贝，函数传参操作都会复制整个数组数据，会占用额外的内存，函数内对数组元素值的修改，不会修改原数组内容。

  • 切片是引用类型，将一个切片赋值给另一个切片时，传递的是一份浅拷贝，函数传参操作不会拷贝整个切片，只会复制 len 和 cap，底层共用同一个数组，不会占用额外的内存，函数内对数组元素值的修改，会修改原数组内容。

3. 计 算数组长度方式不同

  • 数组需要遍历计算数组长度，时间复杂度为 O(n)。

  • 切片底层包含 len 字段，可以通过 len() 计算切片长度，时间复杂度为 O(1)。

 22. Golang Slice 的底层实现

在 Go 语言中，Slice 是一种基于数组的数据结构，它是一个拥有指向底层数组的指针、长度和容量属性的结构体。Slice 的底层实现是一个动态数组，也就是说，它可以动态地增长和缩小，同时具有数组的许多优点，例如可以进行索引和迭代操作等。

当创建一个 Slice 时，Go 语言会在内存中分配一块连续的内存空间用于存储数据，并返回一个指向该内存区域的指针。该指针称为 Slice 的底层指针。Slice 还会记录该内存区域的长度和容量。

在 Slice 容量不足以存储新的元素时，Go 语言会自动重新分配一块更大的内存区域，并将原有的元素复制到新的内存区域中，然后将新的元素添加到新的内存区域中。这种自动扩容机制使得 Slice 的大小可以根据需要自动调整，无需手动进行内存分配和释放操作，同时也保证了 Slice 的连续性，使得它在访问和遍历元素时具有更好的性能表现。

需要注意的是，由于 Slice 是对底层数组的引用，因此多个 Slice 可以共享同一个底层数组。这种特性使得 Slice 在函数之间传递时非常高效，同时也需要注意避免对 Slice 中的元素进行修改，从而影响到其他共享同一个底层数组的 Slice。

23. G olang Slice 的扩容机制，有什么注意点？

Go 语言中的切片（Slice）具有动态扩容的能力。当切片容量不足以容纳更多元素时，就需要扩容。切片的扩容机制是在原切片容量的基础上扩容，一般是容量的 2 倍或者 1.25 倍，具体扩容的倍数由实现算法决定。以下是关于切片扩容的一些注意点：

  1. 切片扩容会重新分配一块连续的内存空间，因此需要将原切片中的元素复制到新的内存空间中，这个过程可能会比较耗时。

  2. 在使用 append() 函数向切片添加元素时，如果添加的元素个数超出了切片的容量，那么就会触发扩容操作。

  3. 切片扩容会导致原切片和新切片指向不同的内存空间，因此原切片的修改不会影响新切片的值。

  4. 切片扩容并不是每次添加元素都会触发，而是当切片容量不足以容纳更多元素时才会触发。

  5. 当切片容量小于 1024 时，扩容时新的容量会翻倍；当容量大于等于 1024 时，新的容量会增加原来容量的 1/4，也就是乘以 1.25。

  6. 由于切片底层是基于数组实现的，因此切片扩容时，如果原数组的容量不足以容纳新的元素，也会触发数组的重新分配和拷贝。

总之，切片的扩容机制需要注意性能和内存问题，特别是在大规模数据处理中，应该尽量减少切片扩容的次数。

 24. 扩容前后的 Slice 是否相同？

在 Golang 中，扩容前后的 Slice 是不同的。在进行 Slice 扩容时，会创建一个新的底层数组，并将原来的元素拷贝到新的数组中。因此，扩容前后的 Slice 指向的底层数组是不同的。

原因

Golang 中的 Slice 是基于数组实现的，因此在创建 Slice 时，底层会创建一个数组来存储数据。当 Slice 中的元素个数超过底层数组的容量时，就需要进行扩容。而在 Golang 中，数组的大小是固定的，无法进行扩容，因此需要创建一个新的底层数组，并将原来的元素拷贝到新的数组中。这样就可以实现 Slice 的扩容了。由于扩容后底层数组的地址已经发生了变化，因此扩容前后的 Slice 底层数组是不同的，即扩容前后的 Slice 不再共享底层数组。

 25. Go slice 的底层实现原理

切片是基于数组实现的，它的底层是数组，可以理解为对底层数组的抽象。

源码包中 src/runtime/slice.go 定义了 slice 的数据结构：

type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

slice 占用 24 个字节：

  • array: 指向底层数组的指针，占用 8 个字节。

  • len: 切片的长度，占用 8 个字节。

  • cap: 切片的容量，cap 总是大于等于 len 的，占用 8 个字节。

slice 有 4 种初始化方式：

// 初始化方式1：直接声明
var slice1 []int

// 初始化方式2：使用字面量
slice2 := []int{1, 2, 3, 4}

// 初始化方式3：使用make创建slice
slice3 := make([]int, 3, 5)         

// 初始化方式4: 从切片或数组“截取”
slcie4 := arr[1:3]

通过一个简单程序，看下 slice 初始化调用的底层函数。

package main

import "fmt"

func main() {
    slice := make([]int, 0)
    slice = append(slice, 1)
    fmt.Println(slice, len(slice), cap(slice))
}

通过 go tool compile -S test.go | grep CALL 得到汇编代码。

0x0042 00066 (test.go:6)        CALL    runtime.makeslice(SB)
0x006d 00109 (test.go:7)        CALL    runtime.growslice(SB)
0x00a4 00164 (test.go:8)        CALL    runtime.convTslice(SB)
0x00c0 00192 (test.go:8)        CALL    runtime.convT64(SB)
0x00d8 00216 (test.go:8)        CALL    runtime.convT64(SB)
0x0166 00358 ($GOROOT/src/fmt/print.go:274)     CALL    fmt.Fprintln(SB)
0x0180 00384 (test.go:5)        CALL    runtime.morestack_noctxt(SB)
0x0079 00121 (<autogenerated>:1)        CALL    runtime.efaceeq(SB)
0x00a0 00160 (<autogenerated>:1)        CALL    runtime.morestack_noctxt(SB)

初始化 slice 调用的是 runtime.makeslice，makeslice 函数的工作主要就是计算 slice 所需内存大小，然后调用 mallocgc 进行内存的分配。

所需内存大小 = 切片中元素大小 * 切片的容量

func makeslice(et *_type, len, cap int) unsafe.Pointer {
    mem, overflow := math.MulUintptr(et.size, uintptr(cap))
    if overflow || mem > maxAlloc || len < 0 || len > cap {
        // NOTE: Produce a len out of range error instead of a
        // cap out of range error when someone does make([]T, bignumber).
        // cap out of range is true too, but since the cap is only being
        // supplied implicitly, saying len is clearer.
        // See golang.org/issue/4085.
        mem, overflow := math.MulUintptr(et.size, uintptr(len))
        if overflow || mem > maxAlloc || len < 0 {
            panicmakeslicelen()
        }
        panicmakeslicecap()
    }

    return mallocgc(mem, et, true)
}

原文地址：https://blog.csdn.net/Newin2020/article/details/140645589

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

自学内容网
Copyright © 2015-2024