Go Concepts - Functions

External

• Function type specification https://golang.org/ref/spec#Function_types

Internal

• Concepts

Function Definition

A function declaration starts with the func keyword and it consists in a series of statements applied on a number of inputs, resulting in a number of outputs. Same inputs will always result in the same outputs. Function do not depend on a type instance's state. From this perspective, functions are conceptually different from methods.

The parameters and the return types are known as the function's signature.

Syntax

func <name>(
    [parameter-identifier1] [type1], [parameter-identifier2] [type2], ...) 
    [(<return-type1>, [return-type2], ...)] {

   // function's body
   statement1
   statement2
   ...

   return <return-value1>, <return-value2>
}

func add(a int, b int) int {
   return a + b;
}

The return type declarations are optional, if the function does not return anything.

Multiple Return Values

A function may return one or more results:

func add(a int, b int) (int, int) {
   return a + b, a - b;
}

Also see Communicating Errors.

Return Types can Have Names

func f() (r int) {
   r = 1
   return
}

Varidic Functions

Variadic parameters are declared using ellipsis (...).

func f(args ...int) int {

    //
    // range can be used to iterate over the individual parameters
    //
   for _, arg := range args {
        // ...
   }
}

Also see:

range

A slice can be "converted" into its individual components which can be passed as individual arguments to a variadic function, by appending an ellipsis (...) to the slice identifier:

s := []int{1, 2, 3}
f(s...)

Functions and Variable Scopes

A function does not have access to variables declares in functions that call it.

A function does have access to package level variables declared in the function's package.

Also see:

Variable Scopes

Closures

Go_Closures#Overview

The main() Function

Compiling an Executable

Built-in Functions

The built-in functions are available by default, without the need to import any package. They are what the specification calls pre-defined function identifiers. Their semantics depends on the arguments.

• Length and capacity len(), cap()
• close()
• Allocation: new()
• Making slices, maps and channels: make()
• Appending to and copying slices: append(), copy()
• Deletion of map elements delete()
• Handling panics panic(), recover()
• Manipulating complex numbers: complex(), real(), imag()
• Bootstrapping print(), println()

Conversion between Types

Conversion between types look like functions, see Conversion between Types.

Methods

A method defines the behavior of a type, and it relies on the state of an instance of the type. The method will - and it is supposed to - change the state. From this point of view, the method is conceptually different from a function.

A method is always exported by the package it is enclosed in.

Syntax

func <receiver> <method-name> (...) {

    // the rest of declaration is similar to a function's
    ...
}