Updating Array Elements

An array element can be replaced using an indexed assignment. The array length stays fixed while its values change.

Write points[1] = 42 to replace the second element. Indexing can also appear on the left of compound assignments such as points[0] += 5. Each assignment requires the new value to be compatible with the array element type.

When an array is passed by value to a function, the function gets a copy. Updating its parameter does not change the caller’s original array. You can return the changed copy or use a pointer when you intentionally need shared mutation.

Follow this diagram before executing the example. Check where a value or decision changes what runs next.

This example is a complete program. Save it as main.go or paste it into the Go Playground.

Go code

package main

import "fmt"

func changeCopy(values [3]int) {
	values[0] = 100
	fmt.Println("Inside:", values)
}
func main() {
	values := [3]int{5, 10, 15}
	values[1] = 20
	changeCopy(values)
	fmt.Println("Outside:", values)
}

Output

Inside: [100 20 15]
Outside: [5 20 15]

The assignment changes the second element to 20 in main. Calling changeCopy copies the array. That function sets its local first element to 100 and prints the copy. When it returns, main still owns [5 20 15].

• Replacing an element does not resize an array.
• Passing a regular array argument copies its elements; mutations to the parameter do not update the caller.

Create a function that returns an updated [3]int array. Assign its result back to the original variable.

Tip: Edit the example above, predict the output, and run the modified code to test your reasoning.

You have practiced Updating Array Elements in a small, self-contained program. The important habit is to predict what runs, inspect the actual output and distinguish the language rule from the particular example.

Before continuing, make sure you can explain the program to someone who has not seen it, including the line that changes its result.