In Go (Golang), a slice of slices refers to a two-dimensional data structure where each element of the outer slice is itself a slice. This concept allows for the creation of dynamic, resizable tables or grids of data.
To visualize this, imagine an outer slice where each element represents a row or a subset of data. Each of these elements (rows) is a slice in itself, containing individual elements that represent columns or data points within that row.
Using slices of slices in Go is flexible and efficient because it allows for jagged arrays, where each row can have a different number of columns. This is unlike traditional two-dimensional arrays, which have a fixed size for each dimension.
Slices of slices are commonly used to model and manipulate tabular data, matrices, or grid-based structures in Go programs. They provide a versatile way to manage data collections dynamically and are particularly useful in scenarios where the size of the data structure may change over time or where irregular data shapes are required. Understanding how to work with slices of slices is essential for effective data management and manipulation in Go programming.
- Go program to illustrate Length and capacity in slice
package main
import "fmt"
func main() {
var x [6]int = [6]int {1, 2, 3, 4, 5,7}
var a []int = x[1:3]
fmt.Println(a)
fmt.Println(len(a))
fmt.Println(cap(a))
}
Output :
PS C:\GO_Language\Slice_Function> go run slice.go
[2 3]
2
4
- Go program to illustrate append function.
package main
import "fmt"
func main() {
var thing = []string{"HI", "This Is Prwatech "}
fmt.Println(thing)
things = append(thing, "!!!")
fmt.Println(thing)
}
Output :
package main
import "fmt"
func main() {
var thing = []string{"HI", "This Is Prwatech "}
fmt.Println(thing)
things = append(thing, "!!!")
fmt.Println(thing)
}
- Go program to illustrate Appending with length specified
package main
import "fmt"
func main() {
var things = []string{"HI", " This is a Prwatech Institute of Data Scientist "}
fmt.Println(things)
subject = append(things, "Analyst ")
fmt.Println(subject)
things = append(subject [1 : len(subject)-1])
fmt.Println(subject)
}
Output :
PS C:\GO_Language\Slice_Function> go run slice3.go
[HI Prwatech Institute of Data Scientist ]
[HI Prwatech Institute of Data Scientist Analyst]
[ Prwatech Institute of Data Scientist ]
- Go program to illustrate slice in string
package main
import "fmt"
func main() {
Names: = [4]string{
"Python", "Machine Learning", "Deep Learning", "Java",
}
fmt.Println(names)
a: = Names[0:2]
b: = Names[1:3]
fmt.Println(a, b)
b[0] = "***"
fmt.Println(a, b)
fmt.Println(Names)
}
Output :
PS C:\GO_Language\Slice_Function> go run slice4.go
[Python Machine Learning Deep Learning Java]
[Python Machine Learning] [Machine Learning Deep Learning]
[Python ***] [*** Deep Learning]
[Python *** Deep Learning Java]
- Go program to illustrate slice Literals
package main
import "fmt"
func main() {
k: = []int {2, 4, 3, 5, 6, 78}
fmt.Println(k)
m: = []bool {true, false, true, false, false, true}
fmt.Println(m)
t: = []struct {
i int
b bool
}{
{2, true},
{4, false},
{3, true},
{5, true},
{6, false},
{78, true},
}
fmt.Println(t)
}
Output :
PS C:\GO_Language\Slice_Function> go run slice5.go
[2 4 3 5 6 78]
[true false true true false true]
[{2 true} {4 false} {3 true} {5 true} {6 false} {78 true}]
- Go program to illustrate slicing using addressing
package main
import "fmt"
func main() {
s: = []int{2, 3, 4, 5, 6, 7, 8, 9}
s = s[1:4]
fmt.Println(s)
s = s[:2]
fmt.Println(s)
s = s[1:]
fmt.Println(s)
Output :
PS C:\GO_Language\Slice_Function> go run slice6.go
[3 4 5]
[3 4]
[4]
- Go program to illustrate slicing operation
package main
import "fmt"
func main() {
s: = []int{2, 3, 4, 5, 6, 7, 11, 14}
PrintSlice(s)
s = s[1:4]
s = s[:0]
PrintSlice(s)
s = s[:4]
PrintSlice(s)
s = s[2:]
PrintSlice(s)
}
func PrintSlice(s []int) {
fmt.Printf("len=%d cap=%d %v \n", len(s), cap(s), s)
}
Output :
C:\GO_Language\Slice_Function> go run slice7.go
len=8 cap=8 [2 3 4 5 6 7 11 14]
len=0 cap=7 []
len=4 cap=7 [3 4 5 6]
len=2 cap=5 [5 6]
PS C:\GO_Language\Slice_Function>
