Go Functions

In Go, functions are self-contained blocks of code that perform a specific task or return a value. They are a fundamental building block of any Go program and can be defined and called to execute a set of instructions. Here are some key points about Go functions:

  1. Function Declaration:
   func functionName(parameters) returnType {
       // Function body
       // Code to be executed
       // Return statement (optional)
  • functionName is the name of the function.
  • parameters are the input values that the function can accept (optional).
  • returnType is the type of value that the function returns (optional).
  1. Function Call:
  • functionName is the name of the function to be called.
  • arguments are the values passed to the function (if it accepts parameters).
  1. Function Return:
  • A function can return a single value or multiple values separated by commas.
  • Use the return statement followed by the value(s) to be returned.
  • If a return type is specified in the function declaration, the function must return a value of that type.
  1. Example of a simple function:
   func add(a, b int) int {
       return a + b
  • The add function takes two integers as parameters (a and b).
  • It returns the sum of a and b as an integer.
  1. Example of calling a function:
   result := add(3, 4)
   fmt.Println(result) // Output: 7
  • The add function is called with arguments 3 and 4.
  • The returned value, 7, is stored in the result variable.
  • The result is then printed using the fmt.Println function.

Functions in Go can be used for various purposes, including code organization, code reuse, and modularity. They play a crucial role in structuring and implementing the logic of a program.

Go Function Parameters and Arguments

In Go, functions can accept parameters, which are placeholders for values that are passed into the function when it is called. These values are referred to as arguments. Parameters allow functions to receive inputs and operate on them within the function’s body. Here are some key points about function parameters and arguments in Go:

  1. Parameter Declaration:
  • Parameters are declared within the parentheses of the function declaration.
  • Each parameter consists of a name followed by its type.
  • Multiple parameters are separated by commas.
   func functionName(param1 type1, param2 type2, ...) {
       // Function body
       // Code that uses the parameters
  1. Argument Passing:
  • When calling a function, arguments are provided in the same order as the corresponding parameters in the function declaration.
  • Arguments can be literals, variables, or expressions that evaluate to the expected parameter types.
   functionName(arg1, arg2, ...)
  1. Example of a function with parameters:
   func greet(name string) {
       fmt.Println("Hello, " + name + "!")
  • The greet function takes a single parameter name of type string.
  1. Example of calling a function with arguments:
  • The greet function is called with the argument "Alice".
  • The value "Alice" is passed to the name parameter within the function.
  1. Multiple Parameters:
  • Functions can have multiple parameters of different types.
   func calculateSum(a int, b int) {
       sum := a + b
       fmt.Println("Sum:", sum)
  • The calculateSum function takes two integer parameters a and b.
  1. Variadic Parameters:
  • Go supports variadic parameters, which allow a function to accept a variable number of arguments of the same type.
  • Variadic parameters are declared using the ... syntax before the parameter type.
  • Inside the function, the variadic parameter behaves like a slice.
   func calculateSum(numbers ...int) {
       sum := 0
       for _, num := range numbers {
           sum += num
       fmt.Println("Sum:", sum)
  • The calculateSum function can accept any number of integer arguments.

Function parameters and arguments provide a flexible way to pass data into functions and make them more reusable. They allow functions to operate on different inputs and produce different results based on the provided arguments.

Go Function Returns

In Go, functions can have return values that provide a way to communicate the result or computed data back to the caller. Return values allow functions to produce output or perform calculations that can be used in the calling code. Here are some key points about function returns in Go:

  1. Return Type Declaration:
  • The return type of a function is specified after the parameter list in the function declaration.
  • A function can have a single return type or multiple return types separated by commas.
   func functionName(parameters) returnType {
       // Function body
       // Code that performs computations
       return value // Return statement
  1. Single Return Value:
  • A function can return a single value of a specific type.
  • Use the return statement followed by the value to be returned.
   func getSum(a, b int) int {
       return a + b
  1. Multiple Return Values:
  • Go functions can return multiple values of different types.
  • Multiple return values are enclosed in parentheses and separated by commas.
   func swap(a, b int) (int, int) {
       return b, a
  1. Named Return Values:
  • Go allows specifying named return values in the function declaration.
  • Named return values act as variables within the function body and are initialized to their zero values.
  • The return statement without explicit values returns the named return values.
   func divide(a, b float64) (quotient, remainder float64) {
       quotient = a / b
       remainder = a % b
       return // Returns quotient and remainder
  1. Empty Return:
  • A function can have an empty return statement to terminate the function without returning any value.
   func greet() {
       return // Empty return
  1. Ignoring Return Values:
  • If a function returns one or more values, but you are not interested in using them, you can use the blank identifier _ to discard the values.
   func processData(data []int) {
       // Process the data

   // Ignoring the return value
   _ = processData(inputData)
  1. Calling Functions with Return Values:
  • When calling a function with return values, you can assign the returned values to variables.
   sum := getSum(3, 4)
   fmt.Println(sum) // Output: 7

   a, b := swap(5, 10)
   fmt.Println(a, b) // Output: 10 5

Functions with return values enable code reuse and allow functions to produce meaningful results. They provide a way to pass data back from the function to the calling code, enabling further processing or decision making based on the returned values.

Named Return Values

In Go, named return values allow you to assign names to the return types in the function declaration. This feature provides several benefits and can improve the readability and clarity of your code. Here are some key points about named return values in Go:

  1. Declaration:
  • Named return values are specified after the list of parameters in the function declaration, just like regular return types.
  • You can assign names to one or more return types.
   func functionName(parameters) (returnValue1 type1, returnValue2 type2, ...) {
       // Function body
       // Code that performs computations
       return value1, value2, ...
  1. Initialization:
  • Named return values act as variables within the function body.
  • They are automatically initialized to their zero values based on their types.
  • You can directly assign values to named return values during the execution of the function.
   func calculateSum(a, b int) (sum int) {
       sum = a + b
  1. Return Statement:
  • You can use a simple return statement without explicitly specifying the values to return.
  • The named return values are automatically returned.
   func calculateSum(a, b int) (sum int) {
       sum = a + b
  1. Benefit of Named Return Values:
  • Improved Readability: By assigning names to return values, you provide context and make the returned values more descriptive.
  • Clearer Intent: Named return values document the purpose and meaning of the returned values, making the function’s behavior more explicit.
  • Simplified Return Statements: You don’t need to explicitly specify the values to return if you’re using named return values. It simplifies the return statements.
  1. Example:
   func divide(a, b float64) (quotient, remainder float64) {
       quotient = a / b
       remainder = a % b
       return // Returns quotient and remainder

Named return values are especially useful when a function has multiple return types or when the returned values need to be modified during the function’s execution. They improve the readability and maintainability of your code by providing clear and self-explanatory names for the return values.

Store the Return Value in a Variable

In Go, when calling a function that returns one or more values, you can store the return value(s) in variable(s) for further use or processing. Here’s how you can store the return value(s) in a variable in Go:

  1. Single Return Value:
  • If the function returns a single value, you can assign it directly to a variable.
   func getMessage() string {
       return "Hello, World!"

   // Storing the return value in a variable
   message := getMessage()
   fmt.Println(message) // Output: Hello, World!
  1. Multiple Return Values:
  • If the function returns multiple values, you can use the assignment operator (:=) or the = operator to assign each return value to a separate variable.
   func getPersonDetails() (string, int) {
       return "John Doe", 30

   // Storing the return values in separate variables
   name, age := getPersonDetails()
   fmt.Println(name) // Output: John Doe
   fmt.Println(age)  // Output: 30

   // Alternatively, you can use the assignment operator for each return value
   name := ""
   age := 0
   name, age = getPersonDetails()
  1. Ignoring Return Values:
  • If you’re not interested in using one or more return values, you can use the blank identifier _ to discard them.
   func getDetails() (string, int, bool) {
       return "John Doe", 30, true

   // Ignoring the second return value
   name, _, isActive := getDetails()
   fmt.Println(name)     // Output: John Doe
   fmt.Println(isActive) // Output: true

Storing the return value(s) in variables allows you to manipulate or use the returned data in subsequent statements or operations. It provides flexibility in handling the results of function calls and enables you to perform further processing based on the returned values.

Multiple Return Values In Go

In Go, a function can return multiple values. This feature is particularly useful when a function needs to return multiple pieces of data or when multiple outcomes need to be communicated. Here’s an example that demonstrates how to define and use a function with multiple return values in Go:

func divideAndRemainder(a, b int) (int, int) {
    quotient := a / b
    remainder := a % b
    return quotient, remainder

func main() {
    a := 17
    b := 5
    quotient, remainder := divideAndRemainder(a, b)
    fmt.Println("Quotient:", quotient)
    fmt.Println("Remainder:", remainder)

In the code above, the divideAndRemainder function takes two integers as parameters and returns two integers as the result. Inside the function, the quotient and remainder are calculated using the / and % operators, respectively. The values are then returned as a comma-separated list in the return statement.

In the main function, we call divideAndRemainder with the values 17 and 5. The returned values are assigned to the variables quotient and remainder using a multi-variable assignment. Finally, we print the values of the quotient and remainder using fmt.Println.


Quotient: 3
Remainder: 2

Note that the order of the returned values should match the order specified in the function signature. Additionally, you can choose to ignore one or more return values by using the blank identifier _ if they are not needed in your code.

Using multiple return values can simplify code and make it more expressive, especially when dealing with functions that produce multiple results or error handling scenarios where you need to return both a value and an error indicator.

Blank Identifier In Go

In Go, the blank identifier _ (underscore) is a special identifier that allows you to discard values returned by functions, ignore function parameters, or assign a value to be discarded. Here are some common use cases for the blank identifier in Go:

  1. Ignoring Return Values:
   func getData() (int, string) {
       // ...

   // Ignoring the second return value
   value, _ := getData()
  1. Discarding Values:
   func processData() {
       // ...

   // Discarding the return value
   _ = processData()
  1. Ignoring Function Parameters:
   func processEvent(_, eventData string) {
       // ...
  1. Ignoring Index or Value in Range Loop:
   numbers := []int{1, 2, 3, 4, 5}

   // Ignoring the index
   for _, value := range numbers {
       // ...

   // Ignoring the value
   for index, _ := range numbers {
       // ...

The blank identifier allows you to explicitly indicate that a value is intentionally being ignored. It helps improve code readability by signaling to other developers that a particular value is not relevant or needed in the current context.

It’s worth noting that using the blank identifier should be done thoughtfully and sparingly. While it can be useful in certain scenarios, excessive use of the blank identifier may make the code less understandable or hinder debugging efforts.