Accessing array elements in Go

Introduction

We access array elements to get or use the specific values stored inside the array. This helps us work with individual pieces of data.

When you want to read a specific value from a list of items.

When you need to update or change a particular item in a collection.

When you want to loop through items and process each one.

When you want to compare or check a value at a certain position.

When you want to print or display a specific element from a group.

Syntax

Go

package main

import "fmt"

func main() {
    var numbers [5]int = [5]int{10, 20, 30, 40, 50}
    // Access element at index 2
    value := numbers[2]
    fmt.Println(value)
}

Array indexes start at 0, so the first element is at index 0.

Trying to access an index outside the array size causes a runtime panic.

Examples

Accessing first and last elements in a small array.

Go

package main

import "fmt"

func main() {
    var letters [3]string = [3]string{"a", "b", "c"}
    fmt.Println(letters[0]) // Output: a
    fmt.Println(letters[2]) // Output: c
}

Example of an empty array with zero length.

Go

package main

import "fmt"

func main() {
    var emptyArray [0]int
    // No elements to access, accessing any index will cause panic
    fmt.Println(len(emptyArray)) // Output: 0
}

Accessing the only element in a single-element array.

Go

package main

import "fmt"

func main() {
    var singleElement [1]string = [1]string{"only"}
    fmt.Println(singleElement[0]) // Output: only
}

Sample Program

This program shows how to access and update elements in an array. It prints the array before and after changing one element.

Go

package main

import "fmt"

func main() {
    // Create an array of 5 integers
    var scores [5]int = [5]int{85, 90, 78, 92, 88}

    // Print the whole array
    fmt.Println("Scores array:", scores)

    // Access and print the first element
    fmt.Println("First score:", scores[0])

    // Access and print the last element
    fmt.Println("Last score:", scores[4])

    // Change the third element
    scores[2] = 80
    fmt.Println("Updated scores array:", scores)
}

Important Notes

Accessing an element by index is very fast, it takes constant time O(1).

Arrays have fixed size, so you cannot access indexes outside their length.

Common mistake: forgetting that indexes start at 0, not 1.

Use arrays when you know the number of elements in advance and want fast access.

Summary

Arrays store multiple values of the same type in order.

You access elements using their index, starting at 0.

Accessing elements is fast and simple but be careful not to go out of bounds.

Practice

1. What is the index of the first element in a Go array?

easy

A. 1

B. Depends on the array size

C. -1

D. 0

Solution

1. Step 1: Understand Go array indexing

   In Go, arrays start indexing from 0, meaning the first element is at index 0.

2. Step 2: Confirm the first element's index

   The first element is always accessed with index 0, not 1 or any other number.

3. Final Answer:

   0 -> Option D

4. Quick Check:

   First element index = 0 [OK]

Hint: Remember, Go arrays start counting at zero [OK]

Common Mistakes:

• Thinking indexing starts at 1
• Assuming negative indexes are valid
• Believing index depends on array size

2. Which of the following is the correct way to access the third element of an array named arr in Go?

easy

A. arr[3]

B. arr[2]

C. arr(2)

D. arr{2}

Solution

1. Step 1: Recall Go array indexing syntax

   Go uses square brackets with zero-based indexing to access elements, so the third element is at index 2.

2. Step 2: Identify correct syntax

   arr[2] accesses the third element; arr[3] accesses the fourth, arr(2) and arr{2} are invalid syntax.

3. Final Answer:

   arr[2] -> Option B

4. Quick Check:

   Third element = arr[2] [OK]

Hint: Use square brackets and zero-based index [OK]

Common Mistakes:

• Using parentheses instead of brackets
• Using 1-based index
• Using curly braces for access

3. What will be the output of this Go code?

arr := [4]int{10, 20, 30, 40}
fmt.Println(arr[1])

medium

A. 10

B. 40

C. 20

D. 30

Solution

1. Step 1: Identify the array elements and their indexes

   The array is [10, 20, 30, 40], indexed 0 to 3. Index 1 corresponds to the second element, 20.

2. Step 2: Determine the printed value

   arr[1] accesses the element 20, so fmt.Println prints 20.

3. Final Answer:

   20 -> Option C

4. Quick Check:

   arr[1] = 20 [OK]

Hint: Remember index 1 is second element [OK]

Common Mistakes:

• Printing arr[0] instead
• Confusing index 1 with 2
• Expecting output as 30 or 40

4. What is wrong with this Go code snippet?

arr := [3]int{1, 2, 3}
fmt.Println(arr[3])

medium

A. Index 3 is out of bounds for the array

B. Array declaration syntax is incorrect

C. fmt.Println cannot print array elements

D. The array size should be 4

Solution

1. Step 1: Check array size and valid indexes

   The array has size 3, so valid indexes are 0, 1, and 2 only.

2. Step 2: Identify the error in accessing arr[3]

   Accessing arr[3] tries to get the fourth element, which does not exist, causing an out-of-bounds runtime error.

3. Final Answer:

   Index 3 is out of bounds for the array -> Option A

4. Quick Check:

   Valid indexes: 0 to 2 only [OK]

Hint: Array indexes go from 0 to length-1 [OK]

Common Mistakes:

• Using index equal to array length
• Thinking fmt.Println can't print elements
• Assuming array size auto-expands

5. Given the array arr := [5]int{5, 10, 15, 20, 25}, which code snippet correctly sums the first three elements?

hard

A. sum := arr[0] + arr[1] + arr[2]

B. sum := arr[1] + arr[2] + arr[3]

C. sum := arr[0] + arr[2] + arr[3]

D. sum := arr[2] + arr[3] + arr[4]

Solution

1. Step 1: Identify the first three elements

   The first three elements are at indexes 0, 1, and 2, which are 5, 10, and 15 respectively.

2. Step 2: Check which option sums these elements

   sum := arr[0] + arr[1] + arr[2] sums arr[0], arr[1], and arr[2], which is correct. Other options include elements beyond the first three.

3. Final Answer:

   sum := arr[0] + arr[1] + arr[2] -> Option A

4. Quick Check:

   Sum first three = arr[0]+arr[1]+arr[2] [OK]

Hint: Sum elements at indexes 0, 1, and 2 for first three [OK]

Common Mistakes:

• Starting sum at index 1
• Skipping elements
• Including elements beyond first three