Why Does Shifting Elements in a Go Slice Cause Unexpected Results?-Golang-php.cn

Why Does Shifting Elements in a Go Slice Cause Unexpected Results?

DDD

Release： 2024-11-02 10:07:02

Original

312 people have browsed it

Why Does Shifting Elements in a Go Slice Cause Unexpected Results?

Shifting Elements within a Slice

In Go, manipulating slices often involves adjusting their contents. One common operation is moving an element from one position to another within a slice. However, a straightforward approach may lead to unexpected results.

Let's examine a typical example where we attempt to move an element from position indexToRemove to indexWhereToInsert:

<code class="go">indexToRemove := 1
indexWhereToInsert := 4

slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

slice = append(slice[:indexToRemove], slice[indexToRemove+1:]...)
fmt.Println("slice:", slice)

newSlice := append(slice[:indexWhereToInsert], 1)
fmt.Println("newSlice:", newSlice)

slice = append(newSlice, slice[indexWhereToInsert:]...)
fmt.Println("slice:", slice)</code>

Copy after login

This code produces the output:

slice: [0 2 3 4 5 6 7 8 9]
newSlice: [0 2 3 4 1]
slice: [0 2 3 4 1 1 6 7 8 9]

Copy after login

However, we expect the following output:

slice: [0 2 3 4 5 6 7 8 9]
newSlice: [0 2 3 4 1]
slice: [0 2 3 4 1 5 6 7 8 9]

Copy after login

Identifying the Issue

The issue arises from the way we shift elements. In the example, we first remove the element at indexToRemove and then insert it at indexWhereToInsert. However, the second operation modifies the indices of the elements after indexWhereToInsert. As a result, the element originally at indexWhereToInsert is inserted after the removed element.

Custom Functions for Shifting Elements

To address this issue, we can create custom functions for removing and inserting elements within a slice. These functions handle index adjustments internally:

<code class="go">func insertInt(array []int, value int, index int) []int {
    return append(array[:index], append([]int{value}, array[index:]...)...)
}

func removeInt(array []int, index int) []int {
    return append(array[:index], array[index+1:]...)
}

func moveInt(array []int, srcIndex int, dstIndex int) []int {
    value := array[srcIndex]
    return insertInt(removeInt(array, srcIndex), value, dstIndex)
}</code>

Copy after login

Usage example:

<code class="go">func main() {
    slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

    fmt.Println("slice: ", slice)

    slice = insertInt(slice, 2, 5)
    fmt.Println("slice: ", slice)

    slice = removeInt(slice, 5)
    fmt.Println("slice: ", slice)

    slice = moveInt(slice, 1, 4)
    fmt.Println("slice: ", slice)
}</code>

Copy after login

Output:

slice:  [0 1 2 3 4 5 6 7 8 9]
slice:  [0 1 2 3 4 2 5 6 7 8 9]
slice:  [0 1 2 3 4 5 6 7 8 9]
slice:  [0 2 3 4 1 5 6 7 8 9]

Copy after login

The above is the detailed content of Why Does Shifting Elements in a Go Slice Cause Unexpected Results?. For more information, please follow other related articles on the PHP Chinese website!