golang remove array

In the Go language, an array is a fixed-length data structure. Once created, its length cannot be changed. But in some cases, we need to dynamically increase or decrease the elements in the array. What should we do at this time? In fact, the Go language provides some methods to remove elements from an array. This article will introduce several of them.

1. Using slices

Slice is a dynamic array in Go language, which is obtained by cutting the array. Although the underlying layer of a slice is an array, its length is not fixed and elements can be dynamically added or reduced as needed. Therefore, using slicing to remove elements from an array is a common approach.

We can use the slice's built-in function append() to remove elements from the array. Suppose you want to remove the idxth element of the array arr. You can first slice the array into two parts, take the element to be deleted from the array, and then splice the two parts. up, and finally save the result to the original array.

The following is a sample code:

func removeItem(arr []int, idx int) []int {
    return append(arr[:idx], arr[idx+1:]...)
}

arr := []int{1, 2, 3, 4, 5}
idx := 2
arr = removeItem(arr, idx)
fmt.Println(arr) // [1 2 4 5]

In this code, we use the built-in function append() to remove the idx element from the slice Remove. After removal, a new slice is returned. This slice divides the original array arr into two parts, namely arr[:idx] and arr[idx 1 :]. The two parts are then connected through the append() function, and the final result is a new array after removing the elements from the original array.

2. Use the whitespace character

Another way to remove array elements is to use the whitespace character in the Go language. The whitespace character is actually a special identifier used to indicate that when we receive the value returned by a function, we do not need to actually use the return value. Using the whitespace character in an array can set an element in the array to empty to achieve the effect of removal.

The example is as follows:

arr := []int{1, 2, 3, 4, 5}
idx := 2
arr[idx] = arr[len(arr)-1]
arr[len(arr)-1] = 0
arr = arr[:len(arr)-1]
fmt.Println(arr) // [1 2 4 5]

Use whitespace here 0 to set the element with index len(arr)-1 to empty, and This empty element is removed from the end of the array, thereby achieving the effect of removing the element.

It should be noted that although this method can remove elements, it will not change the length of the array, so we need to be particularly careful in subsequent operations.

3. Use the copy function

Built-in function of Go languagecopy() You can copy one slice to another slice, or you can copy part of an array. to another part of the same array. Therefore, we can use the copy() function to remove elements from the array.

The example is as follows:

arr := []int{1, 2, 3, 4, 5}
idx := 2
copy(arr[idx:], arr[idx+1:])
arr[len(arr)-1] = 0
arr = arr[:len(arr)-1]
fmt.Println(arr) // [1 2 4 5]

In this code, we first use the copy() function to remove the elements starting from arr[idx 1:] Copy it to arr[idx:], thereby removing the idx element. Then set the last element in the array to empty, and finally delete the empty element through slicing.

It should be noted that because the array is a value type, not a reference type, we need to use slicing to copy the array, and then save the result to the original array after modification.

4. Use loops

The last way to remove array elements is to use loops. We can remove the element by moving it backward through a loop.

The example is as follows:

arr := []int{1, 2, 3, 4, 5}
idx := 2
for i := idx + 1; i < len(arr); i++ {
    arr[i-1] = arr[i]
}
arr = arr[:len(arr)-1]
fmt.Println(arr) // [1 2 4 5]

Here, it loops through each element after the element that needs to be deleted, moves it forward one position, and finally deletes the redundant elements. This method is more cumbersome, but it is also very practical.

Summary

Removing array elements is a basic operation in the Go language. The Go language provides a variety of convenient and efficient methods to implement this operation. You can easily remove elements from an array, whether using slicing, whitespace, the copy function, or using a loop. According to the actual situation, we can choose the most appropriate method to achieve the purpose.

The above is the detailed content of golang remove array. For more information, please follow other related articles on the PHP Chinese website!