Functions are a feature in many different languages. Functions allow us to save pieces of code to reuse at any point in our program. This makes things significantly easier for many tasks. Not only does it decrease the amount that we have to write, it also makes the code more readable. Functions in Go have many specific features that make them particularly useful.

Basic Function Styles in Go

Go supports many different styles of functions. In Go, you can create first-class functions, custom function types, function literals, and functions with multiple return values. You may also use functions as a closure and define high-order functions. We will talk about each of these types of functions one at a time as we work through this tutorial. First, let’s just look at a basic function in Go and how it is structured.

functions in goHere are two simple examples of functions in Go. Our first example just calls the fmt.Println() function inside of it which prints the string “Hello, World” then creates a new line. It takes no arguments and we can simply call it by typing its name followed by a set of parenthesis. Our addition function, allows us to pass two integer values to it. It combines these two values with the addition operator and returns that sum as an integer. 

Notice that we define the types in this function. This serves two main purposes; It allows us to make the function more readable and it makes the function type safe. In this case, our function can only accept integer values and will only return integer values. This removes any unpredictable behavior from the function. Also, we can make this function definition shorter because of its successive type information. Look at the third example for this.

Return Statements in Go and Variadic Functions

We have an explicit return statement in this function. In Go, functions won’t automatically return the last line; we must use the return operator. In this case, we return the sum. We can also use this return operator to return multiple return statements from a function. Let’s look at an example of this.

Go also can make use it’s slice abstraction when we want to pass a non-set amount of arguments to a function. This is what’s called a variadic function. Most of the core functions in Go are variadic, which means that you can pass any number of arguments to them. If we wanted to make a summation function we would use a variadic function to do this.

In this example, we use this triple dot syntax to signify that we can take an arbitrary amount of arguments. It also tells the compiler to make a slice out of this data. For our first execution of sum, we pass nine arguments to it. The function then treats these like a slice of integers. We use the range keyword to iterate through all of the values and we add them all together. We then return a single integer. 

Conclusion

In this post, we took a look at basic functions in Go. We looked at how we can use functions with no arguments or returns, functions that have arguments and/or returns and functions with multiple returns. We also looked at variadic functions in Go. In our next few posts, we will look at recursion and some of the other types of functions in Go.