Arrays, slices, and maps are used in Go to store and manipulate collections of data. Here’s an overview of how they work in Go:
1. Arrays: An array is a fixed-size collection of elements of the same type. In Go, arrays are declared using square brackets, followed by the size of the array and the type of its elements. For example:
`` var nums [5]int nums[0] = 1 nums[1] = 2 nums[2] = 3 nums[3] = 4 nums[4] = 5
`
This code declares an array of 5 integers and initializes it with values.
2. Slices: A slice is a dynamic collection of elements of the same type. In Go, slices are declared using square brackets with no size specified, followed by the type of its elements. For example:
`` var nums []int nums = append(nums, 1) nums = append(nums, 2) nums = append(nums, 3) nums = append(nums, 4) nums = append(nums, 5)
`
This code declares a slice of integers and appends values to it dynamically.
3. Maps: A map is a collection of key-value pairs, like a dictionary in other languages. In Go, maps are declared using the `make` function,followed by the type of the keys and the type of the values. For example:
`` var m = make(map[string]int) m["one"] = 1 m["two"] = 2 m["three"] = 3
`
This code declares a map with string keys and integer values, and initializes it with key-value pairs.
4. Accessing and modifying elements: Elements in an array or slice can be accessed and modified using their index. Elements in a map can be accessed and modified using their key. For example:
``
var nums []int = []int{1, 2, 3, 4, 5}
nums[0] = 10 // modify the first element
fmt.Println(nums[2]) // output: 3
var m = make(map[string]int)
m["one"] = 1
m["two"] = 2
fmt.Println(m["two"]) // output: 2
m["two"] = 20 // modify the value of the key "two"
`
5. Iterating over collections: Arrays, slices, and maps can be iterated over using loops. For example:
``
var nums []int = []int{1, 2, 3, 4, 5}
for i, num := range nums {
fmt.Println(i, num)
}
var m = make(map[string]int)
m["one"] = 1
m["two"] = 2
for key, value := range m {
fmt.Println(key, value)
}
`
This code iterates over the values in the slice and the key-value pairs in the map.
Arrays, slices, and maps are essential for working with collections of data in Go. By using these data structures, you can store, manipulate, and iterate over large amounts of data efficiently and effectively.