Function Declarations, Arguments, Parameters, and Anonymous Functions in Go

Click to subscribe to my newsletter
Click to follow me on twitter
Click to view my Github

This is the sixth entry of my weekly series Learning Go. Last week I covered the Struct and Interface types. This week I will be talking about Function Declarations, Arguments, Parameters, and Anonymous Functions.

Overview

The role that functions play in Go, or in any programming language, is the same. They exist to perform computation, data fetching, aggregation, and many other utilities. A few notes on functions before we jump into a few examples:

• keep functions small and modular
• parameters are the values the function expects
• arguments are the values that are passed when a function is executed
• everything in Go is passed by value

Function Declaration

There are several ways to create a function. The first one I will cover, is probably the most traditional; however, it is not exclusive to how we declare functions.

Before we jump into an example, let me break down the four pieces of a Function Declaration:

• receiver - specifies the type of parameters that the function receives
• identifier - the name of the function
• parameters - the values that the function expects when it is invoked (executed)
• return types - the type of value that the function will return

Quick note: a receiver is not required. These are used in receiver functions which we will cover later. Another thing to keep in mind, parameters and return types are optional.

If your function does not expect to get any values when it is called, you can leave the parameters empty.

Likewise, if your function does not return a value, you do not need a return type.

Let's look at a basic example of a function declaration, first, without a receiver type, parameters, or a return type.

package main

import (
    "fmt"
)

func main() {
    sayHello()
    // hello!
}

func sayHello() {
    fmt.Println("hello!")
}

• below the func main we declare a new function using the func keyword
• next, we give this function the identifier sayHello
• in between the parentheses () is where your parameters go. We do not have any in this example; however, you still need to have them
• we execute this function inside of main simply by writing the function identifier with a set of parentheses ()

Arguments and Parameters

Why do we need parentheses immediately following our identifier? This is how you would pass values into your function. These values are called arguments. If we do not have any values to pass, we still have to write a set of parentheses, this lets the compiler know that we want to execute this function and that it has no arguments.

Let's create a function that uses arguments and parameters.

package main

import (
    "fmt"
)

func main() {
    myName("martin")
    // hello martin
}

func myName(s string) {
    fmt.Println("hello", s)
}

• much like the first example, we create a new function using the func keyword with the identifier myName
• immediately following our function identifier myName, you will see we put s string between parentheses
• the s is the value we will receive from this function and string tells us that s will be of type string
• inside of mainwe write our function identifier, myName
• immediately following we put the value "martin" of type string inside of the parentheses, this is the function's argument
• myName is then executed and it prints "hello martin"

Return Values

We have seen a few very basic ideas of the role that functions can play in your programs; however, I am confident that you will not use functions just to print values. Let's see an example of a function that returns a value:

package main

import (
    "fmt"
)

func main() {
    n := sayHello("martin")
    fmt.Println(n)
    // hello from martin
}

func sayHello(s string) string {
    return fmt.Sprint("hello from ", s)
}

From a code organization standpoint, there will come a time that you need to assign a variable to the returned value of a function in order to do something else useful with it.

• below func main, we declare a function using the func keyword
• give an identifier of sayHello
• write a single parameter s of type string between parentheses
• then write a return type of string
• using the return keyword, we return the value of s from this function
• inside of func main we declare a new variable n that is equal to the returned value of the sayHello function
• after the function executes, we print the value of n

Multiple Return Values

In Go, it is possible to have more than one value returned from a function. Let's see how that works in an example below:

package main

import (
    "fmt"
)

func main() {
    x, y := isAJedi("obi wan", "kenobi")
    fmt.Println(x, y)
    // obi wan kenobi true
}

func isAJedi(s1, s2 string) (string, bool) {
    a := fmt.Sprint(s1, " ", s2)
    b := true
    return a, b
}

• we declare a new function using the func keyword
• give an identifier of isAJedi
• between the first set of parentheses, we write two parameters: s1 and s2, both of type string
• in the next set of parentheses we have our return types: string and bool
• on the first line, we declare a variable a and assign it to the value of a string that includes the values of s1 and s2
• next, we declare a variable b and assign it to the value true of type bool
• after the return keyword we write the variables a and b
  • our return types are string and bool, order matters; therefore, we can not return a bool value and then a string value
• inside of func main we declare x and y as variables that will be assigned the value of each returned value from isAJedi
• when we print we see that the value of x is obi wan kenobi and the value of y is true

Anonymous Functions

As we have already seen, there are many ways you can create and use a function. An anonymous function is used for when you don't need a function with an identifier:

package main

import (
    "fmt"
)

func main() {
    func() {
        fmt.Println("I'm anonymous!")
    }()
    // I'm anonymous!
}

• inside func main we use the func keyword with
• since we do not have any parameters, we write empty parentheses ()
• to let the compiler know to look inside this function, the function body we write an open bracket {
• inside the function body, using the fmt package, we print the string I'm anonymous!
• to signify our function body is closed we write a closing bracket } on the next line
• following the closing bracket } you will notice we have a set of empty parentheses (), as mentioned previously, this is how we tell the compiler to execute this function
• since we have no arguments these parentheses are empty ()

In Summary

I hope you have enjoyed learning about Function Declarations, Arguments, Parameters, and Anonymous Functions. There is so much more to learn about functions in Go, and I am excited to share more with you in the coming weeks. Next week we will dive into Function Expressions, Callbacks, and Recursive Functions. Can't wait, see you then!