In Go language, why does the original slice change after the slice is cropped? How to correctly insert elements into slices?

Go Slicing: Cropping and Inserting Traps and the Right Method

This article explores the potential problems of slice cropping and modification operations in Go language, and how to safely insert elements into slices. Go slices are not independent data structures, but views of the underlying array, so improper operation can lead to unexpected side effects.

Trap of slice cropping: Sharing the underlying array

Consider the following code:

 package main

import "fmt"

func main() {
    original := []int{1, 2, 4, 5}

    sliceA := original[:2] // Slice[1, 2]
    sliceB := original[2:] // Slice[4, 5]

    fmt.Println("Original:", original)
    fmt.Println("Slice A:", sliceA)
    fmt.Println("Slice B:", sliceB)

    sliceA = append(sliceA, 3) // Append element to sliceA fmt.Println("Original (after append):", original)
    fmt.Println("Slice A (after append):", sliceA)
    fmt.Println("Slice B (after append):", sliceB)
}

The output results show that original and sliceB have also changed, because sliceA and original share the same underlying array. When the append operation does not cause the underlying array to be reassigned (for example, sufficient capacity), modifying sliceA directly affects other slices that share the array.

Avoid the trap: Copy the underlying array

To avoid modifying the original slice, you need to copy the underlying array before the operation:

 package main

import "fmt"
import "copy"

func main() {
    original := []int{1, 2, 4, 5}

    sliceA := make([]int, len(original[:2])) // Create a new slice and copy the data copy(sliceA, original[:2])

    sliceB := original[2:]

    fmt.Println("Original:", original)
    fmt.Println("Slice A:", sliceA)
    fmt.Println("Slice B:", sliceB)

    sliceA = append(sliceA, 3)

    fmt.Println("Original (after append):", original)
    fmt.Println("Slice A (after append):", sliceA)
    fmt.Println("Slice B (after append):", sliceB)
}

This time, original and sliceB remain unchanged because sliceA has independent underlying arrays.

The correct way to insert elements in slices

Inserting elements into slices also requires avoiding directly modifying the underlying array. The correct way to do this is to create a new slice and add the elements that need to be inserted to the correct location:

 package main

import "fmt"
import "copy"

func insert(s []int, index int, value int) []int {
    newSlice := make([]int, len(s) 1)
    copy(newSlice[:index], s[:index])
    newSlice[index] = value
    copy(newSlice[index 1:], s[index:])
    return newSlice
}

func main() {
    slice := []int{1, 2, 4, 5}
    insertedSlice := insert(slice, 2, 3)
    fmt.Println("Original slice:", slice)
    fmt.Println("Slice after insertion:", insertedSlice)
}

This insert function creates a new slice and inserts the element into the specified location. The original slice slice remains the same.

Summarize

The characteristics of Go slicing determine that its cropping and modification operations may affect other slices that share the same underlying array. To avoid unexpected results, be sure to pay attention to copying the underlying array or using the method of creating new slices before performing these operations to ensure the security of the operations.

The above is the detailed content of In Go language, why does the original slice change after the slice is cropped? How to correctly insert elements into slices?. For more information, please follow other related articles on the PHP Chinese website!