Fixing Go error: array index must be non-negative integer constant

When programming in Go, you might encounter the error “array index must be non-negative integer constant”. This message typically indicates that you have tried to use a non-constant, negative, or out-of-bounds index while accessing an array. In this article, I will show you how to fix these issues through clear explanations and code examples.

Understanding Arrays in Go

Arrays in Go are fixed-size sequences that hold elements of the same type. When an array is created, its size must be specified, and this size cannot change afterward. Here's a quick example of declaring and initializing an array in Go:

package main

import "fmt"

func main() {
    // Declare an array of integers with 5 elements
    numbers := [5]int{1, 2, 3, 4, 5}
    fmt.Println(numbers)
}

Common Causes of the Error

Non-Constant Index

This error occurs when you use a variable as an index without ensuring it is a non-negative constant. For example:

package main

import "fmt"

func main() {
    x := 5
    numbers := [5]int{1, 2, 3, 4, 5}
    fmt.Println(numbers[x])  // Error: array index must be non-negative integer constant
}

In the above code, x is not a constant. To fix the error, ensure that your index is within bounds and use constants or ensure the variable value does not exceed array bounds.

Negative Index

Using a negative integer as an index is prohibited, as it causes this error. Here's an example:

package main

import "fmt"

func main() {
    numbers := [5]int{1, 2, 3, 4, 5}
    fmt.Println(numbers[-1])  // Error: array index must be non-negative integer constant
}

The negative index -1 is invalid. All indices must be non-negative.

Out-of-Bounds Index

An array index must be less than the array size. Here's what happens when you exceed this limit:

package main

import "fmt"

func main() {
    numbers := [5]int{1, 2, 3, 4, 5}
    fmt.Println(numbers[5])  // Error: array index out of bounds
}

Only indices 0 through 4 are valid in this example, as the array size is 5.

How to Correct These Mistakes

Use constants: Whenever possible, prefer constants for array sizes and index bounds.
Conditional checks: Always check that an index is within the valid range before accessing an array.
Iterate safely: Use loops that properly manage and restrict the index variable to stay inside array bounds.

Example with Correct Indexing

Here is a corrected example using a safe iteration over an array:

package main

import "fmt"

func main() {
    numbers := [5]int{1, 2, 3, 4, 5}

    for i := 0; i < len(numbers); i++ {
        fmt.Println(numbers[i])
    }
}

In this example, the loop iterates over the entire array without exceeding its boundaries, ensuring a safe and error-free execution.

By understanding these common mistakes and their solutions, you can effectively avoid the array index must be non-negative integer constant error in your Go programs.