ado.xyz
Blog Courses About

How to Return Multiple Values in Go Functions

April 28, 2020

The Go programming language makes it possible and easy to return multiple values from functions. While most programming languages limit the number of values you can return to just one, with Go, you can return two, three, or really any number of values that will solve your problem.

Let’s take a look at a couple of examples.

Return One Value from a Go Function

The first one we’ll start with is just return a single value.

package main

import "fmt"

func returnOne() string {
    return "Return One"
}

func main() {
  result := returnOne()
  fmt.Println(result) // "Return One"
}

This is a classic example. In our returnOne() function we don’t take any parameters and return just one value that is of type string.

Return Two Values from a Go Function

Let’s turn it up a notch and return two values.

package main

import "fmt"

func returnTwo() (string, string) {
    return "Value One", "Value Two"
}

func main() {
  resultOne, resultTwo := returnTwo()
  fmt.Println(resultOne, ResultTwo) // "Value One Value Two"
}

A couple things change. First, we have to wrap the values we expect back in parenthesis and declare the type we expect. Second, we also have to create two variables in our main() function to capture the two return values sent back. If we were to omit one, our program would not compile.

We have to do something with all the returned values from a function. If we aren’t going to use the data from a returned value we could ignore it but declaring the variable with an _. This would allow us to discard the value, while still accounting for it.

package main

import "fmt"

func returnTwo() (string, string) {
    return "Value One", "Value Two"
}

func main() {
  // Discard the second value returned
  resultOne, _ := returnTwo()
  fmt.Println(resultOne) // "Value One"
}

Alternatively, we could have discarded the first value by using the _ for the first variable declaration.

Return Three or More Values from a Go Function

For our last example, we’ll return three values. We’ll also mix and match the return types to make this example a little more interesting.

package main

import "fmt"

func returnThree() (string, int, bool) {
    return "The year is:", 2020, true
}

func main() {
  resultOne, resultTwo, resultThree := returnThree()

  fmt.Println(resultOne, resultTwo, resultThree) // "The year is: 2020 true"
}

As you can see, we can return as many values from our Go functions as needed to do the job. In practice, you’ll often see functions return the expect value and and error.

Having the ability to return multiple values for our functions unlocks many possibilities but you should still be cautious to not write functions that do too many things. It’s always better to break up functionality into smaller pieces that are more testable and easier to reason about than have monolithic functions that attempt to solve multiple problems. Just because you can, doesn’t mean you should.

Newsletter

Subscribe to the newsletter and be the first to know when I publish new content. No Spam.