What is the range of environments contained within a closure?

php Xiaobian The scope of the environment contained in the closed environment refers to the elements, factors and conditions contained in the closed environment. A closed environment refers to a relatively closed and restricted space or range, which can be a physical space, such as a laboratory or a factory floor, or a virtual space, such as a computer network. In a closed environment, various factors such as temperature, humidity, gas composition, etc. can be controlled and adjusted to achieve specific purposes. Closed environments are common in scientific research experiments, production and manufacturing and other fields, and play an important role in ensuring experimental accuracy and product quality.

Question content

I imitated online tutorials about closures and wrote the following code.

func foo1() func() {
    xvalue := 1
    x := &xvalue
    defer func() {
        xvalue = 2
    }()
    return func() {
        *x = *x + 1
        fmt.printf("foo1 val = %d\n", *x)
    }
}

func main() {

    f1 := foo1()
    f1()
    f1()
    f1()
}

I'm confused, it seems like the variable xvalue should be recycled after executing f1 := foo1(), so using *x should be wrong, But the above code has no errors and executes fine, giving the output

foo1 val = 3
foo1 val = 4
foo1 val = 5

So I want to know whether the closure saves the value of the pointer in addition to the pointer itself, or is the garbage collection mechanism of the go language causing the xvalue to not be deleted?

Solution

In Go, a closure gets a reference to (the address of) any variable it closes. QuoteLanguage Reference:

Function literals are closures: they can reference variables defined in surrounding functions. These variables are then shared between surrounding functions and function literals, and they persist as long as they are accessible.

So, in your example:

1. f1 := foo1()

   1. Make the xValue variable exist (the compiler may allocate it on the heap). It will start with a zero value of 0 for its type.
   2. Make the variable x exist and assign it the address of xValue.
   The
   3. defer-red closure runs and assigns the value 2 to xValue.
   4. Returns a closure that closes the variable x.

   This latter point can be a bit tricky: since the returned closure references the variable x, the compiler guarantees that the variable will exist even after foo returns. Since x contains the address of xValue (and is therefore a live reference to it), that address still exists and cannot be garbage collected. Using the same escape analysis method, the compiler guarantees that xValue survives the return of its declared function.

2. You execute the returned closure, which modifies the xValue via the pointer to it - no magic happens here. The other two calls perform the same operation.

To summarize, maybe you're tripping over the C knowledge, once control is returned from the function, any variable declared within the function no longer exists, so any reference to that variable that exists outside the function becomes Invalid. In Go, this is not the case: the language is explicitly defined as safe in this respect: the compiler ensures that any variable has a proper allocation so that when a reference to it is returned (or otherwise communicated) when it was created function calls. From this function calls are made to the outside world.

The above is the detailed content of What is the range of environments contained within a closure?. For more information, please follow other related articles on the PHP Chinese website!