# 24. Functions

### Functions 

Functions are basic construct in most of the programming language. It a way of organizing code for reuse. Simple put, function is a named code block which can be called. We have seen in-build functions like `fmt.Println()` We can also define our own functions.

### Main Function

We use `func` keyword. We have seen `func` keyword before in our code with `main`. `main()` is a special function which is required for every executable Go code.

{% code title="main.go" %}

```go

package main

import "fmt"

func main() {
	fmt.Println("Hello, World!")
}
```

{% endcode %}

### Declaring Functions

Functions are declared using `func` keyword followed by name of function. A function need to have a body, which defines code statements to execute when called.

{% code title="main.go" %}

```go

func sayHello(){
    fmt.Println("Hello")
}
```

{% endcode %}

`sayHello` is a function which will print `Hello` when called.

### Calling Function

Calling function is a way to execute our function. A function can be called multiple times if required. To call a function, we simply use name of function followed by pair of round brackets `()`

{% code title="main.go" %}

```go
package main

import "fmt"

func sayHello() {
	fmt.Println("Hello")
}
func main() {
	sayHello()
}
```

{% endcode %}

On line 9, we have called `sayHello.`

### Passing Data

A function can accept input to work upon. We can pass data to a function in the form of what are called function parameters. It follows syntax

`func func_name(parameter_list) { func_body }`

Parameter list is comma separated list of parameter. Each parameter need to define name of parameter and type of parameter.

`(paramter_name_1 paramter_type, parameter_name_2 parameter_type)`

{% code title="main.go" %}

```go

package main

import "fmt"

func sayHello(message string) {
	fmt.Println(message)
}
func main() {
	sayHello("Hello, World!")
}
```

{% endcode %}

`message` is the name of parameter and it will store `string` values passed to it.

while calling function, we need to pass string as

`sayHello("Hello, World!")`

### Returning Data

Function can accept data using function parameters. Similarly, function can also return data using return value. 

`func func_name(parameter_list) (return_list) { func_body }`

In Go, a function can return multiple values. Similar to parameter list, we can also define return list. It can be defined as comma separated list of types that function will return.

`(return_type1, return_type2, return_type3)`

Once data is returned, we will also need to store this data from where we are calling this function.

{% code title="main.go" %}

```go

package main

import "fmt"

func sayHello(message string) string {
	fmt.Println(message)
	return "I have printed!"
}
func main() {
	var result string
	result = sayHello("Hello, World!")

	fmt.Println(result)
}
```

{% endcode %}

function `sayHello` returns a `string.` We have defined `result` as type of `string` as local variable for our `main` function. When `sayHello` returns `string`, it is being stored in result variable.

### Returning Error

Since Go can return multiple values, an error is returned if function has encountered an error while executing. Errors may happen to various reasons. A common example is reading a file. Say if we try to read from a file and that file does not exist.

{% code title="main.go" %}

```go
package main

import (
	"fmt"
	"io/ioutil"
)

func readFile(fileName string) (string, error) {
	data, err := ioutil.ReadFile(fileName)
	return string(data), err
}
func main() {
	result, err := readFile("hello.txt")

	if err != nil {
		fmt.Println(result)
	}
}
```

{% endcode %}

`readFile` function return 2 values a `string` and an `error`. While calling this function, we need to provide 2 variables which will capture this return values. We have used `result` and `err` variable to store these values.

### Anonymous Functions

Go supports anonymous functions. These are functions without any names. They let us define a function at its point of use. Anonymous functions defined have access to the entire lexical environment also called as Closure.

{% code title="main.go" %}

```go

package main

import "fmt"

func main() {
	var hello string

	func() {
		fmt.Println("I am anonymous function!")
		hello = "Hello, World!"
	}()

	fmt.Println(hello)
}
```

{% endcode %}

We have anonymous function which is declared and called inside main function.

### Blog Posts

{% embed url="<https://blog.golang.org/first-class-functions-in-go-and-new-go>" %}

{% embed url="<https://blog.gophersumit.com/fun-with-go-functions-cjz1ogmcg0008mgs1yzm5h6l5>" %}

{% embed url="<https://www.ardanlabs.com/blog/2013/10/functions-and-naked-returns-in-go.html>" %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://book.codewithgo.com/what-are-functions.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.