Go Functions#

We use functions to divide our code into smaller chunks to make our code looks clean and easier to understand.

Basically, a function is a block of code that performs a specific task. For example, suppose we want to write code to create a circle and rectangle and color them.

In this case, we can organize our code by creating three different functions:

• function to create a circle
• function to create a rectangle
• function to color

This way, our code will look more organized. Also, we can reuse the same function to color the circle and rectangle. Hence, providing the benefits of code reusability.

#Create a Go Function

In Golang, we use the func keyword to create a function.

func greet(){
  // code
}

Here, greet() is the name of the function (denoted by ()) and code inside {....} indicates the function body.

Let's now create a function that prints Good Morning.

// Program to define a function

package main
import "fmt"

// define a function
func greet() {
  fmt.Println("Good Morning")
}

func main() {

}

When we run this program, we will not get the output.

This is because we are just defining a function. To execute a function, we need to call it first.

Function Call

We use the function's name followed by parenthesis to call a function.

greet()

Now, let's add a function call inside main().

// Program to define a function

package main
import "fmt"

// define a function
func greet() {
  fmt.Println("Good Morning")
}

func main() {

  // function call
  greet()

}

Output

Good Morning

This time the function runs, and we get Good Morning as output.

#Example: Golang Function

package main
import "fmt"

// function to add two numbers
func addNumbers() {
  n1 := 12
  n2 := 8

  sum := n1 + n2
  fmt.Println("Sum:", sum)
}

func main() {
  // function call
  addNumbers()
}

Output

Sum: 20

In the above example, we have created a function named addNumbers(). The function adds two numbers and prints the sum.

Here's how the program works:

#Function Parameters in Golang

In our last example, we have created a function that does a single task, adds two numbers, 12 and 8.

func addNumbers() {
  n1 := 12
  n2 := 8
  sum := n1 + n2
  fmt.Println("Sum:", sum)
}

However, in real projects, we want our functions to work dynamically. That is, instead of adding 12 and 8, the addNumbers() function should be able to add any two numbers.

In this case, we can create functions that accept external values and perform operations on them. These additional parameters are known as function parameters.

#Define Function with Parameters

Here's how we can create a function with parameters:

func addNumbers(n1 int, n2 int) {
  // code
}

Now, the addNumbers() function accepts two parameters: n1 and n2. Here, int denotes that both parameters are of integer type.

To call this function, we need to pass some values (known as function arguments).

// function call
addNumbers(21, 13)

Here, 21 and 13 are the function arguments that are passed to the addNumbers() function.

#Example: Function Parameters

// Program to illustrate function parameters

package main
import "fmt"

// define a function with 2 parameters
func addNumbers(n1 int, n2 int) {
  sum := n1 + n2
  fmt.Println("Sum:", sum)
}

func main() {

  // pass parameters in function call
  addNumbers(21, 13)

}

Output

Sum: 34

Here's how the program works:

The arguments are assigned to the function parameters when we call the function. 21 is assigned to n1 and 13 is assigned to n2.

That's why when we add n1 and n2 inside the function, we get 34 (21 + 13).

#Return Value from Go Function

In our last example, we have printed the value of the sum inside the function itself. However, we can also return value from a function and use it anywhere in our program.

Here's how we can create a Go function that returns a value:

func addNumbers(n1 int, n2 int) int {
  // code
  return sum
}

Here, int before the opening curly bracket { indicates the return type of the function. In this case, int means the function will return an integer value.

And return sum is the return statement that returns the value of the sum variable.

The function returns value to the place from where it is called, so we need to store the returned value to a variable.

// function call
result := addNumbers(21, 13)

Here, we are storing the returned value to the result variable.

#Example: Function Return Value

package main
import "fmt"

// function definition
func addNumbers(n1 int, n2 int) int {
  sum := n1 + n2
  return sum
}

func main() {

  // function call
  result := addNumbers(21, 13)

  fmt.Println("Sum:",result)
}

Output

Sum: 34

In the above example, when the return statement is encountered, it returns the value of sum. The returned value is assigned to the result variable inside main().

Here's how the program works.

The return statement should be the last statement of the function. When a return statement is encountered, the function terminates.

Let's see an example,

package main
import "fmt"

// function definition
func addNumbers(n1 int, n2 int) int {
  sum := n1 + n2
  return sum

  // code after return statement
  fmt.Println("After return statement")
}

func main() {

  // function call
  result := addNumbers(21, 13)
  fmt.Println("Sum:",result)

}

We get a "missing return at the end of function" error as we have added a line after the return statement.

#Return Multiple Values from Go Function

In Go, we can also return multiple values from a function. For example,

// Program to return multiple values from function

package main
import "fmt"

// function definition
func calculate(n1 int, n2 int) (int, int) {
  sum := n1 + n2
  difference := n1 - n2

  // return two values
  return sum, difference
}

func main() {

  // function call
  sum, difference := calculate(21, 13)

  fmt.Println("Sum:", sum, "Difference:", difference)
}

Output

Sum: 34 Difference: 8

In the above example, we have created a function named calculate().

func calculate(n1 int, n2 int) (int, int) {
  ...
}

Here, (int, int) indicates that we are returning two integer values: sum and difference from the function.

Since the function returns two values, we have used two variables while calling the function.

sum, difference = calculate(21, 13);

#Benefits of Using Functions

Here are the benefits of using a function in programming:

#1. Code Reusability

We can reuse the same function multiple times in our program. For example,

// Program to illustrate code reusability in function

package main
import "fmt"

// function definition
func getSquare(num int) {
  square := num * num
  fmt.Printf("Square of %d is %d\n", num, square)
}

// main function
func main() {

  // call function 3 times
  getSquare(3)
  getSquare(5)
  getSquare(10)

}

Output

Square of 3 is 9
Square of 5 is 25
Square of 10 is 100

In the above program, we have created the function named getSquare() to calculate the square of a number.

Here, we are reusing the same function multiple times to calculate the square of different numbers.

#2. Code Readability

Functions help us break our code into chunks to make our program readable and easy to understand. It also makes the code easier to maintain and debug.