In-depth analysis of how Go language slicing works

As a fast and efficient programming language, Go language has naturally attracted the love of many developers. Among them, slice is one of the most commonly used data structures in Go language. It is flexible and efficient and is widely used to store dynamic length data collections. This article will provide an in-depth analysis of how Go language slicing works and explain it through specific code examples.

1. Definition and declaration of slices

In the Go language, a slice is a lightweight data structure consisting of three parts: a pointer to the underlying array, the length of the slice, and The capacity of the slice. The declaration form of a slice is:

var slice []int

Or use the make function to create a slice:

slice := make([]int, 0, 5)

Among them, the first parameter of the make function is the type of the slice, and the second parameter is the length of the slice. The third parameter is the capacity of the slice.

2. The underlying array of the slice

The underlying array of the slice is the actual data storage space referenced by the slice. When the slice is created, a continuous memory space will be automatically allocated for storing data. . When a slice performs an append operation, if the new data exceeds the capacity of the slice, the system will automatically allocate a larger underlying array and copy the original data to the new underlying array.

slice1 := make([]int, 3, 5)
slice2 := append(slice1, 4)

In the above code, the length of the underlying array of slice slice1 is 5 and the capacity is 5. When the append operation is performed, the system will automatically reallocate an underlying array and copy the original data to the new underlying array. In the array, the underlying array referenced by slice slice2 has a length of 6 and a capacity of 10.

3. How slicing works

The working principle of slicing can be illustrated by the following code example:

package main

import "fmt"

func main() {
    array := [5]int{1, 2, 3, 4, 5}
    slice := array[1:3] // 切片包含array[1]和array[2]

    fmt.Printf("数组array：%v
", array)
    fmt.Printf("切片slice：%v
", slice)
    fmt.Printf("切片长度：%d
", len(slice))
    fmt.Printf("切片容量：%d
", cap(slice))
}

The running results are as follows:

数组array：[1 2 3 4 5]
切片slice：[2 3]
切片长度：2
切片容量：4

From As can be seen from the results, the slice contains elements with indexes 1 and 2 in the array, with a length of 2 and a capacity of 4. The length of the slice represents the number of elements actually stored in the slice, and the capacity represents the number of elements in the slice from the current position to the end of the underlying array.

4. Characteristics of slices

Slices are reference types, and operations on slices will affect the underlying array and other slices. When multiple slices jointly reference an underlying array, if the elements of one slice change, other slices sharing the underlying array will also be affected.

package main

import "fmt"

func main() {
    array := [3]int{1, 2, 3}
    slice1 := array[:] // slice1引用整个数组
    slice2 := array[1:] // slice2引用数组从索引1开始的子数组

    slice1[0] = 100
    fmt.Println(array) // [100 2 3]
    fmt.Println(slice2) // [2 3]
}

In the above code, modifying the first element of slice1 to 100 will cause the first element of the underlying array to also be modified. Because slice2 shares the underlying array, slice2 is also affected.

5. Slice expansion mechanism

When the capacity of the slice is insufficient to store new data, the system will automatically allocate a larger capacity to the slice. Under normal circumstances, the new capacity is twice the original capacity, but if the original capacity is less than 1024, the new capacity is 1.25 times the original capacity.

slice := make([]int, 3, 5)
fmt.Printf("切片长度：%d
", len(slice)) // 切片长度：3
fmt.Printf("切片容量：%d
", cap(slice)) // 切片容量：5

slice = append(slice, 4)
fmt.Printf("切片长度：%d
", len(slice)) // 切片长度：4
fmt.Printf("切片容量：%d
", cap(slice)) // 切片容量：5

In the above code, the slice length is 3 and the capacity is 5. When the append operation is performed, because the capacity is sufficient, the slice will not reallocate the underlying array, the length increases to 4, and the capacity remains 5.

6. Summary

Through the above code examples and analysis, we have an in-depth understanding of the working principle of Go language slicing. As a flexible and efficient data structure, slicing plays an important role in the development of Go language. Developers should be familiar with the characteristics and working principles of slicing in order to better utilize slicing to improve code efficiency.

I hope this article can help readers have a deeper understanding of Go language slicing. Readers are also welcome to further deepen their understanding and application of slicing through practice and exploration.

The above is the detailed content of In-depth analysis of how Go language slicing works. For more information, please follow other related articles on the PHP Chinese website!