Go Language Functions

Functions are the basic building blocks of code, used to perform a task.

Go language has at least one main() function.

You can divide different functionalities through functions, logically each function performs a specific task.

The function declaration tells the compiler about the function's name, return type, and parameters.

The Go language standard library provides various built-in functions that can be used. For example, the len() function can accept parameters of different types and return the length of that type. If we pass a string, it returns the length of the string; if we pass an array, it returns the number of elements in the array.

Function Definition

The format for defining a function in Go is as follows:

func function_name([parameter list]) [return_types] {
    function body
}

Function definition breakdown:

• func: Functions are declared with the func keyword.

• function_name: The function name, parameter list, and return type constitute the function signature.

• parameter list: The parameter list, parameters act as placeholders. When the function is called, you can pass values to these parameters, which are called actual parameters. The parameter list specifies the type, order, and number of parameters. Parameters are optional, meaning a function can also have no parameters.

• return_types: The return type, a function returns a list of values. The return_types is the data type of these values. Some functions do not need to return a value, in which case return_types are not necessary.

• function body: The collection of code defined within the function.

Example

The following example is the code for the max() function, which takes two integer parameters num1 and num2 and returns the maximum of these two:

Example

/* Function returns the maximum of two numbers */
func max(num1, num2 int) int {
   /* Declare local variable */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

Function Call

When you create a function, you define what the function needs to do, and by calling this function, you execute the specified task.

Calling a function involves passing parameters to it and receiving a return value, for example:

Example

package main

import "fmt"

func main() {
   /* Define local variables */
   var a int = 100
   var b int = 200
   var ret int

   /* Call function and return maximum value */
   ret = max(a, b)

   fmt.Printf( "Maximum value is : %d\n", ret )
}

/* Function returns the maximum of two numbers */
func max(num1, num2 int) int {
   /* Define local variable */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

The above example calls the max() function within the main() function, and the execution result is:

Maximum value is : 200

Function Returning Multiple Values

Go functions can return multiple values, for example:

Example

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}

func main() {
   a, b := swap("Google", "tutorialpro")
   fmt.Println(a, b)
}

The above example execution result is:

tutorialpro Google

Function Parameters

If a function uses parameters, these variables are called the function's formal parameters.

Formal parameters behave like local variables defined within the function body.

When calling a function, there are two ways to pass parameters:

By default, Go language uses value pass, which means it will not affect the actual parameters during the call.

Function Usage