Warum führt das Verschieben von Elementen in einem Go-Slice zu unerwarteten Ergebnissen?

Elemente innerhalb eines Slice verschieben

In Go erfordert die Manipulation von Slices häufig die Anpassung ihres Inhalts. Eine häufige Operation ist das Verschieben eines Elements von einer Position zu einer anderen innerhalb eines Slice. Ein einfacher Ansatz kann jedoch zu unerwarteten Ergebnissen führen.

Sehen wir uns ein typisches Beispiel an, in dem wir versuchen, ein Element von der Position indexToRemove nach indexWhereToInsert zu verschieben:

<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>

Dieser Code erzeugt die Ausgabe:

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]

Wir erwarten jedoch die folgende Ausgabe:

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]

Identifizierung des Problems

Das Problem ergibt sich aus der Art und Weise, wie wir Elemente verschieben. Im Beispiel entfernen wir zunächst das Element bei indexToRemove und fügen es dann bei indexWhereToInsert ein. Die zweite Operation ändert jedoch die Indizes der Elemente nach indexWhereToInsert. Dadurch wird das ursprünglich bei indexWhereToInsert befindliche Element nach dem entfernten Element eingefügt.

Benutzerdefinierte Funktionen zum Verschieben von Elementen

Um dieses Problem zu beheben, können wir benutzerdefinierte Funktionen zum Entfernen und Einfügen von Elementen innerhalb eines erstellen Scheibe. Diese Funktionen verarbeiten Indexanpassungen intern:

<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>

Verwendungsbeispiel:

<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>

Ausgabe:

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]

Das obige ist der detaillierte Inhalt vonWarum führt das Verschieben von Elementen in einem Go-Slice zu unerwarteten Ergebnissen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!