Golang function parameter passing methods and precautions

Abstract In Go language, function parameter passing methods include value passing and reference passing. Passing a copy by value will not affect the original value; passing a reference by reference, modifying the reference will affect the original value. Considerations include performance, concurrency, and readability. In a hash table implementation, pass-by-reference is used to modify the slice contents without copying the entire slice.

Golang function parameter passing method and precautions

In the Go language, the function parameter passing method is similar to other languages, divided into value passing and reference transfer. Understanding the different delivery methods is important to writing efficient and robust code.

Value passing

When a value is passed as a function parameter, a copy of the value is actually passed to the function. This means that any changes made to the copy inside the function will not affect the original value outside the function.

Sample code:

func square(n int) {
    n *= n
}

func main() {
    num := 5
    square(num)
    fmt.Println(num) // 输出：5
}

In the example, the square function receives a copy of num instead of the original Reference to num. Therefore, modifications to the copy in the function do not affect the original value in the main function.

Reference passing

To implement reference passing, you need to use pointer types. When a pointer type is passed as a function parameter, what is actually passed is a reference to the original value. This means that any changes made inside the function to the value pointed to by the reference will affect the original value outside the function.

Sample code:

func square(p *int) {
    *p *= *p
}

func main() {
    num := 5
    square(&num)
    fmt.Println(num) // 输出：25
}

In the example, function square receives a pointer to num. Therefore, modifications to the pointed-to value within the function update the actual value of the original value.

Notes

When using function parameter passing, you need to pay attention to the following:

• Performance: Reference passing has higher performance than value passing overhead since it requires tracking a reference to the original value.
• Concurrency: In concurrent programming, you need to be careful when using pass-by-reference because multiple coroutines may access the same primitive value at the same time, leading to unexpected results.
• Readability: Using pointer type parameters may reduce the readability of the code. Prefer passing by value if possible.

Practical case

Hash table implementation

In hash table implementation, key-value pairs are usually stored in slices or arrays. To avoid copying the entire slice in every Map operation, you can use pass-by-reference to modify the contents of the slice.

Sample code:

type HashTable struct {
    Buckets []*Entry
}

type Entry struct {
    Key   string
    Value interface{}
}

func (h *HashTable) AddOrUpdate(key string, value interface{}) {
    bucket, index := findOrCreateBucket(h, key)

    // 使用 *bucket 来修改切片中的元素
    if index == -1 {
        *bucket = append(*bucket, &Entry{Key: key, Value: value})
    } else {
        (*bucket)[index].Value = value
    }
}

In this case, declare the type of the Buckets field of the hash table as *[ ]*Entry to modify the contents of the slice using reference passing.

The above is the detailed content of Golang function parameter passing methods and precautions. For more information, please follow other related articles on the PHP Chinese website!