golang slice modification value

Golang is a statically typed programming language that supports data structures such as arrays and slices. In Golang, a slice is a variable-length sequence, similar to a dynamic array. It is more flexible than an array and can grow or shrink in size at runtime without having to specify the size in advance.

When using slices, we often need to modify the elements of the slice. This article will detail how to modify the value of a slice in Golang.

Declaring and initializing slices

In Golang, you can use the following methods to declare and initialize slice variables:

// 声明一个切片
var slice []int

// 声明并初始化一个切片
slice := []int{1, 2, 3}

// 创建一个长度为5的切片
slice := make([]int, 5)

// 创建一个长度为5，容量为10的切片
slice := make([]int, 5, 10)

As you can see, creating a slice in Golang is very simple . The length and capacity of the slice created using the first two methods are both 3, that is, the initial number of elements is 3. Using the make function you can create slices of specified length and capacity.

Modify the value of the slice

In Golang, the elements of the slice can be accessed by index. For example, to access the first element of a slice, you can use the following code:

slice := []int{1, 2, 3}
fmt.Println(slice[0]) // 输出1

If you want to modify the value of the slice, you can do it by index:

slice := []int{1, 2, 3}
slice[0] = 4
fmt.Println(slice) // 输出[4 2 3]

As you can see, we use the index method modifies the first element of the slice and updates it to 4.

If you want to modify multiple elements at the same time, you can use for to loop through the slice and then modify each element:

slice := []int{1, 2, 3}
for i := 0; i < len(slice); i++ {
   slice[i] = slice[i] * 2
}
fmt.Println(slice) // 输出[2 4 6]

Here we multiply each element to 2, and then output the modified slice.

Reference type characteristics of slices

In Golang, slices are reference types, not value types. This means that when we pass a slice as an argument to a function, the function will directly operate on the original slice instead of creating a copy of it.

The following is an example:

func modifySlice(slice []int) {
    slice[0] = 10
}

func main() {
    slice := []int{1, 2, 3}
    fmt.Println(slice) // 输出[1 2 3]
    modifySlice(slice)
    fmt.Println(slice) // 输出[10 2 3]
}

In this example, we define the modifySlice function to modify the first element of the slice. We first print the original slice, then call the modifySlice function to modify the value of the slice, and print the slice again.

Note that when we pass the slice parameter, the function modifies the first element of the original slice. This is because slices are reference types, and we are passing the address of the original slice, not a copy.

Append function of slice

In Golang, we can use the append function to add new elements to the slice. appendThe function returns a new slice without modifying the original slice.

Here is an example of adding an element to a slice using the append function:

slice := []int{1, 2, 3}
slice = append(slice, 4)
fmt.Println(slice) // 输出[1 2 3 4]

In this example, we use the append function to append the value 4 Add to end of slice. Note that we assign the return value of the append function to the original slice. This is because the append function returns a new slice instead of modifying the original slice.

In addition to adding a new element to the slice, the append function can also add multiple elements:

slice := []int{1, 2, 3}
newSlice := []int{4, 5, 6}
slice = append(slice, newSlice...)
fmt.Println(slice) // 输出[1 2 3 4 5 6]

In this example, we use ... The operator passes newSlice to the append function. This tells the compiler to add all elements in newSlice to the end of the slice slice.

Shared underlying array characteristics of slices

In Golang, slices can share the same underlying array. This means that if two slices share the same underlying array, when one slice is modified, the value of the other slice will also change.

The following is an example of modification using a shared underlying array:

slice := []int{1, 2, 3}
newSlice := slice[1:3]
newSlice[0] = 4
fmt.Println(slice)    // 输出[1 4 3]
fmt.Println(newSlice) // 输出[4 3]

In this example, we create a new slice newSlice, which is derived from the original sliceslice starts at index 1 and ends at index 3. We then modify the value of the slice array by setting the first element of newSlice.

Note that since newSlice and slice share the same underlying array, when modifying the first element of newSlice, The value of the second element of slice will also change.

Summary

In Golang, slices are a useful data structure that can be dynamically resized as needed. When using slices, we need to know how to modify the element values ​​of the slice. The elements of a slice can be easily accessed and modified using indexes. When we pass a slice to a function, the function operates directly on the original slice. In addition, slices also have the characteristic of sharing the underlying array, which also requires our attention.

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