golang array delete

The array in golang is an ordered data structure. Its length is fixed. Once created, its length cannot be changed. Therefore, the operation of deleting array elements in golang is not as flexible as slicing.

So, how to delete elements in an array in golang? First, you need to understand the basic operations of arrays in golang.

1. Array definition

In golang, you can define an array in the following way:

var arr [5]int

In this way, define An int array of length 5 is obtained. Array elements can be initialized in the following way:

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

2. Array traversal

golang The for loop can be used to traverse the array. The code example is as follows:

for i:=0; i

fmt.Println(arr[i])

}

can also be used range keyword, the code example is as follows:

for index, value := range arr {

fmt.Println(index, value)

}

3. Get the array length

in golang The length of the array can be obtained through the len() function. The code example is as follows:

length := len(arr)

Now let’s take a look at how to delete elements in the array.

1. Set array elements to default values

You can set array elements to default values ​​in golang, and the initial value is determined according to the type. Therefore, if you want to delete an element from an array, you only need to set the corresponding element to its default value. For example, delete the 3rd element, the code example is as follows:

var arr [5]int = [5]int{1, 2, 3, 4, 5}
arr[2] = 0
for _, value := range arr {

fmt.Println(value)

}

This will delete the third element, its value is 0, and the output result is: 1 2 0 4 5.

However, this method has a problem, that is, a default value will be left in the array after deletion. If the elements in the array are strings or custom types, their default values ​​may not be what you want.

2. Use slicing to achieve deletion

Slicing in golang is a powerful data structure that can easily delete elements without changing the length of the original array. Therefore, we can use slicing to delete elements from an array.

The specific steps are as follows:

1. Convert the array into a slice

2. Use the append() function to delete the element through the subscript of the element to be deleted in the slice

3. Convert the slice back to an array

The following is the sample code:

var arr [5]int = [5]int{1, 2, 3, 4, 5}
slice := arr[:]
slice = append(slice[:2], slice[3:]...)
for _, value := range slice {

fmt.Println(value)

}

First, convert the array into a slice, then delete the element with index 2 (that is, the 3rd element) in the slice, and then convert the slice back to an array. The output result is: 1 2 4 5.

The method of deleting array elements through slicing can not only delete elements, but also change the position of elements and delete any number of elements. Therefore, in actual development, if you need to frequently add, delete, or modify elements, it is recommended to use slices instead of arrays.

Summary:

In golang, the method of deleting array elements is not as flexible as slicing, but you can use default values ​​or slicing to implement the deletion operation. In actual development, it is recommended to choose an appropriate method based on the actual situation.

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