关于go中切片的基础知识

朱雀 2024-02-17 09:57 1阅读 0赞

###### 切片什么情况下需要扩容？ ######

1.  追加元素： 当向切片中追加元素时，如果此时 切片长度达到了容量上限，就需要进行扩容。
2.  将切片作为参数传递：当将切片作为参数传递给函数时，如果函数内部需要修改切片，并且修改后的切片长度超过了元切片的容量，就需要扩容。
    
        package main
        
        import "fmt"
        
        func main() {
              
            numbers := []int{
              1, 2, 3}
            fmt.Println("初始切片:", numbers)
        
            // 调用函数修改切片长度
            resizeSlice(numbers, 5)
        }
        
        func resizeSlice(slice []int, newLength int) {
              
            if newLength > cap(slice) {
              
                // 创建一个新的切片，并将原切片的元素复制到新切片
                newSlice := make([]int, newLength)
                copy(newSlice, slice)
                slice = newSlice
            } else {
              
                // 对原切片进行截取，修改长度
                slice = slice[:newLength]
            }
        
            fmt.Println("修改后的切片:", slice)
        }

###### 扩容很好吗？ ######

尽管切片可以自动扩容，但是频繁的扩容很可能带来一些潜在的性能问题 和 内存管理方面的开销。

比如：内存的分配，数据需要复制，原内存需要回收。（当扩容后长度超过容量时）

在切片扩容时，Go 运行时会创建一个新的底层数组，并将原有的元素复制到新的底层数组中，然后将切片指向新的底层数组。

这种复制过程是通过 `copy()` 函数实现的，它将原有的元素逐个复制到新的底层数组中。这样，扩容后的切片将引用新的底层数组，而之前的底层数组会被垃圾回收。

如果扩容后，长度没有超出容量，则就在原来底层数组的基础上增加数据。

如果扩容后，长度超出容量，就需要形成一个新的底层数组，然后将原底层数组的数据复制过来。

###### 怎么扩容？ ######

1.如果切片的容量小于1024，那么在扩容时，新的切片容量会变为原容量的两倍。

2.如果切片的容量大于等于1024，那么在扩容时，新的切片容量会增加原容量的25%。

1024 是一个常量，它表示一个固定的阈值。是Go语言运行时库中定义的一个常量，用于切片的自动扩容策略。具体的值可能因不同的Go版本或编译设置而有所变化。

###### 切片的使用 ######

用make创建一个切片

var s []int
    s = make([]int, 3, 5) // 创建一个长度为3， 容量为5的空间

如果不写明容量，则容量等于长度

由系统自动创建底层数组

s := []int{
        1,2,3,4}

len()  // 查看切片长度
    cap()  // 查看切片容量
    
    append()  // 为切片追加元素
    copy()   //  复制切片

###### 共享底层数组 ######

func main() {
        
    
    	nums := [...]string{
         "one",  "two" , "three","four","five","six","seven","eight"};
    
    	a := nums[1:3]; // 取 two 和 three
    	b := nums[2:4]; // 取 three 和 four
    
    	a[1] = "新的"
    
    	fmt.Println(a)  // 输出 two , 新的
    	fmt.Println(b)	// 输出 新的 , four
    
    }

######  ######

###### 切片和数组有什么区别？ ######

###### 声明和初始化 ######

数组是同一种数据类型元素的集合，数组在定义时需要指定长度和元素类型。

func main() {
        
        var nums [3]int   // 声明并初始化为默认零值
        var nums1 = [4]int{
        1, 2, 3, 4}  // 声明同时初始化
        var nums2 = [...]int{
        1, 2, 3, 4, 5} // ...可以表示后面初始化值的长度
        fmt.Println(nums)    // [0 0 0]
        fmt.Println(nums1)   // [1 2 3 4]
        fmt.Println(nums2)   // [1 2 3 4 5]
    }

切片 则是一种引用类型，包含三个属性：指针，长度和容量。

1.  指针：指向 slice 可以访问到的第一个元素。
2.  长度：slice 中元素个数。
3.  容量：slice 起始元素到底层数组最后一个元素间的元素个数。

func main() {
        
        var nums []int  // 声明切片
        fmt.Println(len(nums), cap(nums)) // 0 0
        nums = append(nums, 1)   // 初始化
        fmt.Println(len(nums), cap(nums)) // 1 1
    
        nums1 := []int{
        1,2,3,4}    // 声明并初始化
        fmt.Println(len(nums1), cap(nums1))    // 4 4
    
        nums2 := make([]int,3,5)   // 使用make()函数构造切片
        fmt.Println(len(nums2), cap(nums2))    // 3 5
    }

###### 函数参数 ######

当数组作为函数的参数时，实际是将数组复制了一份然后传递作为参数，传递给了函数，所以在函数内部修改数组参数的时候，不会影响原来数组的数据。

当切片作为函数的参数时，因为切片本就是指定了底层数组，数据都在底层数据，所以 函数接收切片当参数时，指针还是传递给了底层数组，所以对切片的任何操作，都会在底层数组实现，所以 函数中对切片的修改，都会影响原切片数据。

import (
        "fmt"
    )
    
    func Add(numbers []int) {
        
        for i := 0; i < len(numbers); i++ {
        
            numbers[i] = numbers[i] + 1
        }
        fmt.Println("numbers in Add:", numbers) // [2 3 4 5 6]
    }
    
    func main() {
        
        var numbers []int
        for i := 0; i < 5; i++ {
        
            numbers = append(numbers, i+1)
        }
        Add(numbers)
        fmt.Println("numbers in main:", numbers) // [2 3 4 5 6]
    }