Functions: How to define and call functions in GO programming language, passing arguments, and returning values.


Functions are a fundamental concept in programming. They are used to encapsulate a piece of code that performs a specific task, making it reusable and easier to maintain. In this document, we will explore how to define and call functions in the Go programming language, which is a statically typed, compiled language designed for building large-scale, high-performance applications.

Defining Functions in GO

A function in the Go programming language is defined using the func keyword followed by the function name, the parameter list, and the return type (if any). The parameter list contains the input values that the function needs to perform its task. The return type defines the type of value that the function will return to the caller. Here is an example:

func add(x int, y int) int {
    return x + y

In this example, the function name is add, and it takes two integer parameters x and y. It returns an integer value which is the sum of x and y.

Calling Functions in GO

To call a function in Go, you simply use the function name followed by the argument list enclosed in parentheses. The argument list contains the values that you want to pass to the function as input. Here is an example:

result := add(3, 4)

In this example, we are calling the add function with arguments 3 and 4. The result of the function call is then assigned to the variable result.

Passing Arguments in GO

In Go, arguments can be passed by value or by reference. When an argument is passed by value, a copy of the value is made and passed to the function. When an argument is passed by reference, a reference to the original value is passed to the function. Passing by value is the default behavior in Go.

Here is an example of passing arguments by value:

func multiply(x int, y int) int {
    return x * y

result := multiply(3, 4)

In this example, the multiply function takes two integer parameters x and y and returns their product. We are calling the multiply function with arguments 3 and 4, and the result is assigned to the variable result.

Here is an example of passing arguments by reference:

func swap(x *int, y *int) {
    temp := *x
    *x = *y
    *y = temp

a := 3
b := 4
swap(&a, &b)

In this example, the swap function takes two integer pointers x and y, and it swaps their values. We are calling the swap function with the addresses of variables a and b using the & operator.

Returning Values in GO

Functions in Go can return one or more values. To return a value from a function, use the return statement followed by the value(s) to be returned. If a function does not return a value, the return type is void. Here is an example:

func divide(x float64, y float64) (float64, error) {
    if y == 0 {
        return 0, errors.New("division by zero")
    return x / y, nil

result, err := divide(10, 2)

In this example, the divide function takes two float64 parameters x and y, and it returns their quotient and an error if y is equal to 0. We are calling the divide function with arguments 10 and 2, and the result and error (if any) are assigned to the variables result and err, respectively.


Functions are a powerful tool in programming, and Go provides an elegant and efficient way of defining and calling functions. By using functions, you can break down a complex problem into smaller, more manageable pieces, making your code more readable and easier to maintain.

Previous Post

Control Structures in GO Programming Language

Next Post

Arrays and Slices in GO programming language

Related Posts