Functions in Go

In Go, functions are blocks of code that perform specific tasks, which can be reused throughout the program to save memory, improve readability, and save time. Golang functions may or may not return a value to the caller.

Things to know about functions in Golang

• Function syntax in Golang
• Function declaration
• Call function
• Function arguments
  • Call by value
  • Call by reference

For example:

package main
import "fmt"

// multiply() nhân 2 số nguyên và trả về kết quả
func multiply(a, b int) int {
    return a * b
}

func main() {
    result := multiply(5, 10)
    fmt.Printf("multiplication: %d", result)
}

Result:

multiplication: 50

Function syntax in Golang

func function_name(Parameter-list)(Return_type) {
    // function body...
}

Function declaration

In Go, a function is declared with the func keyword, followed by a name, parameters, and optional return type.

Syntax

func function_name(Parameter-list)(Return_type) {
    // function body...
}

Multiply function example

func multiply(a, b int) int {
    return a * b
}

func: Keyword to declare a function.
function_name: Name of the function, for example: multiply.
Parameter-list: a, b int—the parameters along with their types.
Return_type: int specifies the return type.

Call function

To use a function, simply call it by its name with any necessary arguments. Here, multiply(5, 10) calls the function with 5 and 10 as arguments.

For example

result := multiply(5, 10)
fmt.Printf("Result of multiplication: %d", result)

Function arguments

Go supports two ways to pass parameters to a function: Call by value and Call by reference. By default, Go uses call by value, which means that values ​​are copied and changes inside the function do not affect the caller's variables.

Call by value

In call by value, the values ​​of the arguments are copied into the function parameters, so changes in the function do not affect the original variables.

For example:

package main
import "fmt"

func multiply(a, b int) int {
    a = a * 2 // chỉnh sửa bên trong hàm này
    return a * b
}

func main() {
    x := 5
    y := 10
    fmt.Printf("Before: x = %d, y = %d\n", x, y)
    result := multiply(x, y)
    fmt.Printf("multiplication: %d\n", result)
    fmt.Printf("After: x = %d, y = %d\n", x, y)
}

Result:

Before: x = 5, y = 10
multiplication: 100
After: x = 5, y = 10

Call by reference

In call by reference, pointers are used so that changes inside the function are reflected in the caller's variables.

For example:

package main
import "fmt"

func multiply(a, b *int) int {
    *a = *a * 2 // chỉnh sửa giá trị của a ở địa chỉ bộ nhớ của nó
    return *a * *b
}

func main() {
    x := 5
    y := 10
    fmt.Printf("Before: x = %d, y = %d\n", x, y)
    result := multiply(&x, &y)
    fmt.Printf("multiplication: %d\n", result)
    fmt.Printf("After: x = %d, y = %d\n", x, y)
}

Result

Before: x = 5, y = 10
multiplication: 100
After: x = 10, y = 10