How to delete elements in array in Golang

Golang can delete elements in an array by creating a new slice. Detailed introduction: 1. Determine whether the index is out of bounds; 2. Create a new slice; 3. Copy the data after the deleted element to the new slice; 4. Create an array; 5. Delete the element with index 2; 6. Output the result That’s it.

The operating system for this tutorial: Windows 10 system, Go version 1.21, DELL G3 computer.

In the Go language, an array is a fixed-length data structure. Its length is determined when it is created and cannot be changed. Since arrays are of immutable length, deleting elements from an array is not as straightforward as with other dynamic data structures. But we can achieve effects like deleting elements in other ways.

A common method is to use slices. A slice is a dynamic array in the Go language that can automatically expand or shrink as needed. By creating a new slice, we can delete elements from the array.

Here is a sample code that demonstrates how to delete elements in an array:

func deleteElement(arr []int, index int) []int {
// 判断索引是否越界
if index < 0 || index >= len(arr) {
return arr
}
// 创建一个新的切片
result := make([]int, len(arr)-1)
// 拷贝删除元素后的数据到新的切片
copy(result[:index], arr[:index])
copy(result[index:], arr[index+1:])
return result
}
func main() {
// 创建一个数组
arr := []int{1, 2, 3, 4, 5}
// 删除索引为2的元素
newArr := deleteElement(arr, 2)
fmt.Println(newArr) // 输出：[1 2 4 5]
}

In the above sample code, we have defined a deleteElement function that accepts a slice and the element to be deleted takes the index of the element as argument and returns a new slice. First, we determine whether the index is out of bounds, and if so, return the original slice directly. Then, we create a new slice result with the length of the original slice minus 1. Next, we use the copy function to copy the data after deleting the element to a new slice, and achieve the effect of deleting the element by specifying the appropriate index range. Finally, we return the new slice as the result.

It should be noted that deleting elements in this way does not change the length of the original array or slice, but returns a new slice. If you need to modify the original array or slice, pass it as a pointer argument to the delete function.

In addition to using slices, you can also use other data structures to delete elements in the array, such as using linked lists or using mark deletion. The specific implementation depends on actual needs and usage scenarios.

In summary, although the array length of Go language is immutable, effects similar to deleting elements can be achieved through slicing and other methods. By creating a new slice and copying the elements that need to be retained to the new slice, you can delete elements in the array.

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