Arrays and Slices

# CHAPTER 10

Arrays and Slices #

1. Introduction #

2. Learning Objectives #

• Declare and initialize fixed-size Arrays.

• Understand why Arrays are rigid.

• Declare and manipulate dynamic Slices.

• Use the append() function.

• Understand the difference between Length and Capacity.

• Use the make() function for optimization.

3. Arrays (Fixed Size) #

package main
import "fmt"

func main() {
    // Declares an array that holds exactly 3 strings
    var cars [3]string 

    cars[0] = "Volvo" // Arrays are zero-indexed!
    cars[1] = "BMW"
    cars[2] = "Ford"
    // cars[3] = "Mazda" // ERROR: index out of bounds!

    fmt.Println(cars)
    fmt.Println("Total cars:", len(cars)) // len() gets the length
}

Short Initialization:

primes := [5]int{2, 3, 5, 7, 11}

4. Slices (Dynamic Size) #

Syntax Difference: You leave the brackets [] EMPTY!

func main() {
    // Empty brackets mean this is a SLICE, not an array
    users := []string{"Alice", "Bob"} 

    // We can ADD to a slice using the append() function!
    users = append(users, "Charlie") 
    
    fmt.Println(users) // Output: [Alice Bob Charlie]
}

5. How append() works in Memory #

6. Length vs Capacity #

• Length (len): How many items are currently accessible in the slice.

• Capacity (cap): How much total room exists in the hidden underlying array before Go has to create a new one.

func main() {
    nums := []int{1, 2}
    fmt.Printf("Len: %d, Cap: %d\n", len(nums), cap(nums))
    
    // Add an item. The capacity will double automatically!
    nums = append(nums, 3)
    fmt.Printf("Len: %d, Cap: %d\n", len(nums), cap(nums))
}

7. The make() Function (Optimization) #

// Creates a slice of ints. Length is 0, but starting Capacity is 10,000.
// This prevents memory resizing during appending!
data := make([]int, 0, 10000)

8. Iterating over Arrays and Slices #

heroes := []string{"Batman", "Superman", "Flash"}

for index, name := range heroes {
    fmt.Printf("Hero #%d is %s\n", index, name)
}

*(Remember: If you don't need the index, replace it with the blank identifier _)*.

9. Common Mistakes #

• Index Out of Range: Trying to access cars[5] when the length is only 3 will instantly crash (Panic) the program.

• Confusing Arrays and Slices: [3]int is an array (rigid). []int is a slice (dynamic). They are completely different types in Go, and you cannot pass an array to a function that expects a slice.

10. Best Practices #

• Always use Slices: Unless you are building highly optimized cryptographic algorithms or parsing fixed-byte network packets, always default to using Slices.

• Use make() for known sizes: If you know exactly how much data you will pull from a database, use make() to set the capacity and save the Garbage Collector from doing extra work.

11. Exercises #

1. 1. Create a Slice of strings containing 3 grocery items.

1. 2. Use append() to add 2 more items.

1. 3. Use a for ... range loop to print them all out.

12. MCQs with Answers & Explanations #

13. Interview Preparation #

1. 1. Explain the difference between an Array and a Slice in Go.

1. 2. How does the append() function affect memory allocation when a slice reaches its maximum capacity?

1. 3. What is the purpose of the make() function, and when should you use it?

14. Summary #

15. Next Chapter Recommendation #