A function is a self-contained block of code that can take inputs (parameters), perform some operations on them, and then produce a result (output).

Defining and Calling a Function

To define a function, we use the func keyword:

func example() {
	
}

A function lets us write a part of the program only once and call it whenever we need it.

package main

import "fmt"

func main() {
	hello()
	hello()
	hello()
}

func hello() {
	fmt.Println("hello world")
}

In the example above, we defined the hello function once and called it 3 times, which causes the text hello world to be printed to the screen three times.

Input and Output Parameters

A function can accept one or more values as input (parameters). A function's parameters, or inputs, are variables separated from each other by commas.

package main

import "fmt"

func main() {
	introduce("John Doe", 20)
	introduce("Alex Martini", 30)
	introduce("Mahdi Khanzadi", 31)
}

func introduce(name string, age int) {
	fmt.Printf("%s is %d years old\n", name, age)
}

In the example above, we defined the introduce function, which prints the values name and age to the screen. We called this function three times with different values.

The return statement ends the function's execution and also returns values. To return values from a function's output, you need to specify the values' types.

package main

import (
	"fmt"
)

func main() {
	halt()

	introduction := introduce("Mahdi Khanzadi", 31)
	fmt.Println(introduction)
}

func halt() {
	fmt.Println("hello")
	return
	fmt.Println("middle")
}

func introduce(name string, age int) string {
	return fmt.Sprintf("%s is %d years old", name, age)
}

In the example above, the last line of the halt function doesn't run, because the return before it exits the function.

In Go, a function can return more than one value. When calling a function, if you don't need one or more of the returned values, you can ignore them using _.

package main

import (
	"fmt"
)

func main() {
	name, _ := user()

	fmt.Println(name)
}

func user() (string, int) {
	return "Mahdi Khanzadi", 31
}

Just like input parameters, output parameters can also be named. If you name the output parameters, calling return ends the function and returns the values of the output parameters.

package main

import (
	"fmt"
)

func main() {
	name, age := user()

	fmt.Println(name, age)
}

func user() (name string, age int) {
	name = "John Doe"
	age = 20

	return
}

In the example above, on the last line of the user function, we called return with no arguments at all, which returns the values of name and age as output.