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

DDD
Release: 2024-11-02 10:07:02
Original
152 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!

source:php.cn
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template
About us Disclaimer Sitemap
php.cn:Public welfare online PHP training,Help PHP learners grow quickly!