[5]int<\/code> are different types and cannot be assigned to each other.<\/p>\nDeclare an array by specifying the length and type, then provide values in curly braces:<\/p>\n
package main\n\nimport \"fmt\"\n\nfunc main() {\n\t\/\/ Array of 5 integers, all zero-initialized\n\tvar scores [5]int\n\n\t\/\/ Array with literal values\n\tdays := [7]string{\"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\", \"Sun\"}\n\n\t\/\/ Let the compiler count elements with ...\n\tprimes := [...]int{2, 3, 5, 7, 11}\n\n\tscores[0] = 95\n\tfmt.Println(scores[0]) \/\/ 95\n\tfmt.Println(len(days)) \/\/ 7\n\tfmt.Println(len(primes)) \/\/ 5\n}\n<\/code><\/pre>\nArrays are useful when you know the exact size upfront \u2014 for example, the seven days of the week or a fixed-size buffer. In most application code, however, you need collections that can grow and shrink. That is where slices<\/strong> come in.<\/p>\n2. Slices \u2014 Dynamic Views Over Arrays<\/h4>\n A slice<\/strong> is a flexible, dynamically sized view into an underlying array. Slices are reference types: assigning one slice variable to another copies the slice header (pointer, length, capacity) but not the elements themselves. This is why slices appear everywhere in Go \u2014 from parsing HTTP requests to processing JSON.<\/p>\nYou can create a slice in several ways:<\/p>\n
\nSlice literal:<\/strong> nums := []int{1, 2, 3}<\/code><\/li>\nFrom an array:<\/strong> arr := [5]int{10, 20, 30, 40, 50}; s := arr[1:4]<\/code> \u2014 elements at indices 1, 2, 3<\/li>\nWith make:<\/strong> make([]int, length, capacity)<\/code><\/li>\n<\/ul>\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\t\/\/ Slice literal\n\tfruits := []string{\"apple\", \"banana\", \"cherry\"}\n\n\t\/\/ make(type, length, capacity)\n\t\/\/ length = number of accessible elements\n\t\/\/ capacity = total space in the backing array\n\tbuffer := make([]byte, 0, 16)\n\n\tfmt.Println(fruits) \/\/ [apple banana cherry]\n\tfmt.Println(len(buffer)) \/\/ 0\n\tfmt.Println(cap(buffer)) \/\/ 16\n}\n<\/code><\/pre>\n3. append, len, and cap<\/h4>\n Three functions and built-ins define everyday slice work:<\/p>\n
\nlen(s)<\/code> \u2014 returns the number of elements currently in the slice<\/li>\ncap(s)<\/code> \u2014 returns the capacity of the underlying array from the slice’s start index<\/li>\nappend(s, elements...)<\/code> \u2014 adds elements to the end, growing the slice when needed<\/li>\n<\/ul>\nWhen append<\/code> exceeds capacity, Go allocates a new, larger backing array (typically doubling capacity), copies existing elements, and returns the updated slice. Always assign the result back to your variable:<\/p>\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\tnums := []int{1, 2, 3}\n\tfmt.Printf(\"len=%d cap=%d %v\\n\", len(nums), cap(nums), nums)\n\n\tnums = append(nums, 4, 5, 6)\n\tfmt.Printf(\"len=%d cap=%d %v\\n\", len(nums), cap(nums), nums)\n\n\t\/\/ append can add another slice with ...\n\tmore := []int{7, 8}\n\tnums = append(nums, more...)\n\tfmt.Printf(\"len=%d cap=%d %v\\n\", len(nums), cap(nums), nums)\n}\n<\/code><\/pre>\nUnderstanding len<\/code> vs cap<\/code> helps you write efficient code. Pre-allocating with make([]T, 0, expectedSize)<\/code> avoids repeated reallocations when you know roughly how many elements you will store \u2014 a common pattern in API handlers and data pipelines.<\/p>\n4. Slicing, Copying, and Common Patterns<\/h4>\n You can create sub-slices with the syntax s[low:high]<\/code>. Omitting low<\/code> defaults to 0; omitting high<\/code> defaults to len(s)<\/code>:<\/p>\ns := []int{10, 20, 30, 40, 50}\nfirst := s[:2] \/\/ [10 20]\nmiddle := s[1:4] \/\/ [20 30 40]\nlast := s[3:] \/\/ [40 50]\n<\/code><\/pre>\nTo copy elements without sharing the backing array, use the built-in copy<\/code> function:<\/p>\nsrc := []int{1, 2, 3}\ndst := make([]int, len(src))\ncopy(dst, src)\n<\/code><\/pre>\nA nil slice has len<\/code> 0 and cap<\/code> 0. You can call append<\/code> on a nil slice \u2014 it works fine. An empty slice literal []int{}<\/code> is also valid and sometimes preferred when serializing to JSON, because null<\/code> vs []<\/code> matters for API consumers.<\/p>\n5. Maps \u2014 Key-Value Collections<\/h4>\n A map<\/strong> associates keys with values. Both keys and values have types \u2014 for example, map[string]int<\/code> maps string keys to integer values. Maps are reference types, like slices.<\/p>\nCreate a map with make<\/code> or a literal:<\/p>\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\t\/\/ Map literal\n\tages := map[string]int{\n\t\t\"Alice\": 30,\n\t\t\"Bob\": 25,\n\t}\n\n\t\/\/ make(map[KeyType]ValueType)\n\tscores := make(map[string]int)\n\n\tscores[\"math\"] = 92\n\tscores[\"science\"] = 88\n\n\tfmt.Println(ages[\"Alice\"]) \/\/ 30\n\tfmt.Println(scores) \/\/ map[math:92 science:88]\n}\n<\/code><\/pre>\nReading a missing key returns the zero value for the value type (0 for int<\/code>, \"\"<\/code> for string<\/code>). To distinguish “key not found” from “key exists with zero value”, use the two-value form:<\/p>\nscore, ok := scores[\"history\"]\nif !ok {\n\tfmt.Println(\"history score not found\")\n} else {\n\tfmt.Println(\"history:\", score)\n}\n<\/code><\/pre>\nDelete a key with delete(scores, \"math\")<\/code>. Maps are not safe for concurrent access from multiple goroutines without synchronization \u2014 you will learn about that in the goroutines lesson.<\/p>\n6. Iteration with range<\/h4>\n The range<\/code> keyword iterates over slices, arrays, maps, strings, and channels. For slices and arrays, range<\/code> provides the index and value:<\/p>\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\tcolors := []string{\"red\", \"green\", \"blue\"}\n\n\t\/\/ Index and value\n\tfor i, color := range colors {\n\t\tfmt.Printf(\"%d: %s\\n\", i, color)\n\t}\n\n\t\/\/ Value only \u2014 use _ to ignore the index\n\tfor _, color := range colors {\n\t\tfmt.Println(color)\n\t}\n\n\t\/\/ Map iteration \u2014 key and value\n\tcapital := map[string]string{\n\t\t\"Nigeria\": \"Abuja\",\n\t\t\"Kenya\": \"Nairobi\",\n\t\t\"Ghana\": \"Accra\",\n\t}\n\n\tfor country, city := range capital {\n\t\tfmt.Printf(\"%s \u2192 %s\\n\", country, city)\n\t}\n}\n<\/code><\/pre>\nMap iteration order is randomized<\/em> in Go \u2014 do not depend on any particular order. If you need sorted output, collect keys into a slice and sort them first (using the sort<\/code> package).<\/p>\n7. Arrays vs Slices vs Maps \u2014 Quick Reference<\/h4>\n \n\n\nType<\/th>\n Size<\/th>\n Access<\/th>\n Typical Use<\/th>\n<\/tr>\n<\/thead>\n \n\nArray<\/td>\n Fixed at compile time<\/td>\n Index [i]<\/code><\/td>\nFixed buffers, low-level code<\/td>\n<\/tr>\n \nSlice<\/td>\n Dynamic (append<\/code>)<\/td>\nIndex [i]<\/code><\/td>\nLists, sequences, most collections<\/td>\n<\/tr>\n \nMap<\/td>\n Dynamic (grows automatically)<\/td>\n Key [key]<\/code><\/td>\nLookups, counting, grouping<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n8. Next Steps<\/h4>\n You now understand Go arrays, slices, and maps<\/strong> \u2014 how to create them with literals and make<\/code>, grow slices with append<\/code>, inspect size with len<\/code> and cap<\/code>, and iterate with range<\/code>. In the next lesson we cover structs and methods<\/strong> \u2014 Go’s way to group related data and attach behavior to types.<\/p>\nContinue the series: Lesson 6 \u2013 Functions<\/a> \u00b7 Lesson 8 \u2013 Structs and Methods<\/a><\/p>\nFrequently Asked Questions<\/h4>\n What is the difference between arrays and slices in Go?<\/strong>How do you append to a slice in Go?<\/strong>append(slice, element)<\/code> and assign the result back: slice = append(slice, value)<\/code>. When capacity is exceeded, Go allocates a new backing array automatically.<\/p>\nAre Go maps ordered?<\/strong><\/p>\n\nPrevious:<\/strong> Lesson 6: Go Functions \u2013 Declarations, Returns, and defer<\/a><\/p>\nNext:<\/strong> Lesson 8: Go Structs and Methods \u2013 Organizing Data and Behavior<\/a><\/p>\n<\/nav>\n<\/p>\n