How to delete elements using Golang's range

Go language is an open source programming language that supports high concurrency and high-performance programming. Many companies have begun to use and support this language. Among them, Golang has attracted much attention due to its concise syntax, high code readability, and fast execution speed.

In Golang, range is a very important keyword, which can be used to process collection type data such as arrays, slices, strings, and maps. We usually use the range keyword to traverse these collection types of data. However, when we need to modify the elements in the collection while using range, we encounter a problem: using range during loop iteration will cause the iterator to become invalid, thus causing a series of problems. This article will introduce in detail how to use Golang's range to delete elements.

First, look at a simple example:

package main

import (
    "fmt"
)

func main() {
    nums := []int{1, 2, 3, 4, 5}
    for idx, val := range nums {
        if (idx == 2) {
            nums = append(nums[:idx], nums[idx+1:]...)
        }
        fmt.Println("val:", val)
    }
    fmt.Println("nums:", nums)
}

The output after running is as follows:

val: 1
val: 2
val: 4
val: 5
nums: [1 2 4 5]

We will find that in the process of traversing the array, use the range keyword and When modifying the slice size, some elements are actually not traversed. This is because during the traversal process, the expression nums[:idx] is used, which actually changes the length of nums, and the iterator fails to successfully obtain the current length of the slice, which causes some problems.

To get around this problem, we can use two loop variables to iterate over the slices. The first variable is used to iterate over the slice elements, and the second variable is used to save the current iteration position. Then we can process all the elements inside the loop, and finally delete all the elements that need to be deleted at once. As in the following example:

package main

import "fmt"

func main() {
    nums := []int{1, 2, 3, 4, 5}
    var newNums []int
    var keepIdx []int
    for idx, val := range nums {
        if val%2 == 0 {
            keepIdx = append(keepIdx, idx)
        }
        newNums = append(newNums, val)
    }
    for i := len(keepIdx) - 1; i >= 0; i-- {
        newNums = append(newNums[:keepIdx[i]], newNums[keepIdx[i]+1:]...)
    }
    fmt.Println(newNums) // [1 3 5]
}

In this example, we create two new variables newNums and keepIdx to save the new slice and the index of the element to be retained. In the first loop, we add all elements to the new slice and add the index of the element that needs to be kept to the keepIdx array. In the second loop, we add all elements to the newNums slice except the elements that need to be removed.

Finally, when we use range to delete collection elements, we need to pay special attention not to allow the collection size to change during the iteration process. We can first traverse all elements, record the subscripts of the elements that need to be deleted, and then delete these elements at once. This avoids index and element mismatch problems caused by the iterative process.

In summary, the method of using Golang's range to delete elements is nothing more than two points: one is to avoid modifying the collection size during the iteration process, and the other is to be particularly careful about modifying elements, which may cause the iterator to fail. If we can use these two points skillfully, then using range to delete elements will become easy.

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