Summarize some common golang Slice operations

In Go language, Slice is a very common data type. Compared with array (Array), Slice is more flexible and more convenient in actual development. Next we will discuss how to use Slice in Go language.

First of all, some basic concepts of Slice and Array need to be understood clearly. In the Go language, an array is a fixed-size data structure, while a Slice is a dynamically changing sequence. In addition, the underlying layer of Slice is implemented by arrays. The structure of Slice is as follows:

type slice struct {
    array unsafe.Pointer // 指向底层数组的指针
    len   int            // slice 的长度（元素数量）
    cap   int            // slice 的容量
}

Slice can be created through the make function, and its syntax is as follows:

slices := make([]T, len, cap)

Among them, T can be any type, len represents the length of Slice, and cap represents the capacity of Slice . It should be noted that the created Slice is a pointer to the underlying array, so when the Slice is modified, it will affect the underlying array.

Data access in Slice is similar to arrays, and subscripts can be used to access elements. For example:

slices := []string{"Apple", "Banana", "Orange", "Grape"}

fmt.Println(slices[0]) // Apple

fmt.Println(slices[1:3]) // [Banana Orange]

It should be noted that Slice can be sliced ​​(Slice) and return a new Slice. For example: slices[1:3] is the new Slice from 1 to 3.

Next, let’s take a look at some operations of Slice.

1. append

Append elements to the end of Slice. The append function has two return values, the first is the appended Slice, and the second is whether memory needs to be reallocated. For example:

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

slices = append(slices, 6)

fmt.Println(slices) // [1 2 3 4 5 6]

It should be noted that when the Slice capacity is insufficient, append will reallocate memory.

2. Delete elements

Use the append function and slice operation to delete elements in Slice. For example:

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

slices = append(slices[:2], slices[3:]...)

fmt.Println(slices) // [1 2 4 5]

The operation of the above code is to delete 3 from Slice.

3. len and cap

The length and capacity of Slice can be obtained through the len and cap functions. For example:

slices := make([]int, 3, 5)

fmt.Println(len(slices)) // 3

fmt.Println(cap(slices)) // 5

It should be noted that when adding elements to Slice, if the capacity is insufficient, the length of Slice will automatically increase until the capacity is sufficient.

4. copy

Copy elements from one Slice to another Slice. Note that in order to prevent the original elements from being overwritten, sufficient space needs to be allocated first. For example:

a := []int{1, 2, 3}

b := make([]int, len(a))

copy(b, a)

fmt.Println(b) // [1 2 3]

It should be noted that if the length of the target Slice is smaller than the source Slice, only the length elements of the target Slice will be copied.

The above are some common Slice operations. It should be noted that since Slice is actually a pointer to the underlying array, you need to be careful when operating Slice to avoid modifying the data of the underlying array. In addition, the length of Slice can be changed, which is more flexible and convenient than arrays.

The above is the detailed content of Summarize some common golang Slice operations. For more information, please follow other related articles on the PHP Chinese website!