Slices in Golang
-
In Golang, a slice is a dynamic and flexible data structure used to work with variable-length sequences of elements.
-
Slices overcome the drawbacks of arrays. Unlike arrays, slices can grow or shrink in size during runtime, making them more convenient for handling collections of data.
-
Slices are an essential part of Golang and are commonly used in various programming tasks.
Creating Slices
We can create a slice in Golang using the built-in make function or by directly initializing it. You can use the following code to create a slice.
// Using make function
slice := make([]ElementType, length, capacity)
// Initializing directly
slice := []ElementType{element1, element2, element3}
Accessing and Modifying Slices
We can access and modify elements in a slice using the index. The index starts at 0 for the first element and goes up to the length of the slice-1 for the last element.
Example:
package main
import "fmt"
func main() {
slice := []int{10, 20, 30, 40, 50}
fmt.Println(slice[0])
fmt.Println(slice[3])
slice[2] = 35
fmt.Println(slice)
}
Output:
10
40
[10 20 35 40 50]
Slice Operations
Golang provides several built-in functions and operations to working with slices. Some commonly used functions and operations are.
1. Appending elements: We can add elements to a slice using the append function.
Example:
package main
import "fmt"
func main() {
slice := []int{1, 2, 3}
slice = append(slice, 4, 5)
fmt.Println(slice)
}
Output:
[1 2 3 4 5]
2. Slicing slices: We can create a new slice from an existing slice by specifying a range of indices.
Example:
package main
import "fmt"
func main() {
slice := []int{1, 2, 3, 4, 5}
newSlice := slice[1:4]
fmt.Println(newSlice)
}
Output:
[2 3 4]
3. Copying slices: We can copy elements from one slice to another using the copy function.
Example:
package main
import "fmt"
func main() {
slice := []int{1, 2, 3}
newSlice := make([]int, len(slice))
copy(newSlice, slice)
fmt.Println(newSlice)
}
Output:
[1 2 3]
Length and Capacity
All the slices have a length and capacity. The length of a slice represents the number of elements in the slice, while the capacity represents the number of elements the underlying array can hold without resizing.
Example:
package main
import "fmt"
func main() {
slice := make([]int, 5, 10)
fmt.Println(len(slice))
fmt.Println(cap(slice))
}
Output:
5
10
