How to use golang slice

Golang is a currently popular programming language, and its built-in data type slice is very common in use. Slice refers to a continuous block of data in memory. It has the characteristics of dynamically variable length, which is different from an array. This article will introduce in detail how to use Golang slice.

1. Create slice

There are two ways to create a slice in Golang:

(1) Use the make() function to create a slice

The make() function is a function used in Golang to create slices, maps, channels, etc. When using the make() function to create a slice, you need to specify the slice type, length and capacity. As shown below:

s := make([]int, 5, 10)

The above code creates a slice of type int containing 5 elements, and allocates storage space for 10 elements. Among them, the length is 5 and the capacity is 10.

(2) Use literal mode to create slice

In literal mode, you can initialize a slice and define its initial value. As shown below:

s := []int{1, 2, 3, 4, 5}

The above code creates a slice of int type containing 5 elements, and defines its initial value through {}.

2. Accessing slice elements

Same as arrays, slice elements can also be accessed through subscripts. As shown below:

s := []int{1, 2, 3, 4, 5}
s[0] // 访问第一个元素
s[1] // 访问第二个元素
...

3. slice traversal

(1) Use for loop to traverse slice

You can use for loop to traverse a slice and obtain each value of elements. As shown below:

s := []int{1, 2, 3, 4, 5}
for i := 0; i < len(s); i++ {
    fmt.Println(s[i])
}

(2) Use the range keyword to traverse a slice

Using the range keyword can more conveniently traverse a slice and obtain the value of each element. As shown below:

s := []int{1, 2, 3, 4, 5}
for _, v := range s {
    fmt.Println(v)
}

In the above code, using _ ignores the return value of the subscript and only obtains the value of the element.

4. slice cutting

In Golang, you can cut a slice to get a smaller slice.

The cutting operation of slice is implemented through colon (:). The number before the first colon indicates the starting position, and the number after the first colon indicates the ending position (excluding this position), as follows Display:

s := []int{1, 2, 3, 4, 5}
s1 := s[1:3] // s1变成了[2, 3]

In the above code, s1 starts from s[1] and goes to s[3] (excluding s[3]).

If the number before the colon is omitted, it means starting from the first element of the slice. If the number after the colon is omitted, it means cutting to the last element of the slice.

5. Slice appends elements

Slice has the characteristic of dynamically changing length, so one or more elements can be appended to an existing slice.

You can use the built-in function append() to append one or more elements to the slice. The append() function automatically expands the capacity of the slice to accommodate the newly added elements.

s := []int{1, 2, 3, 4, 5}
s = append(s, 6) // 追加一个元素6
s = append(s, 7, 8, 9) // 追加三个元素7、8、9

6. slice deletes elements

In Golang, slice does not have a built-in function to delete elements, but you can use the append() function in conjunction with the cutting operation to delete elements. Function.

For example, if you want to delete the third element in slice, you can follow the following steps:

(1) Use the cutting operation of slice to delete the element to be deleted, as follows:

s := []int{1, 2, 3, 4, 5}
s = append(s[:2], s[3:]...)

In the above code, the append() function is used to cooperate with the cutting operation to delete the third element s[2] in the slice.

(2) Use a for loop to traverse the slice, find the element to be deleted, and use the cutting operation of the slice to delete it.

7. slice copy

In Golang, you can use the built-in function copy() to copy a slice.

s1 := []int{1, 2, 3, 4, 5}
s2 := make([]int, len(s1))
copy(s2, s1)

In the above code, the make() function is used to create a slice s2 with the same length as s1, and the copy() function is used to copy the elements in s1 to s2.

When the number of copied elements exceeds the capacity of the target slice, the copy() function will only copy the elements in the target slice. If the target slice is larger than the source slice, a 0-valued element will be added to the end of the target slice.

Summary

Through the above content, we can summarize the main characteristics of slice:

(1) Slice is a dynamically variable length sequence.

(2) The basic operations of slice include creating, accessing elements, traversing, cutting, appending elements, deleting elements, and copying.

(3) Use the make() function or literal method to create slice.

(4) Use subscript or range keyword to access slice elements.

(5) Use the cutting operation to split the slice, use the append() function to append elements, and the copy() function to copy the slice.

In short, slice, as a built-in data type in Golang, plays a very important role. When we need a dynamically variable length data structure, we can use slice first.

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