Understanding Arrays and Slices in Go
Arrays and slices are fundamental data structures in the Go programming language for managing collections of elements.
An array in Go is a fixed-size sequence of elements of the same type. The size of an array is specified at compile time and cannot be changed at runtime. Arrays provide direct access to individual elements using zero-based indexing.
Slices, on the other hand, are dynamic and flexible wrappers around arrays. A slice is a lightweight data structure that represents a segment of an underlying array. Unlike arrays, slices can grow or shrink dynamically at runtime. Slices include a pointer to the underlying array, along with a length and capacity, allowing for efficient operations like appending elements.
Understanding the differences between arrays and slices is crucial for effective memory management and data manipulation in Go. Arrays are suitable for fixed-size collections, while slices are preferred for handling variable-size data and supporting dynamic operations. Both arrays and slices are integral to Go's idiomatic approach to managing collections and data structures efficiently.
In an array, store zero or more
than zero
elements in it. which means the index of the first element is
array [0] and the index of the last element is an
array [len(array)-1].
Arrays are created in two different ways:
- Using var keyword
- Go program to illustrate how to create:
package main
import "fmt"
func main() {
var a [5]int
fmt.Println(" size of the array: ", a)
}
Output :
PS C:\GO_Language\Array> go run arr.go
thr size of the array [0 0 0 0 0]
- Go program to illustrate the values of an array
package main
import "fmt"
func main() {
a: = [5]int {1, 3, 4, 2, 5}
sum: = 0
for i: = 0; i < len(a); i++ {
sum += a[i]
fmt.Println("The value :", sum)
}
}
Output:
PS C:\GO_Language\Array> go run arr2.go
The value : 1
The value : 4
The value : 8
The value : 10
The value : 15
- Go program to illustrate and insert the values in an array using for loop
package main
import "fmt"
func main() {
var n [10]int
var i, j int
for i = 0; i < 10; i++ {
n[i] = i + 100
}
for j = 0; j < 10; j++ {
fmt.Printf("Element[%d] =%d\n", j, n[j])
}
}
Output :
PS C:\GO_Language\Array> go run arr3.go
Element[0] =100
Element[1] =101
Element[2] =102
Element[3] =103
Element[4] =104
Element[5] =105
Element[6] =106
Element[7] =107
Element[8] =108
Element[9] =109
- Go program to illustrate the Address of a variable
package main
import "fmt"
func main() {
x: = 7
y: = &x
fmt.Println(x, y)
}
Output:
PS C:\GO_Language\Array> go run arr4.go
7 0xc000014088
- Go program to illustrate Assigning values through pointers
package main
import "fmt"
func main() {
i, j: = 42, 2372
p: = &i
fmt.Println(*p)
*p = 21
fmt.Println(i)
p = &j
*p = *p / 37
fmt.Println(j)
}
Output:
PS C:\GO_Language\Array> go run arr5.go
42
21
64
PS C:\GO_Language\Array>
- Go program to illustrate the value of null pointer.
package main
import "fmt"
func main() {
var ptr *int
fmt.Printf("the Value of ptr is :%x\n", ptr)
}
Output :
PS C:\GO_Language\Array> go run arr6.go
the Value of ptr is :0
- Go program to illustrate the division using pointer
package main
import "fmt"
func main() {
i, j: = 42, 2372
p: = &i
fmt.Println(*p)
fmt.Printf("%T \n ", p)
*p = 21
fmt.Println(i)
p = &j
*p = *p / 37
fmt.Println(j)
}
Output :
PS C:\GO_Language\Array> go run arr7.go
42
*int
21
64
