Updating golang array while iterating it

Question

When iterating an array with range, if the array is updated the updated positions do not make it into the future loop runs. The following prints "1 2" instead of "1 0"

package main

import (
    "fmt"
)

func main() {
    var A = &[2]int{1, 2}
    for i, v := range A {
        if i == 0 {
            A[1] = 0
        }
        fmt.Print(v, " ")
    }

    fmt.Println()

    var B = [2]int{1, 2}
    for i, v := range B {
        if i == 0 {
            B[1] = 0
        }
        fmt.Print(v, " ")
    }
}

https://play.golang.org/p/0zZY6vjxwut

It looks like the array is copied before it's iterated.

What part of the spec describes this behavior? See "For statements with range clause" at https://golang.org/ref/spec#For_range

icza · Accepted Answer · 2019-12-21 07:21:28Z

7

TLDR; Whatever you range over, a copy is made of it (this is the general "rule", but there is an exception, see below). Arrays are rare in Go, usually slices are used. Slice values (slice headers) contain a pointer to an underlying array, so copying a slice header is fast, efficient, and it does not copy the slice elements, not like arrays. Ranging over a pointer to array is similar to ranging over a slice in this regard.

Spec: For statements:

The range expression x is evaluated once before beginning the loop, with one exception: if at most one iteration variable is present and len(x) is constant, the range expression is not evaluated.

Arrays are values, they do not contain pointers to data located outside of the array's memory (unlike slices). The Go Blog: Go Slices: usage and internals:

Go's arrays are values. An array variable denotes the entire array; it is not a pointer to the first array element (as would be the case in C). This means that when you assign or pass around an array value you will make a copy of its contents. (To avoid the copy you could pass a pointer to the array, but then that's a pointer to an array, not an array.) One way to think about arrays is as a sort of struct but with indexed rather than named fields: a fixed-size composite value.

Evaluating an array is a copy of the entire array, it is a copy of all the elements. Spec: Variables:

A variable's value is retrieved by referring to the variable in an expression; it is the most recent value assigned to the variable.

In your first example the range expression is just a pointer to the array, so only this pointer is copied (but not the pointed array), so when you do A[1] = 0 (which is a shorthand for (*A)[1] = 0), you modify the original array, and the iteration variable gets elements from the pointed array.

In your second example the range expression is the array, so the array (with all its elements) is copied, and inside it B[1] = 0 still modifies the original array (B is a variable, not the result of the evaluation of the range expression), but v is an element of the copy (v is populated from the copied array in each iteration).

Under the hood

So how is this "copy" realized? The compiler generates code for the for range that copies (assigns) the result of the range expression to a temporary variable (if needed, because it might not always be needed: "if at most one iteration variable is present and len(x) is constant, the range expression is not evaluated").

This code can be inspected in the cmd/compile/internal/gc/range.go file.

See related article: Go Range Loop Internals

edited Dec 21, 2019 at 7:21

answered Dec 20, 2019 at 9:35

icza

423k78 gold badges1k silver badges905 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Chris Drew Over a year ago

Can you explain a little more about what it means to "evaluate a range expression".

icza Over a year ago

@ChrisDrew The expression here is simple, it's just the variable B. Evaluating a variable is simply reading its value. The expression could be anything more complex of course, e.g. calling other functions.

user4466350 Over a year ago

is it possible to see the copy in action using assembler output ? i naively ask as i don't realize how much instructions, nor what they look like, i am referring to.

icza Over a year ago

@mh-cbon Please see edited answer, the last "Under the hood" part. The compiler generates such code that the result of the range expression is assigned to a temporary variable.

Community · Accepted Answer · 2020-06-20 09:12:55Z

2

The spec says

The range expression x is evaluated once before beginning the loop, with one exception: if at most one iteration variable is present and len(x) is constant, the range expression is not evaluated.

Function calls on the left are evaluated once per iteration. For each iteration, iteration values are produced as follows if the respective iteration variables are present

The thing here is that given your loop takes more than one variable, the range expression is evaluated only once at the beginning of the iteration. Thus the value of the B[1] assigned to the v won't change.

In the case with reference, you see the modified value since the expression evaluates the reference to the B[1], which is not modified and prints the value of that referenced variable, which is actually modified.

edited Jun 20, 2020 at 9:12

CommunityBot

11 silver badge

answered Dec 20, 2019 at 9:49

Henry Harutyunyan

2,4351 gold badge20 silver badges23 bronze badges

Collectives™ on Stack Overflow

Updating golang array while iterating it

2 Answers 2

Under the hood

4 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Under the hood

4 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related