Functions are one of the most important building blocks in Go programming.
A function is a reusable block of code designed to perform a specific task. Instead of writing the same logic again and again, you can place that logic inside a function and call it whenever needed.
Functions help make Go programs:
- Easier to read
- Easier to reuse
- Easier to test
- Easier to maintain
- Better organized
In this beginner’s guide, you will learn how Go functions work, how to create and call them, how parameters and return values work, how to return multiple values, how variadic functions work, and how anonymous functions and closures are used.
What Is a Function in Go?
A function is a named block of code that performs a specific task.
A basic Go function looks like this:
func greet() {
fmt.Println("Hello!")
}
Here:
func
is the keyword used to create a function.
greet
is the function name.
()
contains function parameters.
{
}
contains the function body.
Basic Function Syntax in Go
The basic syntax is:
func functionName() {
// code
}
Example:
func sayHello() {
fmt.Println("Hello, Go!")
}
This creates the function, but the function does not run automatically.
You need to call it.
How to Call a Function
To execute a function, write its name followed by parentheses.
Example:
sayHello()
Complete example:
package main
import "fmt"
func sayHello() {
fmt.Println("Hello, Go!")
}
func main() {
sayHello()
}
Output:
Hello, Go!
Why Do We Use Functions?
Suppose you want to print the same welcome message several times.
Without a function:
fmt.Println("Welcome to Go")
fmt.Println("Welcome to Go")
fmt.Println("Welcome to Go")
With a function:
func welcome() {
fmt.Println("Welcome to Go")
}
Now you can call it whenever needed:
welcome()
welcome()
welcome()
This reduces repeated code.
The main() Function
Every executable Go program starts from the main() function inside the main package.
Example:
package main
import "fmt"
func main() {
fmt.Println("Program started")
}
The function:
func main()
is special.
When the program starts, Go begins execution from main().
Function with Parameters
Functions become more useful when they can receive values.
These values are called parameters.
Example:
func greet(name string) {
fmt.Println("Hello", name)
}
Now call:
greet("John")
Output:
Hello John
Here:
name string
is the parameter.
John
is the argument passed to the function.
Parameter vs Argument
Beginners often confuse these terms.
In:
func greet(name string) {
}
name is a parameter.
When you call:
greet("John")
"John" is an argument.
A parameter is defined in the function.
An argument is the actual value supplied when calling it.
Function with Multiple Parameters
A function can accept multiple parameters.
Example:
func introduce(name string, age int) {
fmt.Println("Name:", name)
fmt.Println("Age:", age)
}
Call:
introduce("John", 25)
Output:
Name: John
Age: 25
Parameters with the Same Type
If multiple consecutive parameters have the same type, you can write the type once.
Instead of:
func add(a int, b int) {
}
you can write:
func add(a, b int) {
}
Example:
func add(a, b int) {
fmt.Println(a + b)
}
Call:
add(10, 20)
Output:
30
Function Return Values
Functions can return values.
Example:
func add(a, b int) int {
return a + b
}
Here:
int
after the parameter list means the function returns an integer.
Usage:
result := add(10, 20)
fmt.Println(result)
Output:
30
Understanding the return Keyword
The return keyword sends a value back to the caller.
Example:
func multiply(a, b int) int {
return a * b
}
Call:
result := multiply(5, 4)
Now:
result
contains:
20
Complete Return Value Example
package main
import "fmt"
func calculateTotal(price float64, quantity int) float64 {
return price * float64(quantity)
}
func main() {
total := calculateTotal(99.99, 2)
fmt.Println("Total:", total)
}
Output:
Total: 199.98
Multiple Return Values in Go
Go functions can return more than one value.
This is an important feature of the language.
Example:
func calculate(a, b int) (int, int) {
sum := a + b
difference := a - b
return sum, difference
}
Usage:
sum, difference := calculate(10, 5)
Print:
fmt.Println(sum)
fmt.Println(difference)
Output:
15
5
Why Are Multiple Return Values Useful?
Multiple return values are frequently used when a function needs to return:
Result + Error
For example:
value, err := someFunction()
This pattern appears throughout Go programming.
Function Returning Result and Error
Example:
package main
import (
"errors"
"fmt"
)
func divide(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("cannot divide by zero")
}
return a / b, nil
}
func main() {
result, err := divide(10, 2)
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Println("Result:", result)
}
Output:
Result: 5
If:
divide(10, 0)
is called, the function returns an error.
Ignoring a Return Value
Sometimes you do not need every returned value.
You can use the blank identifier:
_
Example:
sum, _ := calculate(10, 5)
Now the second return value is intentionally ignored.
Named Return Values
Go allows return values to be named.
Example:
func calculate(a, b int) (sum int, difference int) {
sum = a + b
difference = a - b
return
}
Here:
sum
difference
are named return variables.
The final:
return
returns their current values.
Should Beginners Use Named Returns?
Named return values can be useful in some functions, but overusing them can make code harder to understand.
For simple functions, this is often clearer:
func add(a, b int) int {
return a + b
}
instead of:
func add(a, b int) (result int) {
result = a + b
return
}
Use whichever version keeps the code easier to read.
Functions Without Parameters
Not every function needs input.
Example:
func showMessage() {
fmt.Println("Welcome!")
}
Call:
showMessage()
Functions Without Return Values
A function does not need to return anything.
Example:
func printUser(name string) {
fmt.Println("User:", name)
}
This function receives a parameter but does not return a value.
Local Variables Inside Functions
Variables created inside a function are local to that function.
Example:
func showUser() {
name := "John"
fmt.Println(name)
}
The variable:
name
is available only inside showUser().
You normally cannot access it from another function.
Function Scope Example
package main
import "fmt"
func showMessage() {
message := "Hello from function"
fmt.Println(message)
}
func main() {
showMessage()
}
The message variable exists only inside showMessage().
Passing Variables to Functions
You can create a variable and pass it to a function.
Example:
func greet(name string) {
fmt.Println("Hello", name)
}
func main() {
userName := "John"
greet(userName)
}
Output:
Hello John
Go Passes Arguments by Value
In Go, function arguments are passed by value.
This means the function receives a copy of the value.
Example:
package main
import "fmt"
func changeNumber(number int) {
number = 100
}
func main() {
number := 10
changeNumber(number)
fmt.Println(number)
}
Output:
10
The original value does not change.
Changing a Value Using a Pointer
If you want a function to modify the original variable, you can pass a pointer.
Example:
package main
import "fmt"
func changeNumber(number *int) {
*number = 100
}
func main() {
number := 10
changeNumber(&number)
fmt.Println(number)
}
Output:
100
Here:
&number
passes the address of the variable.
*number
accesses the value through the pointer.
Pointers are a separate Go topic, so beginners only need to understand this basic idea for now.
Passing Structs to Functions
You can pass structs as function parameters.
Example:
package main
import "fmt"
type User struct {
Name string
Age int
}
func showUser(user User) {
fmt.Println("Name:", user.Name)
fmt.Println("Age:", user.Age)
}
func main() {
user := User{
Name: "John",
Age: 25,
}
showUser(user)
}
Returning a Struct from a Function
Functions can also return structs.
Example:
type User struct {
Name string
Age int
}
func createUser(name string, age int) User {
return User{
Name: name,
Age: age,
}
}
Usage:
user := createUser("John", 25)
Passing Slices to Functions
Slices can be passed to functions.
Example:
func printNumbers(numbers []int) {
for _, number := range numbers {
fmt.Println(number)
}
}
Usage:
numbers := []int{10, 20, 30}
printNumbers(numbers)
Output:
10
20
30
Returning a Slice
A function can also return a slice.
Example:
func getNumbers() []int {
return []int{10, 20, 30}
}
Call:
numbers := getNumbers()
Print:
fmt.Println(numbers)
Output:
[10 20 30]
Variadic Functions in Go
A variadic function can accept a variable number of arguments.
The syntax uses:
...
Example:
func sum(numbers ...int) int {
total := 0
for _, number := range numbers {
total += number
}
return total
}
Now you can call:
sum(10, 20)
or:
sum(10, 20, 30, 40)
Variadic Function Example
package main
import "fmt"
func sum(numbers ...int) int {
total := 0
for _, number := range numbers {
total += number
}
return total
}
func main() {
fmt.Println(sum(10, 20))
fmt.Println(sum(10, 20, 30, 40))
}
Output:
30
100
Passing a Slice to a Variadic Function
Suppose you have:
numbers := []int{10, 20, 30}
You can pass the slice values to a variadic function using:
sum(numbers...)
Example:
fmt.Println(sum(numbers...))
Output:
60
Anonymous Functions
Go allows functions without names.
These are commonly called anonymous functions or function literals.
Example:
func() {
fmt.Println("Hello")
}()
The final:
()
immediately calls the function.
Store a Function in a Variable
Because functions are values in Go, you can store one in a variable.
Example:
greet := func() {
fmt.Println("Hello!")
}
Then call:
greet()
Complete example:
package main
import "fmt"
func main() {
greet := func() {
fmt.Println("Hello!")
}
greet()
}
Anonymous Function with Parameters
Example:
add := func(a, b int) int {
return a + b
}
Call:
result := add(10, 20)
Output:
30
Functions as Values
Functions can be assigned to variables.
Example:
func add(a, b int) int {
return a + b
}
func main() {
operation := add
result := operation(10, 20)
fmt.Println(result)
}
Output:
30
Passing a Function to Another Function
A function can accept another function as a parameter.
Example:
func calculate(a, b int, operation func(int, int) int) int {
return operation(a, b)
}
Create another function:
func add(a, b int) int {
return a + b
}
Usage:
result := calculate(10, 20, add)
Output:
30
This concept becomes useful in more advanced Go programs.
Returning a Function
A function can also return another function.
Example:
func multiplier(factor int) func(int) int {
return func(number int) int {
return number * factor
}
}
Usage:
double := multiplier(2)
fmt.Println(double(5))
Output:
10
Closures in Go
A closure is a function that remembers variables from the surrounding scope.
Example:
func counter() func() int {
count := 0
return func() int {
count++
return count
}
}
Usage:
next := counter()
fmt.Println(next())
fmt.Println(next())
fmt.Println(next())
Output:
1
2
3
The inner function continues to access:
count
even after counter() has returned.
Recursive Functions
A recursive function calls itself.
Example:
func countdown(number int) {
if number == 0 {
return
}
fmt.Println(number)
countdown(number - 1)
}
Call:
countdown(5)
Output:
5
4
3
2
1
Factorial Using Recursion
A common recursion example is factorial.
func factorial(n int) int {
if n <= 1 {
return 1
}
return n * factorial(n-1)
}
Usage:
fmt.Println(factorial(5))
Output:
120
Beginners should understand recursion, but normal loops are often simpler for many tasks.
What Is defer in a Function?
The defer keyword delays a function call until the surrounding function is about to return.
Example:
package main
import "fmt"
func main() {
defer fmt.Println("Second")
fmt.Println("First")
}
Output:
First
Second
Multiple defer Calls
When multiple deferred calls are used, they run in last-in, first-out order.
Example:
package main
import "fmt"
func main() {
defer fmt.Println("One")
defer fmt.Println("Two")
defer fmt.Println("Three")
fmt.Println("Start")
}
Output:
Start
Three
Two
One
defer is commonly useful for cleanup operations such as closing files or connections.
Methods vs Functions
Go also supports methods.
A function is declared normally:
func greet(name string) {
}
A method is associated with a type through a receiver.
Example:
type User struct {
Name string
}
func (u User) greet() {
fmt.Println("Hello", u.Name)
}
Usage:
user := User{Name: "John"}
user.greet()
Methods deserve their own detailed topic, but the main difference is:
Function → Independent
Method → Associated with a type
Function Naming in Go
Function names should clearly describe what the function does.
Good examples:
calculateTotal()
createUser()
getProduct()
sendEmail()
validateInput()
Avoid unclear names such as:
doThing()
abc()
x()
unless the function is extremely small and the short name is clearly understandable from context.
Exported Functions
Function names beginning with an uppercase letter are exported from their package.
Example:
func CalculateTotal() {
}
This function can be accessed from another package when the package itself is imported.
A lowercase function:
func calculateTotal() {
}
is not exported outside its package.
This capitalization rule is very important in Go.
Small Functions vs Large Functions
Functions should usually focus on one clear responsibility.
Instead of creating one very large function that:
Reads input
Validates user
Saves database record
Sends email
Logs activity
Returns response
you can divide responsibilities into smaller functions.
For example:
validateUser()
saveUser()
sendWelcomeEmail()
This can improve readability and testing.
Complete Function Example
Here is a practical beginner example:
package main
import "fmt"
func calculateSubtotal(price float64, quantity int) float64 {
return price * float64(quantity)
}
func calculateDiscount(subtotal float64) float64 {
if subtotal >= 1000 {
return subtotal * 0.10
}
return 0
}
func calculateTotal(subtotal, discount float64) float64 {
return subtotal - discount
}
func main() {
price := 600.0
quantity := 2
subtotal := calculateSubtotal(price, quantity)
discount := calculateDiscount(subtotal)
total := calculateTotal(subtotal, discount)
fmt.Println("Subtotal:", subtotal)
fmt.Println("Discount:", discount)
fmt.Println("Total:", total)
}
Output:
Subtotal: 1200
Discount: 120
Total: 1080
This example shows how a program can be separated into smaller reusable functions.
Common Beginner Mistakes with Functions
Forgetting to Call the Function
Creating a function does not automatically execute it.
This:
func greet() {
fmt.Println("Hello")
}
only defines the function.
You still need:
greet()
Passing the Wrong Type
Suppose:
func showAge(age int) {
}
This is valid:
showAge(25)
This is not:
showAge("25")
because "25" is a string, not an integer.
Wrong Number of Arguments
Suppose:
func add(a, b int) {
}
You must provide two arguments:
add(10, 20)
Calling:
add(10)
causes an error.
Forgetting a Return Value
Suppose the function says it returns an integer:
func add(a, b int) int {
}
The function must return an appropriate value.
Correct:
func add(a, b int) int {
return a + b
}
Returning the Wrong Type
This is invalid:
func getAge() int {
return "25"
}
The function declares:
int
as its return type but returns a string.
Correct:
func getAge() int {
return 25
}
Confusing Print and Return
These are different.
Printing:
func add(a, b int) {
fmt.Println(a + b)
}
Returning:
func add(a, b int) int {
return a + b
}
With a return value, the caller can store and reuse the result.
Example:
result := add(10, 20)
fmt.Println(result * 2)
Best Practices for Go Functions
Use descriptive function names.
Keep functions focused on one responsibility.
Avoid making functions unnecessarily large.
Use parameters instead of depending heavily on global variables.
Return errors when an operation can fail.
Keep return values clear and predictable.
Avoid unnecessary named returns when normal returns are easier to read.
Use comments for exported functions and complex logic when needed.
Prefer simple code over overly clever function patterns.
Beginner Function Practice Examples
Try creating functions for:
Add two numbers
Subtract two numbers
Calculate area
Convert Celsius to Fahrenheit
Check even or odd
Calculate discount
Find maximum value
Print user information
Calculate average
Validate age
For example:
func isEven(number int) bool {
return number%2 == 0
}
Usage:
fmt.Println(isEven(10))
Output:
true
Simple Maximum Function
func max(a, b int) int {
if a > b {
return a
}
return b
}
Usage:
fmt.Println(max(10, 20))
Output:
20
Celsius to Fahrenheit Function
func celsiusToFahrenheit(celsius float64) float64 {
return (celsius * 9 / 5) + 32
}
Usage:
fmt.Println(celsiusToFahrenheit(25))
Output:
77
Go Functions Quick Reference
Basic function:
func greet() {
fmt.Println("Hello")
}
Function with parameter:
func greet(name string) {
fmt.Println("Hello", name)
}
Function returning value:
func add(a, b int) int {
return a + b
}
Multiple returns:
func calculate(a, b int) (int, int) {
return a + b, a - b
}
Variadic function:
func sum(numbers ...int) int {
total := 0
for _, number := range numbers {
total += number
}
return total
}
Anonymous function:
greet := func() {
fmt.Println("Hello")
}
Frequently Asked Questions
What is a function in Go?
A function is a reusable block of code that performs a specific task.
Which keyword is used to create a Go function?
Go uses:
func
What is the main function in Go?
main() is the starting function of an executable Go program inside the main package.
Can Go functions take parameters?
Yes. Functions can take one or multiple parameters.
Can Go functions return values?
Yes. A function can return one or more values.
Can Go return multiple values?
Yes. Multiple return values are a built-in Go feature and are commonly used for result-and-error patterns.
What does return do?
return ends the function and sends one or more values back to the caller.
What is a variadic function?
A variadic function can accept a variable number of arguments.
Example:
func sum(numbers ...int)
Can functions be stored in variables?
Yes. Functions are values in Go and can be assigned to variables.
What is an anonymous function?
An anonymous function is a function without a declared name.
What is a closure?
A closure is a function that can access and retain variables from its surrounding scope.
What is recursion?
Recursion occurs when a function calls itself.
What is the difference between a function and a method?
A normal function is independent, while a method is associated with a type through a receiver.
Conclusion
Functions are essential to writing clean and reusable Go programs.
The simplest function looks like:
func greet() {
fmt.Println("Hello")
}
As you progress, functions can accept parameters:
func greet(name string)
return values:
func add(a, b int) int
or return multiple values:
func calculate(a, b int) (int, int)
Go also supports useful function features such as:
Variadic functions
Anonymous functions
Closures
Recursion
Functions as values
Multiple return values
defer
As a beginner, focus first on normal functions, parameters, arguments, and return values. Once these concepts are comfortable, move on to multiple returns, error handling, variadic functions, anonymous functions, and closures.
A strong understanding of functions will make later Go topics such as structs, methods, interfaces, APIs, and backend development much easier to learn.
