functions in golang

One of the core features of Go is its support for functions, which are blocks of code that can be executed multiple times with different inputs. In this tutorial, we will be discussing how to work with functions in Golang.

Creating Functions

To create a function in Go, you use the keyword func followed by the function name, a set of parentheses, and a set of curly braces. Inside the curly braces, you can place the code that you want to execute when the function is called. Here is an example of a simple function that takes no inputs and returns no outputs:

func myFunction() {
    fmt.Println("Hello, World!")

You can also create functions that take inputs, known as parameters, and return outputs, known as return values. Here is an example of a function that takes two integers as input and returns their sum:

func add(a int, b int) int {
    return a + b

In the above example, the function add takes two integer inputs, a and b, and returns an integer output. The keyword int is used to specify the data type of the inputs and outputs.

Calling Functions

To call a function in Go, you simply write the function name followed by a set of parentheses. If the function takes inputs, you should pass them inside the parentheses. Here is an example of how you would call the add function from the previous example:

result := add(5, 10)
fmt.Println(result) // Output: 15

In this example, we are calling the add function and passing it the values 5 and 10 as input. The function then adds these values together and returns the result, which we store in the variable result. We then use the fmt.Println function to print the value of result to the console.

Function Variables

Go also supports function variables, which are variables that are only available within the scope of a specific function. These variables are declared inside the function, and they cannot be accessed from outside of the function. Here is an example of how you would create a function variable:

func myFunction() {
    var x int = 5

In this example, we are declaring a variable x inside the myFunction function. The variable is of type integer and is assigned the value 5. We can then use the fmt.Println function to print the value of x to the console.

Recursive Functions

Go also supports recursive functions, which are functions that call themselves. Recursive functions are useful for solving problems that involve repetitive tasks, such as finding the factorial of a number. Here is an example of a recursive function that finds the factorial of a number:

func factorial(n int) int {
    if n == 0 {
        return 1
    return n * factorial(n-1)

In this example, the factorial function takes an integer input n and returns an integer output. The function uses an if statement to check if the input is equal to 0, and if it is, it returns 1. If the input is not 0, the function calls itself with the input decremented by 1. This creates a chain of function calls, each one multiplying the result of the previous call by the current input value, until the input value reaches 0. The final result is the factorial of the original input.

Here is an example of how you would call the factorial function:

result := factorial(5)
fmt.Println(result) // Output: 120

In this example, we are calling the factorial function with the input value of 5. The function will then calculate 54321 and return the result 120.


Go also supports closures, which are functions that can remember the values of variables outside of their scope. Closures are created by returning a function from another function. Here is an example of how you would create a closure:

func adder() func(int) int {
    var x int = 0
    return func(y int) int {
        x += y
        return x

In this example, we have a function adder that returns another function. The returned function takes an integer input y and adds it to the variable x which was defined outside of its scope. We can then assign this returned function to a variable and use it multiple times, it will remember the last value of x

add5 := adder()
fmt.Println(add5(3)) // Output: 3
fmt.Println(add5(2)) // Output: 5

In this example, we are assigning the returned function of adder to a variable add5 and calling it twice, passing it 3 and 2 as input. Each time we call it, it adds the input to the x variable, so the first call returns 3 and the second call returns 5.

These are some of the basic features of working with functions in Golang. With this knowledge, you should be able to create, call, and work with functions in Go, using different types of inputs and outputs, function variables, recursive functions, and closures.

Similar Posts

Leave a Reply

Your email address will not be published. Required fields are marked *