How to delete slice elements in Golang

In Golang, slices are a more flexible array that can support dynamic addition or deletion of elements. Commonly used deletion methods are to overwrite unnecessary elements through the "append" function or to copy elements that need to be retained to a new slice through the "copy" function. This article mainly introduces how to delete slice elements in Golang.

1. Use the append function to delete slice elements

In Golang, an element can be appended to a slice through the "append" function. If an empty slice and a non-empty slice are combined Append, you will get a new slice, which will contain the original elements and the appended elements. We can use this feature to delete an element in the slice.

First, suppose we have an integer slice "slice" and we need to delete an element in it. You can consider using the following code:

func Remove(slice []int, index int) []int {
    return append(slice[:index], slice[index+1:]...)
}

func main() {
    slice := []int{1, 2, 3, 4, 5}
    index := 2
    slice = Remove(slice, index)
    fmt.Println(slice)
}

In the above code, the parameters of the Remove function It includes an integer slice "slice" and an index value "index", indicating the position of the element to be deleted in the slice. Next, we use the characteristics of the "append" function to implement the deletion operation: first, the first half of the "slice" slice (from 0 to "index"-1) and the second half (from "index" 1 to the end of the slice) Join together and return a new slice as the final result. By assigning this new slice to "slice", the deletion operation is implemented.

It should be noted that in the above code, we use "slice[:]" to indicate taking the entire slice. This is because the slice in Golang is implemented based on the underlying array, and the "underlying array" of the slice points to The original underlying array. Therefore, when performing slicing operations, we need to ensure that the capacity of the slice is sufficient to avoid errors such as "slice bounds out of range".

2. Use the copy function to delete slice elements

In addition to using the "append" function, we can also use the "copy" function to delete an element in the slice. Different from the "append" function, using the "copy" function requires first creating a target slice to receive the deleted results. The following is a sample code for a delete operation implemented using the "copy" function:

func Remove2(slice []int, index int) []int {
    result := make([]int, len(slice)-1)
    copy(result, slice[:index])
    copy(result[index:], slice[index+1:])
    return result
}

func main() {
    slice := []int{1, 2, 3, 4, 5}
    index := 2
    slice = Remove2(slice, index)
    fmt.Println(slice)
}

In the above code, we use the "make" function to create a new target slice "result" whose length is the original slice " slice" length is reduced by 1, then copy the first "index" elements of the original slice to the front of the target slice, and then copy the remaining elements of the original slice to the back of the target slice. Finally, the new "result" slice is returned as the result after deletion.

Summary: In Golang, deleting an element in a slice can be achieved through the "append" and "copy" functions. It is easier to use the "append" function, but you need to ensure that the capacity of the slice is sufficient first. Although using the "copy" function requires creating a new target slice, it is relatively simple to implement. In actual development, different implementation methods can be selected according to specific needs.

The above is the detailed content of How to delete slice elements in Golang. For more information, please follow other related articles on the PHP Chinese website!