Do slices or arrays act as a global scope?

Question

I'm still new to programming. Forgive my lack of computer science knowledge. Not sure if this question is specific to Golang or computer science in general...

I always thought that functions do not alter variables/data held outside their own scope unless you use a return statement back into the other scope, or unless they are higher in the hierarchy of scopes. One may argue that functions f1 and f2 in this example are called from a lower scope. However, this still doesn't explain why I'm getting different results for variable num and nums.

package main

import "fmt"

func f1(a int) {
    a = 50 // this will not work, as it shouldn't
}

func f2(a ...int) {
    a[0] = 50 // this will work without return statement
    a[1] = 50 // this will work without return statement
}

func main() {

    num := 2
    nums := []int{2, 2}

    f1(num)
    f2(nums...)

    fmt.Printf("function f1 doesn't affect the variable num and stays: %v\n", num)
    fmt.Printf("function f2 affects the variable nums and results in: %v", nums)

Questions:

1. Why doesn't f2 require a return statement to modify nums like num would within f1?
2. Golang functions are said to pass values (rather than reference), shouldn't that force the function to return copies?
3. Can this happen in other languages? (I think I may have seen this in other languages).

Answer 1

In go, function arguments are passed by value. That means, if you pass an int (like in f1), compiler will pass the value of f1, essentially copying it. If the function takes a *int and you pass &num, then the compiler passes the value of &num, which is a pointer to num. When the function changes *num, the value of the variable outside the function will change. If the function changes num, the pointer value of num will change, and it will point to a different variable.

As a contrast, Java passes all primitive values as value, and all objects by reference. That is, if you pass an int, there is no way for the function to modify the value of that int that is visible to the caller. If you want to pass an int the function can modify, you put that in a class and pass an instance of that class in Java.

A slice (as in f2) contains a pointer to the underlying array. When you call a function with a slice, the slice header (containing a pointer to the underlying array) is copied, so when the function changes the slice elements, the underlying array elements change.

The question of scope is somewhat different. Scope of a function is all the variables it can see. Those are the global variables (if from different packages, exported global variables), function arguments, and if the function is declared nested within another function, all the variables visible in that function at that point.

Answer 2

This is the correct behaviour, since a ...int is equal to a slice e.g.: a []int

func f2(a []int) {
    a[0] = 50
    a[1] = 50
}
func main() {
    b := []int{2, 2}
    f2(b)
    fmt.Println(b) // [50 50]
}

And a slice is a view to the original data, here 'b'.

"Why doesn't f2 require a return statement to modify nums like num would in f1?"

In f2 you are using the slice, which has a pointer to the original array, so f2 can change the outside array.

"Golang functions are said to pass values (not reference), shouldn't that force to return copies? (If the question is related...)"

In f2 the slice itself is passed by value, meaning pointer and length and capacity of the original array.

"Can this happen in other languages? (I think I may have seen this in other langues)"

Too broad to answer, there are many languages and in general if you have a pointer to the outside world array, yes.

---

Edit:

package main

import "fmt"

func sum(a ...int) int {
    s := 0
    for _, v := range a {
        s += v
    }
    return s
}
func f2(a []int) {
    c := make([]int, len(a))
    copy(c, a)
    c[0] = 50
    fmt.Println(sum(c...)) // 52
}
func main() {
    b := []int{2, 2}
    fmt.Println(sum(1, 2, 3, 4)) // 10
    fmt.Println(sum(b...))       // 4

    f2(b)
    fmt.Println(b) // [2 2]
}

Notes:
The sum() function above is a pure function, since it has no side effect.
The new f2 function above is a pure function, since it has no side effect: it makes a copy of a into c then calls the sum.

Answer 3

1 & 2) Both questions can be answered when looking at how slices work in Go. There's a blog article on it.

In general, all variables are passed by value in Go. You can use pointers (e.g. *int for f1) to pass by reference (or more correct, the address of the pointer). However, slices are technically also passed by value.

When we look here, we can get an idea how they work:

type SliceHeader struct {
    Data uintptr
    Len  int
    Cap  int
}

Len and Cap are integers, but Data is a pointer.

When this struct is copied (when passing by value), a copy of Len, Cap and Data will be made. Since Data is a pointer, any modifications made to the value it's pointing to will be visible after your function returns.

You can also read this