Go Functions: Difference between revisions

From NovaOrdis Knowledge Base
Jump to navigation Jump to search
Line 102: Line 102:
"Call by value vs. call by reference" describes how [[Variables,_Parameters,_Arguments#Argument|arguments]] are passed to [[Variables,_Parameters,_Arguments#Parameter|parameters]] during a function call. When the function is invoked, arguments are passed to the function and the values of those arguments are bound to the function's parameters.
"Call by value vs. call by reference" describes how [[Variables,_Parameters,_Arguments#Argument|arguments]] are passed to [[Variables,_Parameters,_Arguments#Parameter|parameters]] during a function call. When the function is invoked, arguments are passed to the function and the values of those arguments are bound to the function's parameters.


In Go, arguments are '''always passed by value'''. Arguments are '''copied''' to parameters, on the function's call stack. The data that function uses is a copy of the original. This approach promotes '''encapsulation''': the function cannot modify the original data. This comes at the cost of the argument copy time, which for large pieces of data, can be non-trivial. This aspect may become significant in case of arrays. Arrays are [[Go_Arrays#Arrays_are_Values|passed by value]], their data is always copied, and for large arrays this can be a problem.
In Go, arguments are '''always passed by value'''. Arguments are '''copied''' to parameters, on the function's call stack. The data that function uses is a copy of the original. This approach promotes '''encapsulation''': the function cannot modify the original data. It also comes at the cost of the argument copy time, which for large pieces of data, can be non-trivial. The copy time may be significant in case of arrays. Arrays are [[Go_Arrays#Arrays_are_Values|passed by value]], their data is always copied, and for large arrays this can be a problem.


=<span id='main'></span><tt>main()</tt>=
=<span id='main'></span><tt>main()</tt>=

Revision as of 18:06, 28 August 2023

External

Internal

Overview

A function is a block of instructions, grouped together, and that optionally have a name.

Functions exist for code reusability reasons: the function is declared once and then can be invoked any number of times. The functions can be reused from within the project, or from other projects, if the function is declared as part of a package that is imported in the project that needs to use the function.

Function exist for abstraction reasons: they hide details into a compact "packaging" and improve the understandably of the code.

Declaration

The function declaration starts with the func keyword followed by the function name and a mandatory parentheses pair.

func <function_name>([parameters]) [(return_declaration)] {
  // body
  [return [return_values]]
}
func someFunction(color string, size int) (float64, error) {
  //
  // body
  //

  var result float64
  var err error

  // ...

  return result, err
}

Parameters

The parentheses optionally enclose function parameters. A function may not have any parameters, but in this situation, the parentheses must still be provided. The parameters, when exist, are vehicles for the input data the function needs to operate on. The parameter declaration syntax consists in a set of variables listed after the function name, between parentheses. Parameters become local variables to the function, scoped to the function body.

...(<par_name_1> <type>, <par_name_2> <type>, ...)

Example:

func blue(x int, s string) {
  ...
}

If there are multiple parameters of the same type, they can be provided as a comma separated list postfixed by the type:

func blue(x, y int, s string) {
  ...
}

Also see:

Variables, Parameters, Arguments

Return Declaration

The function output must have a type (or types), which are listed in the function declaration after the parameter list.

func ...(...) <return-type> {
 ...
}

If the function has more than one return values, their types must be enclosed in parentheses.

func ...(...) (<return-type-1>, <return-type-2>, ....) {
 ...
}

Function Body

Parameters are local variables visible inside the function body.

Go functions allow new local variables to be declared, inside the function, with the short variable declaration. The short variable declaration is not allowed anywhere else, except a function body.

The function returns its output value(s) with the return keyword:

{
   ...
  return someVar
}

More than one values can be returned at the same time, and such a function can be used with the multi-value short variable declaration form.

{
  ...
  return someVar1, someVar2
}

Invocation

All functions, except main() must be invoked explicitly from the program to execute.

A function is invoked, or called, by specifying the function name, mandatory followed by open parentheses, optionally followed by arguments, if the function has parameters, then mandatory followed by closing parenthesis.

result, err := someFunction("blue", 3)

Arguments

The arguments consist of the data supplied to the function as part of the invocation.

Pass by Value vs. Pass by Reference vs. Pass by Pointer

"Call by value vs. call by reference" describes how arguments are passed to parameters during a function call. When the function is invoked, arguments are passed to the function and the values of those arguments are bound to the function's parameters.

In Go, arguments are always passed by value. Arguments are copied to parameters, on the function's call stack. The data that function uses is a copy of the original. This approach promotes encapsulation: the function cannot modify the original data. It also comes at the cost of the argument copy time, which for large pieces of data, can be non-trivial. The copy time may be significant in case of arrays. Arrays are passed by value, their data is always copied, and for large arrays this can be a problem.

main()

All programs in Go must have a main() function, where the program execution starts. The main() function must be declared in the main package.

You never call this function. When a program is executed, the main() gets called automatically.

Built-in Functions

Built-in functions are available by default, without importing any package. Their names are predeclared function identifiers. They give access to Go's internal data structures. Their semantics depends on the arguments.

append() cap() close() complex() copy()
delete() imag() len() make() new()
panic() print() println() real() recover()

Length and Capacity

https://golang.org/ref/spec#Length_and_capacity

len()

len() returns string length, array length, slice length and map size.

cap()

cap() returns slice capacity.

Complex Number Manipulation

complex() real() imag()

TO DO: Continue to Distribute These Built-in Functions

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()

DEPLETE THIS


Built-in functions for type conversions.

deplete this Go Concepts - Functions