# Function in Go with Examples

Last updated Oct 11, 2021

In this Go tutorial we will learn about functions in Go and different types of functions.

Function is a component that can be used to make certain code is reusable. This is the basic syntax to create a function in Go.

 ```func func_name(arg_name type, ..) return_type { // code.. }```

There are two main types of function including void function (function without return value) and function with return value.

## Void function (function without return value)

In this example, the `sum()` function is created to sum two numbers.

 ```package main import ( "fmt" ) func main() { sum(4, 5) } // create a sum function with two integers as an argument func sum(a int32, b int32) { var result int32 = a + b fmt.Println("Result: ", result) }```

Output

``````Result:  9
``````

Based on the code above, the `sum()` function is called. Then, the sum result is printed out.

## Function with Return Value

In Go, the function can return single value or two values. In this example, the `average()` function is created to calculate average from many data.

 ```package main import "fmt" func main() { // create a slice of int var data []int = []int{1, 2, 3, 4, 5} // call the average function var result int = average(data) // print out the average result fmt.Println("Average result: ", result) } func average(data []int) int { var sum int = 0 // calculate the sum of all data for _, v := range data { sum += v } // calculate the average var result int = sum / len(data) // return the average result return result }```

Output

``````Average result:  3
``````

Based on the code above, the `average()` function is called. The `average()` function returns a value with `int` data type then this value is stored inside `result` variable in `main()` function.

The function can also returns two values. In this example, the `simplePow()` function is created.

 ```package main import ( "fmt" "math" ) func main() { // call the simplePow function // because this function returns two values // the return values are assigned in two variables result, err := simplePow(2, 3) // if error exists, show the error message if err != nil { fmt.Println("Error occurred: ", err.Error()) } // print out the result fmt.Println("Pow result: ", result) } // create simplePow function with two return values func simplePow(x, y float64) (float64, error) { // if y is not positive number if y < 0 { // throw an error return 0, fmt.Errorf("y must be positive number") } // return the pow result and nil // nil means empty or error is not exists return math.Pow(x, y), nil }```

Output

``````Pow result:  8
``````

## What are Variadic Arguments in Go Lang

Variadic arguments is an argument that has a flexible size. This is the basic syntax of variadic arguments.

``````arg_name ...data_type
``````

In this example, the `sum()` function is using variadic arguments.

 ```package main import "fmt" func main() { // call sum function with two parameters var resultOne int = sum(2, 3) // call sum function with five parameters var resultTwo int = sum(1, 2, 3, 4, 5) // print out the results fmt.Println("result from resultOne: ", resultOne) fmt.Println("result from resultTwo: ", resultTwo) } // create sum function with variadic arguments func sum(xi ...int) int { var result int = 0 for _, v := range xi { result += v } return result }```

Output

``````result from resultOne:  5
result from resultTwo:  15
``````

Based on the code above, the `sum()` function is created with variadic arguments to calculate the sum of all numbers in argument. Because of using variadic arguments, the `sum()` function can be called with flexible number of parameters.

Variadic arguments is only allowed in the last part of the argument section in function.

 ```// true func myFunc(a int, xi ...int) int { } // false, throw an error func coolFunc(xi ...int, a int) { }```

## Recursive Function in Go

Recursive function is a function that call a function itself in execution. Usually, recursive function is used to solve many problems like factorial number calculation.

In this example, the factorial number calculation is using recursive function.

 ```package main import "fmt" func main() { // call the factorial function var result int = factorial(5) // print out the result fmt.Println("Result of factorial 5: ", result) } // create a factorial function func factorial(n int) int { if n == 0 || n == 1 { return 1 } else { return n * factorial(n-1) } }```

Output

``````Result of factorial 5:  120
``````

Based on the code above, there are two main components in recursive function:

• Base case: base case is a case when the function is stopped. The base case of the `factorial()` function is if the value of `n` equals 0 or 1.

• Recursive case: recursive case is a case when the function is executed. The recursive case of the `factorial()` function is `return n * factorial(n-1)`.

The `factorial()` function works like this:

 ```factorial(5) = 5 * factorial(4) = 5 * 4 * factorial(3) = 5 * 4 * 3 * factorial(2) = 5 * 4 * 3 * 2 * factorial(1) = 5 * 4 * 3 * 2 * 1 = 120```

## Anonymous Function

Anonymous function is also available in Go. In this example, the anonymous function is created then stored in `sum` variable.

 ```package main import ( "fmt" ) func main() { // create a func then store in sum variable sum := func(a, b int) int { return a + b } // call the function fmt.Println("Result: ", sum(4, 4)) }```

Output

``````Result:  8
``````

Based on the code above, the anonymous function is called based on a variable that store an anonymous function.

The anonymous function can be executed directly. In this example, the anonymous function is created then executed directly.

 ```package main import ( "fmt" ) func main() { // create a function then execute directly func(a, b int) { var result int = a * b fmt.Println("The result: ", result) }(4, 5) }```

Output

``````The result:  20
``````

Based on the code above, the anonymous function is created to perform multiplication of two numbers. The function is executed directly with two parameters that assigned after function declaration `(4, 5)`.

## What are Higher-order Functions in Go Lang?

The higher-order function also available in Go. Higher-order function basically means a function can become an argument in another function or also known as callback.

Notice that Go is not designed for functional programming approach. In this example, the higher-order function is used in `mapper()` function.

 ```package main import ( "fmt" "strings" ) func main() { // create a slice of strings var items []string = []string{"my", "cool", "sample", "text"} // call the mapper() function with two parameters // the first parameter is a function with that returns string // the second parameter is a slice of strings var mapResult []string = mapper(func(item string) string { return strings.ToUpper(item) }, items) fmt.Println("Result from mapper: ", mapResult) } func mapper(callback func(item string) string, items []string) []string { // create an empty slice of strings called result var result []string = []string{} // execute the callback then add to result for _, v := range items { result = append(result, callback(v)) } // return the map result return result }```

Output

``````Result from mapper:  [MY COOL SAMPLE TEXT]
``````

Based on the code above, the `mapper()` function is created with two arguments. The first argument is a callback function that will be executed inside `mapper()` function. The callback function is a function with string as an argument that returns string. The second argument in `mapper()` function is a slice of string. The `mapper()` result is stored inside `mapResult` variable.

## Other Example using Function

The function can be used to reduce duplicate codes. This is the sample code.

 ```func generateCode(text string) string { // perform simple validation if len(text) == 0 && text == "" { fmt.Println("Invalid input") return "" } var code string = strings.Split(text, "") return code } func convertToUppercase(text string) string { // perform simple validation // this code is a duplicate if len(text) == 0 && text == "" { fmt.Println("Invalid input") return "" } return strings.ToUpper(text) ```
``````}
``````

Based on the code above, there is a duplicate code. This code can be wrapped inside a function that can be reused in other code.

 ```func generateCode(text string) string { // call the validation() function var isNotValid bool = validation(text) if isNotValid { return "" } var code string = strings.Split(text, "") return code } func convertToUppercase(text string) string { // call the validation() function var isNotValid bool = validation(text) if isNotValid { return "" } return strings.ToUpper(text) } // create a function for validation func validation(text string) bool { if len(text) == 0 && text == "" { fmt.Println("Invalid input") return false } return true }```

 Article Contributed By : 118 Views