How to use slice in Go language?

Slice in Go language is a powerful data type that allows you to easily perform operations on arrays or slices. This article will introduce the basic concepts of slices and how to use slices in the Go language.

Definition and initialization of slice

In the Go language, slice is used to represent a dynamic array. Unlike an array, the length of a slice is not fixed and will grow or shrink automatically based on the number of elements stored.

The definition format of slice is as follows:

var s []type

where, s represents the variable name of the slice, and type represents the type of elements stored in the slice. Slices can also be initialized using the make() function, with the following format:

var s = make([]type, length, capacity)

where length represents the initial length of the slice, and capacity represents the capacity of the slice (that is, the length of the underlying array). If the capacity is not specified, it defaults to the same as the length. If you operate on an uninitialized slice, a runtime error will result.

Slice operations

Like arrays, slice also supports basic access and modification operations. As shown below:

s[0] = 1      // 修改元素
x := s[1]     // 获取元素
s = append(s, 3)   // 在尾部追加元素
s = s[:len(s)-1]   // 删除尾部元素

These operations are similar to array operations, but slice also supports some special operations, which will be described in detail below.

range traversal

slice You can use the range keyword to traverse, the format is as follows:

for i, v := range s {
    fmt.Printf("s[%d] = %d
", i, v)
}

where, i represents the element subscript, and v represents the value of the element. The range loop will traverse the entire slice.

Slicing operation

slice has a very powerful function - slicing operation. This operation can intercept the original slice and generate a new slice. The format is as follows:

s1 := s[start:end]    // 基于下标[start, end)截取slice
s2 := s[:end]         // 截取slice的前end个元素
s3 := s[start:]       // 从下标为start的元素截取slice的末尾元素

As shown above, we can use the slicing operation to split the original slice into multiple sub-slices.

append() function

slice also supports a very important function - append(). The append() function can append one or more elements to the end of a slice to generate a new slice. The format is as follows:

s = append(s, elem1, elem2, ...)

When using the append() function, if the underlying array capacity of the slice is insufficient, the capacity will be automatically increased. If the capacity of the underlying array does not grow enough, a larger underlying array is reallocated and the original values ​​are copied to the new underlying array.

copy() function

The Go language also provides a copy() function that can copy elements in one slice to another slice. The format is as follows:

copy(destSlice, srcSlice)

Among them, destSlice represents the destination slice and srcSlice represents the source slice. It should be noted that the underlying arrays of the two slices must have sufficient capacity, otherwise a runtime error will occur.

Summary

This article introduces the basic concepts and usage of slices in the Go language. Slice is a very important data type in the Go language. It can easily operate on arrays and slices. It is an important tool for realizing dynamic data structures. Mastering the use of slices can make your Go language programming more efficient and flexible.

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