golang array delete

Golang is a strongly typed language, and its arrays are of fixed length, which means that the length of the array must be specified when it is declared, and the length of the array cannot be changed in subsequent use. This may be very inconvenient for some scenarios. For example, we need to delete an element from an array, but we must ensure that the length of the array remains unchanged.

In this case, we can use some techniques to achieve the element deletion operation of the array. This article will introduce two common Golang array deletion techniques.

1. Use slice interception operation to delete elements

Slice is a reference type, which can contain any type of elements and can grow and shrink dynamically. Through the interception operation of slices, we can easily delete elements in a Golang array. The specific operation steps are as follows:

1. Define a Golang array

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

2. Define the subscript of an element to be deleted

index := 2

3. Use the slicing interception operation to delete the element with the specified subscript

arr = append(arr[:index], arr[index+1:]...)

In this example, we first define A Golang array arr containing 5 elements. Then we defined the subscript index of the element to be deleted. Here we selected the third element for deletion. Next, we use the slicing interception operation to intercept the original array into two new arrays and merge them into a new array arr. At this time, the third element has been deleted.

The complete code is as follows:

package main

import "fmt"

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

The execution result is:

[1 2 4 5]

We can see that the third element has been successfully deleted.

2. Use the slice reversal operation to delete elements

In addition to using the slice interception operation, we can also delete elements in the Golang array through the slice reversal operation. The specific steps are as follows:

1. Define a Golang array

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

2. Define the subscript of an element to be deleted

index := 2

3. Reverse the array

for i, j := 0, len(arr)-1; i < j; i, j = i+1, j-1 {
    arr[i], arr[j] = arr[j], arr[i]
}

4. Use the slice interception operation to delete the element with the specified subscript

arr = arr[:len(arr)-1]

5. Reverse the array again

for i, j := 0, len(arr)-1; i < j; i, j = i+1, j-1 {
    arr[i], arr[j] = arr[j], arr[i]
}

What needs to be noted here is that in steps 3 and 5, we use the multiple assignment statement in Golang, which can exchange the values ​​​​of two variables at once. If we directly use arr[i] and arr[j] to exchange their values, the code will be more cumbersome.

The complete code is as follows:

package main

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    index := 2
    for i, j := 0, len(arr)-1; i < j; i, j = i+1, j-1 {
        arr[i], arr[j] = arr[j], arr[i]
    }
    arr = arr[:len(arr)-1]
    for i, j := 0, len(arr)-1; i < j; i, j = i+1, j-1 {
        arr[i], arr[j] = arr[j], arr[i]
    }
    fmt.Println(arr)
}

The execution result is:

[1 2 4 5]

We can also see that the third element has been successfully deleted.

Summary

Through this article we learned that although Golang arrays are of fixed length, we can still use some techniques to achieve element deletion operations, such as using slice interception operations and slice reversal operate. However, it should be noted that since the length of the array is fixed, these operations will generate additional overhead, so frequent deletion operations should be avoided in actual use to ensure program performance.

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