# Getting Started

In this article you are going to learn how to load environment variables in Go. First you will learn how to load environment variables from a `.env` file using [godotenv](https://github.com/joho/godotenv), then you will learn how to use the [env](https://github.com/caarlos0/env) package to parse environment variables into a struct.

# Loading .env file

One of the common practice when developing backend services is to load environment variables from a `.env` file, specially when running a service locally.

You can use a package called [`godotenv`](https://github.com/joho/godotenv) to load environment variables from a `.env` file.

Install the **godotenv** package:

```bash
go get github.com/joho/godotenv
```

Prepare a `.env` file:

```env
ENVIRONMENT=development
VERSION=1
```

Load the `.env` file:

```go
package main

import (
	"fmt"
    "log"
	"github.com/joho/godotenv"
)

func main() {
	err := gotdotenv.Load() // 👈 load .env file
    if err != nil {
    	log.Fatal(err)
    }
    
	environment := os.Getenv("ENVIRONMENT")
    
    fmt.Println(environment)
    
	version := os.Getenv("VERSION")

	versionNum, err := strconv.Atoi(version)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(versionNum)    
}
```

In Go you can use [`os.Getenv`](https://pkg.go.dev/os#Getenv) function to get environment variables, it returns a `string` so if you are loading a number or boolean you would have to parse it on your own.

# Parsing environment variables

Now you will learn how to parse environment variables into a struct using [`env`](https://github.com/caarlos0/env) a quite popular go package. Using this package will save you a lot of time and will result in less and more cleaner code.

Install the **env** package:

```shell
go get github.com/caarlos0/env/v6 
```

[`env`](https://github.com/caarlos0/env) uses [struct tags](https://www.digitalocean.com/community/tutorials/how-to-use-struct-tags-in-go) to parse and load environment variables. Let's write a struct to present the environment variables from our `.env` file.

```go
type Config struct {
	Environment string `env:"ENVIRONMENT,required"`
	Version     int    `env:"VERSION,required"`
}
```

**env** will automatically check the type of the property and try to parse it, for example in above struct `Config`, `Version` is of type `int`, **env** will try to read the `VERSION` environment variable and try to parse it as an `int`.

Now all you have to do is create an instace of `Config` and call the `env.Parse` function.

```go
package main

import (
	"fmt"
	"log"

	"github.com/caarlos0/env/v6"
	"github.com/joho/godotenv"
)

type Config struct {
	Environment string `env:"ENVIRONMENT,required"`
	Version     int    `env:"VERSION,required"`
}

func main() {
	// Loading the environment variables from '.env' file.
	err := godotenv.Load()
	if err != nil {
		log.Fatalf("unable to load .env file: %e", err)
	}

	cfg := Config{} // 👈 new instance of `Config`

	err = env.Parse(&cfg) // 👈 Parse environment variables into `Config`
	if err != nil {
		log.Fatalf("unable to parse ennvironment variables: %e", err)
	}

	fmt.Println("Config:")
	fmt.Printf("Environment: %s\n", cfg.Environment)
	fmt.Printf("Version: %d\n", cfg.Version)
}
```

Check out the [`env`](https://github.com/caarlos0/env) package it has lots of more features.

Thank you for reading this article 🙏 hope you learned something new, please check out other Go realted articles as well on [TheDeveloperCafe](https://thedevelopercafe.com).

In this article you are going to learn how to load environment variables in Go. First you will learn how to load environment variables from a `.env` file...

Loading environment variables properly in Go with env and gotdotenv

Loading environment variables properly in Go with env and godotenv

# Getting started

In this article, you are going to learn how to serve static files in GO over HTTP. We will first learn how to achieve this using GO's inbuilt [`http.Dir`](https://pkg.go.dev/net/http#Dir) type and [`http.FileServer`](https://pkg.go.dev/net/http#FileServer) function.

# Preparing code directory

Let's assume we have the following directory structure (I encourage you to replicate this and run the examples on your machine 👨🏻‍💻).

```text
- main.go
- /static
	- styles.css
```

We have a simple `main.go` file and folder called `static` which contains a `styles.css` file with the following content.

```css
/* styles.css */

body {
    background: bisque;
    color: black;
    font-family: sans-serif;
}
```

# Serving static files

Serving static files with built-in GO functions is so simple, that it can be covered in a single example.

```go
package main

import (
	"log"
	"net/http"
)

func main() {
	dir := http.Dir("./static")
	
	fs := http.FileServer(dir)

	mux := http.NewServeMux()

	mux.Handle("/", fs)

	err := http.ListenAndServe(":5555", mux)
	if err != nil {
		log.Fatal(err)
	}
}
```

Execute `go run main.go` and open `localhost:5555` in your browser, you will see static file serving in action!

![](https://tdc-public.nyc3.digitaloceanspaces.com/photos/d0c0fb31-5698-414c-8e0b-e2b31477d01c-golang-static-file-serve-browser.png){.center .medium}

Clicking on `styles.css` will reveal its content.

Breakdown of the above example:

- `dir := http.Dir("./static")` Providing path to the static folder that we want to serve.
- `fs := http.FileServer(dir)` Using GO's inbuilt FileServer to server files, under the hood it is a **http.Handler** that tries to read files. **fs** is an **http.Handler**.
- `mux := http.NewServeMux()` Creating a new **ServeMux**.
- `mux.Handle("/", fs)` Telling our serve mux to call the **fs** handler when the path is **/**.

## Auto serving index.html

If the folder you are serving has an `index.html` file, GO will automatically detect the presense of this file and serve it by default.

Add a new file in the `static` folder called `index.html` with the following content.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Home</title>
</head>
<body>
    <h1>Hello World :D</h1>
</body>
</html>
```

Now opening the browser would reveal our beautiful html file.

![](https://tdc-public.nyc3.digitaloceanspaces.com/photos/e131f009-4ce0-4e2f-bd0e-fc29ffb7207a-golang-static-file-serve-index-html.png){.center .medium}

Let's link the `styles.css` with the `index.html` file, we know that `styles.css` file is available at `localhost:5555/styles.css`.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <link rel="stylesheet" href="styles.css" /> 
    <title>Home</title>
</head>
<body>
    <h1>Hello World :D</h1>
</body>
</html>
```

`styles.css` takes effect.

![](https://tdc-public.nyc3.digitaloceanspaces.com/photos/46b81d65-eacd-4d39-a792-fa8fe18d7713-golang-static-file-serve-index-html-styles.png){.center .medium}

## Serving at different route

Till now we have been serving the files at the root route path (`/`). Let's try to serve files at another route `/files`, so basically when we enter the url `localhost:5555/files` we should see our `index.html` page.

Let's make the adjustments to the `main.go` file.

```go
package main

import (
	"log"
	"net/http"
)

func main() {
	dir := http.Dir("./static")
	
	fs := http.FileServer(dir)

	mux := http.NewServeMux()

	mux.Handle("/files/", fs) // 👈 changing the route path

	err := http.ListenAndServe(":5555", mux)
	if err != nil {
		log.Fatal(err)
	}
}
```

❌ If you try to run the above code and visit `localhost:5555/files/` you will see a `404 Not Found` page.

**What is the issue?** The file server tries to look for **Directory Path** + **Route Path** to serve files, so the path it is looking for becomes **./static/files/**, which is wrong, our files are localted in the **./static** folder. We need remove the **/files/** when the route reaches the file server, GO provides a function called [`http.StripPrefix`](https://pkg.go.dev/net/http#StripPrefix) which will remove the specified prefix from a route before passing it on to another route handler.

```go
package main

import (
	"log"
	"net/http"
)

func main() {
	dir := http.Dir("./static")

	fs := http.FileServer(dir)

	mux := http.NewServeMux()

	// 👇 stripping the prefix `/files/`
	mux.Handle("/files/", http.StripPrefix("/files/", fs))

	err := http.ListenAndServe(":5555", mux)
	if err != nil {
		log.Fatal(err)
	}
}
```

Now if you visit `localhost:5555/files/` you will see the `index.html` page and `localhost:5555/files/styles.css` will display the css file ✅.

- File path before prefix removal 👉 `./static/files/index.html`.
- File path after prefix removal 👉 `./static/index.html`.

There is still one thing wrong, our link to css files from `index.html` is broken, since we updated the path at which we are serving files at we need to update its usage as well.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <link rel="stylesheet" href="/files/styles.css" /> 
    <title>Home</title>
</head>
<body>
    <h1>Hello World :D</h1>
</body>
</html>
```

Thank you for reading this article 🙏🏻, I hope you learned something from it!

In this article you are going to learn how to serve static files in GO over http. We will first learn how to achieve this using GO's inbuilt http.Dir...

Serving static files in Go

# Getting started

In this tutorial, you learn how to use the singleton pattern in Go. We will first learn how to create a singleton, then we will see how a program with multiple goroutines can affect our singleton and how we can solve this problem using some standard Go packages.

# Creating singleton

Let's assume we are developing an application that requires an in-memory cache, we only need one instance of this cache throughout the application. Let's assume this cache needs to have a `Get` and a `Set` function, so it needs to fulfill the following interface.

```go
package cache 

// interface our cache needs to fullfill
type MyCache interface {
	Get(key string) string
	Set(key string, value string)
}
```

To fulfill, this interface let's create a struct called `myCache` that implements the required functions.

```go
package cache

type MyCache interface {
	Get(key string) string
	Set(key string, value string)
}

// 👇 our cache struct
type myCache struct {
}

// the actual implementation of `Get` and `Set` don't matter for this tutorial

func (c myCache) Get(key string) string {
	return "default value"
}

func (c myCache) Set(key, value string) {
}
```

**Notice carefully** that the name of `myCache` starts with a lowercase letter, this is because we don't want anyone to create a new instance of `myCache`.

Now it's time to write a `GetCache` function that always returns the same instance of `myCache`.

```go
// ...continuing from the previous example

var cache *myCache

func GetCache() MyCache {
	if cache == nil {
    	cache = &myCache{}
    }
    
    return *cache
}

```

Here we are checking if the `cache` has not already been initialized i.e. `cache` is `nil`, then we initialize our cache and eventually return it. Once done we can use it throughout our application.

```go
package main

import (
	"fmt"
    "<module_path>/cache"
)

func main() {
	c := cache.GetCache()

	fmt.Println(c.Get("key"))
}
```

Congratulations 👏 you have now created a singleton. But hold on, your program is not safe in a concurrent environment 😱.

# Singleton and Concurrency

The current solution will work fine if it is only accessed/initialized by a single goroutine, but in the case where you have multiple goroutines accessing the singleton at the same time, there can be race conditions and you might end up initializing the cache multiple times.

There could be a case where multiple goroutines arrive at the `if cache == nil {` line at the same time.

```go
// ... same as previous code

func GetCache() MyCache {
	if cache == nil { // 👈 Multiple goroutines can arrive here at the same time
		cache = &myCache{}
	}

	return *cache
}
```

What we can do is use `sync.Mutex` to obtain a lock before we initialize the cache (read more about **sync.Mutex** [here](https://www.educative.io/edpresso/golang-lock-mutex)).

```go
// ... same as previous code

var cache *myCache
var mutex sync.Mutex // 👈 defining our mutex

func GetCache() MyCache {
	mutex.Lock() // 👈 goroutines will wait here
	defer mutex.Unlock()

	if cache == nil {
		cache = &myCache{}
	}

	return *cache
}
```

**Why does this work?** The lock on a mutex can only be obtained by one goroutine at a given time, if multiple goroutines try to call `mutex.Lock()` at the same time, only one of them will be able to proceed until `mutex.Unlock()` is called (which gets called once the `GetCache` function completes).

## Optimizing our solution

While we have solved the problem of initializing the singleton only once, now every time you call `GetCache` you have to obtain a mutex lock which is an expensive operation 🤦‍♂️.

What if we move the `mutex.Lock()` inside the if condition 🤔?

```go
// ... same as previous code

var cache *myCache
var mutex sync.Mutex

func GetCache() MyCache {
	if cache == nil {
		mutex.Lock() // 👈 moving it inside the if block
		defer mutex.Unlock()
    
		cache = &myCache{}
	}

	return *cache
}
```

While this solves the problem that *once the cache is initialized you will not need to obtain the lock again*, we are back to square one where we have the problem of initializing our cache multiple times.

To solve this problem we can add a check to see if the cache has already been initialized after obtaining the lock.

```go
// ... same as previous code

var cache *myCache
var mutex sync.Mutex

func GetCache() MyCache {
	if cache == nil {
		mutex.Lock()
		defer mutex.Unlock()

		if cache == nil { // 👈 additional check
			cache = &myCache{}
		}
	}

	return *cache
}
```

So now even if we have multiple goroutines obtaining the lock, due to the additional check only one of them will be able to initialize the cache.

This solves our problem completely and is concurrency safe 🥳!

# Using sync.Once

Fortunately, we don't have to do all of that hoopla to make our program concurrency safe, Go provides `sync.Once` to solve this exact problem.

```go
// ... same as previous code

var cache *myCache
var once sync.Once // 👈 defining a new `sync.Once`

func GetCache() MyCache {
	// 👇 the function only gets called one
	once.Do(func() {
		cache = &myCache{}
	})

	return *cache
}
```

The function passed in `once.Do` only gets called **once**, even if `GetCache` gets called 1000s of times, the function inside `once.Do` will only get executed once and is concurrency safe. I encourage you to read more about `sync.Once` [here](https://pkg.go.dev/sync#Once).

The complete program would look something like this:

```go
package cache

import "sync"

type MyCache interface {
	Get(key string) string
	Set(key string, value string)
}

type myCache struct {
}

func (c myCache) Get(key string) string {
	return "default value"
}

func (c myCache) Set(key, value string) {
}

var cache *myCache
var once sync.Once

func GetCache() MyCache {
	once.Do(func() {
		cache = &myCache{}
	})

	return *cache
}
```

Thank you for reading this article 🙏🏻 hope you learned something new. Now time for some quiz 📚.

Learn to use the singleton pattern in Go and how to make it safely run in a concurrent environment

Singleton in Golang

# Getting Started

In this article, you are going to learn how to loop 🔁 in golang. Looping is a fairly simple concept in general as well as in golang, there are slight differences when compared to other languages and we are going to cover them in this article.

As always, I recommend you to try out all the examples by hand 👨🏻‍💻 the more you practice, the more you understand, and the more you retain. [Go Playground](https://go.dev/play/) and [GoPlay](https://goplay.tools/) are good online websites to quickly write and run some go code.

# The for loop

Go only has one type of loop, the `for` loop.

```go
package main

import "fmt"

func main() {
	for i := 0; i < 5; i++ {
		fmt.Println("i:", i)
	}
}
```

The output of this code will be:

```txt
i: 0
i: 1
i: 2
i: 3
i: 4
```

In GO, there is no `while` or any other keyword for looping, but we can use `for` to mimic all kinds of behaviours.

## Mimic a while loop

Let us take the previous example and try to write it in a way you would write a while loop.

```go
package main

import "fmt"

func main() {
	i := 0

	for i < 5 {
		fmt.Println("i:", i)
		i++
	}
}
```

The output for this piece of code will be the same as before.

## Mimic a do-while loop

A do-while loop is the one that runs **at least once**, we can re-arrange a few statements and get the desired result.

```go
package main

import "fmt"

func main() {
	i := 0

	for { // 👈 no condition in for loop
		fmt.Println("i:", i)

		i++

		if i >= 5 {
			break // 👈 breaking out of the loop
		}
	}
}
```

The above loop will run **at least** once and produce the same output as the previous examples.

## Infinite loop

If you don't specify any condition in the `for` loop and do not break out of it, it will run forever.

```go
package main

import "fmt"

func main() {
	i := 0

	for {
		fmt.Println("i:", i)
		i++
	}
}
```

This will run forever, you wouldn't write these kinds of loops in day-to-day applications, but you use them quite often, for example, a web server would use an infinite loop to receive requests forever. For example, somewhere deep inside the [server.go](https://cs.opensource.google/go/go/+/refs/tags/go1.18.1:src/net/http/server.go;l=3039-3074;drc=a41e37f56a4fc2523ac88a76bf54ba3e45dcf533) file, there is an infinite loop accepting connections for ever.

## Using range

GO has another keyword used along with `for` that helps you range over arrays and maps, it is called `range`.

Using with **arrays**:

```go
package main

import "fmt"

func main() {
	arr := []string{"A", "B", "C", "D"}

	for index, value := range arr {
		fmt.Printf("%d: %s\n", index, value)
	}
}
```

The output of this code will be:

```txt
0: A
1: B
2: C
3: D
```

`range` returns two values:

- **index**: The first is the index of the array
- **value**: The second is the actual value of the item in the array.

Using with **maps**:

```go
package main

import "fmt"

func main() {
	myMap := map[string]int{"A": 1, "B": 2, "C": 3, "D": 4}

	for key, value := range myMap {
		fmt.Printf("%s: %d\n", key, value)
	}
}
```

The output of this code will be:

```txt
C: 3
D: 4
A: 1
B: 2
```
(Since map has no guaranteed order the output can be different when you run the above example)

`range` returns two values:

- **key**: Key of a map item.
- **value**: Value of a map item.

# Loop labelling

There are cases where you have nested loops (one loop inside the other) and you want to break out of the outer loop from the inner loop, in this case, you just using `break` will not work, so go provides **loop labels** to help you out with this,

```go
package main

import "fmt"

func main() {
outer: // 👈 label the outer loop
	for i := 0; i < 10; i++ {
		for j := 0; j < 50; j++ {
			fmt.Printf("j: %d\n", j)
			if j == 4 {
				break outer // 👈 using the label to break out from inner loop
			}
		}
	}
}
```

In the above example, we have labelled the outer loop `outer` and used that inside the inner loop (`break outer`). If you were to just write `break` then the program would just break out of the inner loop and not the outer loop.

Thank you for reading this article, you are well equipped to loop some things in golang now. 🎉

---

In this article you are going to learn how to loop in golang. Looping is fairly simple concept in general as well as in golang, there are slight differences..

Loops in Golang

# Getting Started

Functions are at the core of  **Golang**, they are easy to understand, fun to work with and surprisingly provide a decent amount of flexibility. In this article I aim to teach you the main aspects of functions.

As always, I recommend you to try out all the examples by hand 👨🏻‍💻 the more you practice, the more you understand, and the more you retain. [Go Playground](https://go.dev/play/) and [GoPlay](https://goplay.tools/) are good online websites to quickly write and run some go code.

# Declaring Functions

First thing you do when you write GO code is to declare the `main` function.

```go
package main

func main() {
}
```

We declare functions using the `func` keyword followed by the name of the function (`main` in this case). 

A custom hello world function would look something like this.

```go
package main

import "fmt"

// 👇 we declare our custom function
func SayHello() {
	fmt.Println("Hello!")
}

func main() {
	SayHello() // 👈 calling the `SayHello` function.
}
```

# Function Arguments

Let's add an argument to our `SayHello` function.

```go
package main

import "fmt"

func SayHello(firstName string) { // 👈 declaring an argument
	fmt.Println("Hello", firstName)
}

func main() {
	SayHello("User") // 👈 calling the function with a value
}
```

Just like that you can keep adding as many arguments as required.

```go
package main

import "fmt"

func SayHello(firstName string, lastName string, age int) {
	fmt.Println(firstName, lastName)
	fmt.Println("Age:", age)
}

func main() {
	SayHello("First", "Last", 10)
}
```

If there are two arguments of the same type declared back to back, you can omit the type declaration of the arguments except the last one, so here `firstName` and `lastName` are declared back to back and have the same type `string`, we can omit the type for `firstName`.

```go
package main

import "fmt"

func SayHello(firstName, lastName string, age int) {
	fmt.Println(firstName, lastName)
	fmt.Println("Age:", age)
}

func main() {
	SayHello("First", "Last", 10)
}
```

## Variadic Functions

Go allows you to create functions where you can pass any number of arguments when calling the function. Let's declare a function that will take any number of `string`s and print them separately on each line.

```go
package main

import "fmt"

func main() {
	PrintLines("Hello", "I", "am a", "GO Programmer")
}

func PrintLines(lines ...string) { // 👈 variadic argument `lines`
	// `lines` is of type `[]string` here
	for _, line := range lines {
		fmt.Println(line)
	}
}
```

You can make an argument a variadic argument using the `...` syntax, here `...string` will accept any number of `string`s when `PrintLines` is being called. 

An important thing to note here is that inside `PrintLines` function the type of argument `lines` is `[]string`, so it is a [slice](https://go.dev/blog/slices-intro) of strings. Whenever you use variadic arguments it will be a slice of a type.

⚠ **Note**: Variadic argument can only be the final argument of the function, once you have a variadic argument declared you cannot declare anything else after it, so the below code will not compile.

```go
func PrintLines(lines ...string, int num) {  // ❌ cannot define anything after `lines`
	for _, line := range lines {
		fmt.Println(line)
	}
}

// Compilation Error -> `can only use ... with final parameter in list`
```

# Function Returns

Let's take our `SayHello` function, but this time rather than printing lets return the string.

```go
package main

import "fmt"

func SayHello(firstName string) string { // 👈 setting our return type as `string`
	return fmt.Sprintln("Hello", firstName)
}

func main() {
	line := SayHello("First") // 👈 storing our return value
	fmt.Println(line)
}
```

## Multiple Return Values

In golang you can return as many values as you want, lets change the `SayHello` function to return the line as well as its length.

```go
package main

import "fmt"

func SayHello(firstName string) (string, int) { // 👈 multiple return values
	line := fmt.Sprintln("Hello", firstName)
	length := len(line)
	return line, length
}

func main() {
	line, length := SayHello("First")
	fmt.Println(line)
	fmt.Println(length)
}
```

### Ignoring values in multiple return

When a function returns multiple values, you **have** to capture all of the variables, you don't get a choice to store just one value in a variable.

```go
// `SayHello` same as above

func main() {
	line := SayHello("First") // ❌ this will not compile
	fmt.Println(line)
}

// compilation error: "assignment mismatch: 1 variable but SayHello returns 2 values"
```

To solve this problem go provides a way to ignore a value by using `_`. Whatever value you want to ignore, rather than storing it in a variable, use `_`.

```go
// `SayHello` same as above

func main() {
	line, _ := SayHello("First") // ✅ this works using `_`
	fmt.Println(line)
}
```

Basically, you are telling go, _"Hey GO! I acknowledge that this function returns two variables, but I don't care about the second one"_. Some people find this annoying, but trust me this is a very powerful concept which makes you think about everything that the function returns.

## The error Pattern

I will cover error handling in golang in another article but it is worth touching this topic briefly because it shows up everywhere, in golang there is no `try/catch`, the way we handle errors is by returning them from functions. Let's see an example.

```go
package main

import (
	"errors"
	"fmt"
)

func SayHello(firstName string) (string, error) { // 👈 multiple retruns
	if len(firstName) == 0 {
		// returning an error from the function
		return "", errors.New("Invalid name!")
	}
	return fmt.Sprintln("Hello", firstName), nil
}

func main() {
	line, err := SayHello("")
	// we check if there is an error
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	// no error found, we proceed
	fmt.Println(line)
}
```

Read the above example 3 times, understand it properly because if you plan to use go for **serious** development this pattern of error handling is everywhere, literally everywhere.

It is nothing compliated, a function returns an `error` type, you store the error in a variable, if the error is not `nil` there is an error, else you proceed with normal execution 🚗.

## Named returns

Go allows you to pre-declare return variables when declaring the return types of a function, let's see how this works.

```go
package main

import "fmt"

func SayHello(firstName string) (line string, length int) { // 👈 declaring return variables along with type
	line = fmt.Sprintln("Hello", firstName)
	length = len(line)
	return // 👈 naked return
}

func main() {
	line, length := SayHello("First")
	fmt.Println(line)
	fmt.Println(length)
}
```

Look at the return types of `SayHello` function, not only do we specify the type but also the name, what GO does is it makes the `line` and `length` variable available inside the function body as **variables**, you can change the value of these variables inside the function body. When writing the return statement, you can just use the `return` keyword and go will automatically return these variables, this is called **naked return**.

⚠️ While this feature of GO might look appealing and it has its benefits, please try to avoid using it, using named return can make your code hard to read and understand. Even the official ["A Tour of Go"](https://go.dev/tour/basics/7) says it: 

> Naked return statements should be used only in short functions, as with the example shown here. They can harm readability in longer functions.

Be a good [gopher](https://go.dev/blog/gopher).

# The defer Keyword

When calling a function (B) from within a function (A), GO allows you to defer the execution of the function (B) until the calling function (A) finishes its execution. This can be achieved using the `defer` keyword.

```go
package main

import "fmt"

func SayHelloB() {
	fmt.Println("Hello B")
}

func SayHelloA() {
	defer SayHelloB() // 👈 using the `defer` keyword
	fmt.Println("Hello A")
}

func main() {
	SayHelloA()
}

// Output:
// Hello A
// Hello B
```

In the above example `SayHelloA` calls the `SayHelloB` function using the `defer` keyword, what this will do is defer the execution of `SayHelloB` until the complete body of `SayHelloA` is executed, so it will first print **Hello A** and then it prints **Hello B**. If you remove the defer keyword `SayHelloB` is executed first and then the print statement in `SayHelloA` is executed.

Notice closely that it seems like you are calling `SayHelloB` function because there are `()` after the function, but that is not the case, when using `defer` keyword you have to use the braces `()`, but the function is not called immediately it will be deferred.

Here is another example where we are calculating the execution time of a function.

```go
package main

import (
	"fmt"
	"time"
)

func DoWork() {
	start := time.Now() // store the starting time
    
	defer func() { // 👈 this func gets executed after the for loop
		end := time.Now()
		diff := end.Sub(start)
		fmt.Printf("DoWork() took %d milliseconds to execute.\n", diff.Milliseconds())
	}() // 👈 need to provide braces `()`

	for i := 1; i < 10; i++ {
		time.Sleep(time.Millisecond * time.Duration(i))
	}
}

func main() {
	DoWork()
}

// Output:
// DoWork() took 45 milliseconds to execute.
```

In the above example we are using the `time` package to store the start and end time of the function, we could have calculated the execution time by just placing the end time calulcate statement after the `for` loop, but what this pattern allows us to do is create a general function that we can use everywhere, let's see how.

```go
package main

import (
	"fmt"
	"time"
)

// 👇 our general function of printing execution time
func PrintExecutionTime(functionName string) func() {
	start := time.Now()

	// We are returning a func here, which can be deferred by the 
    // calling function of PrintExecutionTime.
	return func() {
		end := time.Now()
		diff := end.Sub(start)
		fmt.Printf("%s() took %d milliseconds to execute.\n", functionName, diff.Milliseconds())
	}
}

func DoWork() {
	// `PrintExecutionTime` returns a function which will be executed
    // after all statements of `DoWork` have executed.
	defer PrintExecutionTime("DoWork")()  // 👈 need to provide braces `()`

	for i := 1; i < 10; i++ {
		time.Sleep(time.Millisecond * time.Duration(i))
	}
}

func DoWork2() {
	// `PrintExecutionTime` returns a function which will be executed
    // after all statements of `DoWork2` have executed.
	defer PrintExecutionTime("DoWork2")()

	for i := 1; i < 5; i++ {
		time.Sleep(time.Millisecond * time.Duration(i))
	}
}

func main() {
	DoWork()
	DoWork2()
}
// Output:
// DoWork() took 45 milliseconds to execute.
// DoWork2() took 10 milliseconds to execute.
```

In case you have multiple `defer`s in a function, the execution order is last in first out, so the last defer will be executed first.

```go
package main

import "fmt"

func main() {
	SayHello()
}

func SayHello() {
	// 3️⃣ last to get executed
	defer func() {
		fmt.Println("Defer 1")
	}()

	// 2️⃣ executed in after first
	defer func() {
		fmt.Println("Defer 2")
	}()

	// 1️⃣ first to execute
	defer func() {
		fmt.Println("Defer 3")
	}()
}

// Output:
// Defer 3
// Defer 2
// Defer 1
```

Deferring a function execution is very helpful functionality and you will be using it often when writing software using GO.

---

This article has been on the lengthier side but now you have the ability to write effective functions in GO 🔨. There is much more to functions that we haven't covered in this article (such as methods), I will cover those topics in another article so keep an eye 👀 on the blog for updates.


Not possible, you have to store all the values in a variable.

Instead of storing it in a variable use underscore (_) to ignore a return value

Functions are at the core of  Golang, they are easy to understand, fun to work with and surprisingly provide a decent amount of flexibility.

Functions in Golang

# Getting Started

Go takes slightly different approach for variable declaration compared to other languages such as `Java` or `JavaScript`, it is not wildly different but there are some details that you need to understand to get a good grasp of the language.

I would recommend you to try out all the examples 👨🏻‍💻 the more you practice the more you understand and the more you retain. [Go Playground](https://go.dev/play/) and [GoPlay](https://goplay.tools/) are good online websites to quickly write and run some go code.

# Defining Variables

Here is a basic variable declaration in Go.

```go
package main

import "fmt"

var y string = "Hello World" // 👈 Defining a global string variable `y`

func main() {
	var x int = 10  // 👈 Defining an int variable `x`
    fmt.Println(x)
}
```

Let's break it down:

- `var` is the keyword we use to delacre a mutable variable.
- `x` is the name of our variable.
- `int` is the type of the variable.

Format to delcare variables becomes 👉 `var <variable name> <variable type>`.

We can also just delcare the variable and don't need to assign any value to it.

```go
package main

import "fmt"

func main() {
	var x int
    fmt.Println(x) // Prints the 'zero value' of x
}
```

This will print the zero value of `x` which in this case is `0` because `x` is of type `int`.

## Zero Values

In Go if you delcare a variable and don't assign it a value, it gets assigned a `zero value` based on the type of the variable. Think of this as the default value provided by Go.

The zero values are based on the type of the variable. Here are some types in Go and their zero values:

| Type | Zero Value |
| --- | --- |
| `int` | `0` |
| `float64` | `0.0` |
| `bool` | `false` |
| `string` | `""` |
| `Slice` | `nil` |
| `Pointer` | `nil` |


{.center}

Best way to find the `zero value` of a `type` is to declare a variable and print it.

```go
package main

import "fmt"

func main() {
	var x int
	var y bool
	fmt.Println(x)  // Prints '0'
	fmt.Println(y)  // Prints 'false'
}
```

## Type Inference

Go lets you omit specifying a type when declaraing a variable, it can infer the type from the value that is being assigned.

```go
package main

import "fmt"

func getValue() string {
	return "Hello World"
}

func main() {
	var a = 10 // 👈 `a` is of type int
	var b = getValue() // 👈 `b` is of type string
	fmt.Println(a, b)
}
```

Note,  when omitting the **type** you have to assign the variable a value while declaring it, else go will not be able to infer the type 🤷‍♂️.

## Assigning multiple variables

Go allows you to delcare multiple variables at a time and also of different types. Here are some ways to do that.

```go
package main

import "fmt"

func main() {
	var a, b int // Declaraing multiple variables at once
	var c, d = "Hello", "World" // Multiple variables omitting type (type inference)
	var e, f = 12, "ABC" // Multiple variables of different type
    
	var (
		g int     = 10
		h string  = "Bye"
		i float64 = 1.34
	)
    
    // Omiting Types
	var (
		j = 71
		k = "Hi!"
	)

	fmt.Println(a, b, c, d, e, f, g, h, i, j, k)
}
```

# Constants with const keyword

There is another way to define variables using the `const` keyword, as the name suggests it a way to define constants, but the important thing to note is that you can define only **compile time** constants using the `const` keyboard.

A compile time constant means this is valid:

```go
package main

import "fmt"

func main() {
	const a = 10  // 👈 defining a const
	fmt.Println(a)
}
```

But the below example will not compile because the value cannot be determined during compile time.

```go
package main

import "fmt"

func getValue() int {
	return 10
}

func main() {
	const a = getValue() // ❌ invalid, will not compile
	fmt.Println(a)
}
```

You can only define character, string, boolean and numeric constants in golang.

# Using Short Hand Form

Go is famous for its short hand form assignment operator `:=`. This operator allows you to define variables without the need to use the var keyword or specifying a type for the variable.

```go
package main

import "fmt"

func getValue() string {
	return "Hello World"
}

func main() {
	a := 10 // 👈 `a` is of type int
	b := getValue() // 👈 `b` is of type string
	fmt.Println(a, b)
}
```

Go infers the type of variable `a` from the value it is being assigned, so to use `:=` operator you **need to asign** a value to the variable so that go can determine the type. Therefore if you don't know the value of variable during its declaration use the `var` keyword to delcare the variable.

## Assigning multiple variables

Using the shorthand form you can assign more than one variables at a time.

```go
package main

import "fmt"

func main() {
	a, b := 1, "Hello World" // 👈 Two new variables
	fmt.Println(a, b)
}
```

Shorthand form also allows you to re-assign the value of an already declared variable provided there is **atleast a new variable being declared**.

```go
package main

import "fmt"

func main() {
	a := 1
	a, b := 2, "Hello World" // 👈 new variable `b` and changing value of existing `a`
	fmt.Println(a, b)  // Prints `2 Hello World`
}
```

But if there are no new variables being defined on the left hand side, the program will not compile.

```go
package main

import "fmt"

func main() {
	a := 1
	b := "Hello"

	a, b := 2, "Hello World" // ❌ Produces the error `9:7: no new variables on left side of :=`
	fmt.Println(a, b)
}
```

🎉 You have reached the end of this article, there is so much more to the simple yet so deep concept of `variables` but what you learned in this article should be enough to let you move forward in your journey of golang.

Go takes slightly different approach for variable declaration compared to other languages, there are some details that you need to know to be a better gopher.

Loading environment variables properly in Go with env and godotenv

Serving static files in Go

Singleton in Golang

Loops in Golang

Functions in Golang

Variables in Golang