Is Golang Pass By Reference

Go Programming

As a software developer, I have always been fascinated by the ways programming languages handle variable passing. In this article, we will explore the concept of pass by reference in the Go programming language, also known as Golang. It’s a topic that has sparked many discussions and debates in the programming community, and I’m excited to delve into the details.

Understanding Pass by Reference

Pass by reference and pass by value are two fundamental ways for a programming language to handle variable passing. In pass by reference, a reference to the variable’s memory address is passed to the function, allowing the function to modify the actual variable. On the other hand, pass by value passes a copy of the variable’s value to the function, ensuring that the original variable remains unchanged.

Golang’s Approach

Now, let’s talk about Golang. In Go, all arguments are passed by value. This means that when you pass a variable to a function, a copy of the variable is passed, and any changes made to the variable inside the function do not affect the original variable in the calling scope. This might lead some to believe that Golang uses pass by value exclusively, but it’s not that simple.

Go does support pointers, which are a way to pass references to variables. When you pass a pointer to a function, you are essentially passing the reference to the original variable, allowing the function to modify the variable directly. This behavior might seem similar to pass by reference, but it’s important to remember that under the hood, Go is still passing the pointer by value.

Code Example

Let’s illustrate this with a code example:

package main

import "fmt"

func addOne(val *int) {
*val = *val + 1

func main() {
num := 5
fmt.Println(num) // Outputs: 6

In the example above, we declare a function addOne that takes a pointer to an integer. Inside the function, we dereference the pointer and increment the value by one. When we call addOne in the main function with &num, we are passing a reference to the variable num

My Take

As I reflect on Golang's approach to variable passing, I find it to be a pragmatic balance between the simplicity of pass by value and the flexibility of pass by reference. By leveraging pointers, Golang provides the ability to work with references while maintaining the safety and predictability of pass by value.


In conclusion, Golang uses pass by value for all variable passing, but the presence of pointers allows for a form of pass by reference behavior. Understanding this distinction is crucial for writing efficient and predictable code in Golang. As I continue to explore the intricacies of Golang and other programming languages, the concept of variable passing will remain a fascinating area of study.