# Getting Started

In this article you are going to learn how to create a custom GitHub Action in Go. GitHub provides us two ways to build custom GitHub Actions, you can either build actions using JavaScript 💩 or you can use Docker 🐳. I am going to use Docker + Go to build custom GitHub Action, while doing so I will point out some important things to take note of.

This articles assumes the following pre-requisites:
- You know what [GitHub Actions](https://docs.github.com/en/actions) are and you have used them before.
- You have basic understanding of [Docker](https://www.docker.com/).

# Writing Go Code

For now lets keep the code simple and just print a message. Create a `main.go` file and add the following code to it.

```go:main.go
package main

import "fmt"

func main() {
	fmt.Println("Hello World From GitHub Action")
}
```

# Writing Dockerfile

There is no need to do anything specific for the `Dockerfile`, all you need is a regular docker image that runs the go code. Create a new `Dockerfile` and add the following code to it.

```dockerfile:Dockerfile
FROM golang:1.18.3-alpine3.16

WORKDIR /app

COPY ./ ./

RUN go build -o /bin/app main.go

ENTRYPOINT ["app"]
```

You might have noticed that (`RUN go build -o /bin/app main.go`) when building the go code the executable is being stored inside the `bin` directory. This is not a requirement, you can store the executable wherever you want.

# Writing action.yml

`action.yml` is the file that tells GitHub *"Hey GitHub! This repository contains a GitHub Action"*. You can define a lot of metadata related to the action in this file. I highly recommend to give this documentation a read if you are developing a GitHub Action 👉 [Metadata syntax for GitHub Actions](https://docs.github.com/en/actions/creating-actions/metadata-syntax-for-github-actions).

Create a new `action.yml` file and add the following code to it.

```yaml:action.yml
name: "github-action-go"
description: "An example of building github actions with Go"
runs:
  using: docker
  image: Dockerfile
```

The `runs` section is the one where you can specify to GitHub to run this action using Docker.

# Publishing the Action

Now you are all set to go, create a new repository and push the code. Before you can use an action you need to publish it by creating a release on GitHub. On the repository click on **create a new release**.

![GitHub create new release](https://tdc-public.nyc3.digitaloceanspaces.com/photos/3882c22a-1bd1-4042-84e8-4918a0d70465-github-create-new-release.png){.medium .center}

You will need to create a tag before the release, create a tag named `v1` (you can name it whatever you want but keeping proper versions is highly recommended).

![GitHub action create tag](https://tdc-public.nyc3.digitaloceanspaces.com/photos/00462c47-efdd-41a2-95e9-94c049b920a1-github-action-create-tag.png){.medium .center}

Give the release a title and click on **Publish Release**.

# Using the Action

Once the release is created you can start using the action in any github repositories, an example [workflow](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions) file would look something like this:

```yaml:.github/workflows/workflow.yml
jobs:
  github-action-go:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: gurleensethi/github-action-go@v1 # 👈 using custom action
```

You can also use your custom action in the same repository as the action itself.

```yaml:.github/workflows/workflow.yml
jobs:
  github-action-go:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: ./ # 👈 using action from the repository itself.
```

## How GitHub runs Docker actions

Since the action is supposed to run in as a docker container GitHub uses the `docker run` command to run it, it provides a bunch of arguments. Brave yourself to see the giant command.

```shell
docker run --name e225889822a53557c5068f1d4400b154c_a1b5de --label 72882e 
--workdir /github/workspace --rm -e HOME -e GITHUB_JOB -e GITHUB_REF -e GITHUB_SHA 
-e GITHUB_REPOSITORY -e GITHUB_REPOSITORY_OWNER -e GITHUB_RUN_ID 
-e GITHUB_RUN_NUMBER -e GITHUB_RETENTION_DAYS -e GITHUB_RUN_ATTEMPT 
-e GITHUB_ACTOR -e GITHUB_WORKFLOW -e GITHUB_HEAD_REF -e GITHUB_BASE_REF 
-e GITHUB_EVENT_NAME -e GITHUB_SERVER_URL -e GITHUB_API_URL -e GITHUB_GRAPHQL_URL 
-e GITHUB_REF_NAME -e GITHUB_REF_PROTECTED -e GITHUB_REF_TYPE -e GITHUB_WORKSPACE 
-e GITHUB_ACTION -e GITHUB_EVENT_PATH -e GITHUB_ACTION_REPOSITORY 
-e GITHUB_ACTION_REF -e GITHUB_PATH -e GITHUB_ENV -e GITHUB_STEP_SUMMARY 
-e RUNNER_OS -e RUNNER_ARCH -e RUNNER_NAME -e RUNNER_TOOL_CACHE -e RUNNER_TEMP 
-e RUNNER_WORKSPACE -e ACTIONS_RUNTIME_URL -e ACTIONS_RUNTIME_TOKEN 
-e ACTIONS_CACHE_URL -e GITHUB_ACTIONS=true -e CI=true 
-v "/var/run/docker.sock":"/var/run/docker.sock" 
-v "/home/runner/work/_temp/_github_home":"/github/home" 
-v "/home/runner/work/_temp/_github_workflow":"/github/workflow" 
-v "/home/runner/work/_temp/_runner_file_commands":"/github/file_commands" 
-v "/home/runner/work/github-action-go/github-action-go":"/github/workspace" 72882e:225889822a53557c5068f1d4400b154c
```

There is bunch of good stuff here, it sets the working directory `--workdir /github/workspace`, passes a bunch of environment variables using the `-e` flag and attaches a lot of volumes. Give this command a good read it might help you in something you are developing.

# Action Input and Container Arguments

GitHub Actions allow you to specify [inputs](https://docs.github.com/en/actions/creating-actions/metadata-syntax-for-github-actions#inputs) which the user of the action can pass when defining the workflow file.

The code for this section is available in the [input_args](https://github.com/gurleensethi/github-action-go/tree/input_args) branch of the repository.

Let's refactor the code to accept the message from the user instead of harcoding it. Update the `main.go` code to print all the arguments passed to the program.

```go:main.go
package main

import (
	"fmt"
	"strings"
	"os"
)

func main() {
	fmt.Println(strings.Join(os.Args[1:], " "))
}
```

If you run `go run main.go hello world` you will get the output `hello world`.

Update the `action.yml` to accept input from the user, let's call it `message`.

```yaml:action.yml
name: "github-action-go"
description: "An example of building github actions with Go"

inputs:
  message:
    required: true

runs:
  using: docker
  image: Dockerfile
```

As you can see I have added a new `inputs` section where I have defined an input called `message`. 

This input needs to be passed as args to the go program, you can do this by using the `args` option under `run`. Any args you specify with `args` will be passed to the `docker run` command when the action is run.


```yaml:action.yml
name: "github-action-go"
description: "An example of building github actions with Go"

inputs:
  message:
    required: true
    
runs:
  using: docker
  image: Dockerfile
  args:
    - ${{ inputs.message }}
```

Update the worflow file to use this `message` input.

```yaml:.github/workflows/workflow.yml
jobs:
  github-action-go:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: gurleensethi/github-action-go@v1
      	with:
        	message: Hello World from Github Action Input
```

Running the workflow you can see the specified message 🎉 and you can also see that the `docker run` command is being passed the arguments.

![GitHub docker input args](https://tdc-public.nyc3.digitaloceanspaces.com/photos/6a93be02-068f-49da-850b-c982e6d35866-github-docker-input-args.png){.center .large}

There is so much more you can do with GitHub Actions and even more with the beautiful language of Go, go out there and build some actions 😉.

Thank you for reading this article 🙏🏻.

In this article you are going to learn how to create a custom GitHub Action in Go. GitHub provides us two ways to build custom GitHub Actions, you can either build...

Custom GitHub Action with Go

# Getting Started

In this article we are going to learn how to use [GoMock](https://github.com/golang/mock) to generate mock implementations of `interface`s in Go.

# Installing GoMock

GoMock works as a command line application to generate mocked source code, but you also have to install it in your application to use the generated mock code.

Installing the cli tool:

```
go install github.com/golang/mock/mockgen@v1.6.0
```

Installing gomock in your go project:

```
go get github.com/golang/mock/gomock
```

# Generating mock code

Let's say we have the following code in your `main.go` file.

```go
package main

// 👇 an interface acting as API Client
type ApiClient interface {
	GetData() string
}

// 👇 a function using the ApiClient interface
func Process(client ApiClient) int {
	data := client.GetData()
	return len(data)
}

func main() {

}
```

In the above piece of code we have an interface `ApiClient` that is being used by the `Process` function. Lets say we want to test the `Process` function and we require a mock implementation of `ApiClient` when doing so.

To generate mock implementation of `ApiClient` run the following code in the project root:

```
mockgen -source=main.go -destination=mocks/main.go
```

This will generate a mock implementation of the interfaace `ApiClient` and write the code into `mocks/main.go` file.

We don't really care about the generated code but here is the generated code to satisfy your curiosity (don't bother to understand it, just glance over it).

```go
// Code generated by MockGen. DO NOT EDIT.
// Source: main.go

// Package mock_main is a generated GoMock package.
package mock_main

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
)

// MockApiClient is a mock of ApiClient interface.
type MockApiClient struct {
	ctrl     *gomock.Controller
	recorder *MockApiClientMockRecorder
}

// MockApiClientMockRecorder is the mock recorder for MockApiClient.
type MockApiClientMockRecorder struct {
	mock *MockApiClient
}

// NewMockApiClient creates a new mock instance.
func NewMockApiClient(ctrl *gomock.Controller) *MockApiClient {
	mock := &MockApiClient{ctrl: ctrl}
	mock.recorder = &MockApiClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockApiClient) EXPECT() *MockApiClientMockRecorder {
	return m.recorder
}

// GetData mocks base method.
func (m *MockApiClient) GetData() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetData")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetData indicates an expected call of GetData.
func (mr *MockApiClientMockRecorder) GetData() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetData", reflect.TypeOf((*MockApiClient)(nil).GetData))
}
```

Look closely we have an struct called `MockApiClient` that has all the functions of `ApiClient` (`GetData` in this case). Additionally we have a function called `NewMockApiClient` that we can use to get an instance of `MockApiClient` in our tests.

# Using the mock code

Create a new file called `mock_test.go` and add the following code:

```go
package main

import (
	"github.com/golang/mock/gomock"
	mock_main "github.com/gurleensethi/playground/mocks"
	"testing"
)

func TestProcess(t *testing.T) {
	ctrl := gomock.NewController(t)
    
    // 👇 create new mock client
	mockApiClient := mock_main.NewMockApiClient(ctrl)
    
    // 👇 configure our mock `GetData` function to return mock data
	mockApiClient.EXPECT().GetData().Return("Hello World")

	length := Process(mockApiClient)

	if length != 11 {
		t.Fatalf("want: %d, got: %d\n", 11, length)
	}
}
```

We use the `NewMockApiClient` function to get an instance that we can use wherever `ApiClient` interface is expected.

```go
mockApiClient := mock_main.NewMockApiClient(ctrl)
```

Pay attention to how we configure the `GetData` function on the mock client to return the data that we want.

```go
mockApiClient.EXPECT().GetData().Return("Hello World")
```

Check out [GoMock documentation](https://github.com/golang/mock) it has a lot more options to configure mocks, it has a reflection mode which allows you to generate mocks of interfaces from packages that you have not written yourself and much more.

Thank your for reading this article 🙏🏻 hopefully you learned something new.

In this article we are going to learn how to use GoMock to generate mock implementations of interfaces in Go.

Mocking Interfaces in Go with GoMock

Mocking interfaces in Go with GoMock

# Getting Started

In this tutorial you are going to learn how to use [Chi](https://github.com/go-chi/chi) router to create HTTP endpoints in Go. We will also take a look at using middleware in Chi and grouping routes.

# Installing Chi

Setup a new Go project using `go mod init ...` and install Chi using the following command.

```shell
go get -u github.com/go-chi/chi/v5
```

# Writing HTTP Endpoints

A good thing about Chi is its ease of use and minimal API. Creating an endpoint is as simple as follows.

1. We start by creating a new router using `chi.NewRouter()`

```go
router := chi.NewRouter()
```

2. We register a new `GET` endpoint with the path `/`.

```go
router.Get("/", func(writer http.ResponseWriter, request *http.Request) {
	_, err := writer.Write([]byte("Hello World"))
	if err != nil {
		log.Println(err)
	}
})
```

Notice that chi takes the standard `http.HandlerFunc` as the handler function for an endpoint. FYI, `http.HandlerFunc` underlying type declaration is `type HandlerFunc func(ResponseWriter, *Request)`.

3. Chi router implements `http.Handler` interface so you can directly use it with `http.ListenAndServe`.

```go
err := http.ListenAndServe(":3000", router)
if err != nil {
	log.Println(err)
}
```

Here is the full working example.

```go
package main

import (
	"github.com/go-chi/chi/v5"
	"log"
	"net/http"
)

func main() {
	// 1. Create a new router
	router := chi.NewRouter()

	// 2. Register an endpoint
	router.Get("/", func(writer http.ResponseWriter, request *http.Request) {
		_, err := writer.Write([]byte("Hello World"))
		if err != nil {
			log.Println(err)
		}
	})

	// 3. Use router to start the server
	err := http.ListenAndServe(":3000", router)
	if err != nil {
		log.Println(err)
	}
}
```

## HTTP Methods

Writing endpoints with other HTTP methods (`POST`, `PUT`, `DELETE` etc) is exactly like writing the `GET` request above, **chi** provides functions for all of them.

```go
router.Put()
router.Post()
router.Delete()
router.Patch()
```

For endpoints that have a request body, you would parse the body just like you [parse with regular Go http package](https://stackoverflow.com/a/15685432).

# Path Parameters

**chi** provides a function (`chi.URLParam`) to get path parameters that are defined using curly brackets `{ }`.

```go
router.Get("/user/{username}", func(writer http.ResponseWriter, request *http.Request) {
	username := chi.URLParam(request, "username") // 👈 getting path param
	_, err := writer.Write([]byte("Hello " + username))
	if err != nil {
		log.Println(err)
	}
})
```

In this example we define a GET endpoint that has a path parameter `username`, we call `chi.URLParam(request, "username")` to get the value of the path parameter.

To get query params from a request you can use the inbuilt Go functionality `request.URL.Query()`.

# Middleware with Chi

**Chi** lets you to easily add middleware to the router using the `use` function. The `use` function takes in another function as a parameter that takes in a [http.Handler](https://pkg.go.dev/net/http#Handler) and returns a [http.Handler](https://pkg.go.dev/net/http#Handler) as well (**http.Handler** is just an interface with a single function `ServeHTTP(ResponseWriter, *Request)`).

Here is how you would write a middleware to log each request's path.

```go
// 1. Write a middleware
func Logger(handler http.Handler) http.Handler {
	return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
		log.Println(request.URL.Path)
		handler.ServeHTTP(writer, request)
	})
}

// 2. Register with router
router.Use(Logger)
```

Here is the full example with logging middleware.

```go
package main

import (
	"github.com/go-chi/chi/v5"
	"log"
	"net/http"
)

func main() {
	router := chi.NewRouter()

	router.Use(Logger) // 👈 register middleware with router

	router.Get("/", func(writer http.ResponseWriter, request *http.Request) {
		_, err := writer.Write([]byte("Hello World"))
		if err != nil {
			log.Println(err)
		}
	})

	err := http.ListenAndServe(":3000", router)
	if err != nil {
		log.Println(err)
	}
}

// 👇 a logging middleware
func Logger(handler http.Handler) http.Handler {
	return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
		log.Println(request.URL.Path)
		handler.ServeHTTP(writer, request)
	})
}
```

**Chi** provides a wide range of middlewares built into the package itself, you can find the complete list [here](https://go-chi.io/#/pages/middleware).

Using the inbuilt logging middleware from **Chi**:

```go
package main

import (
	"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware" // 👈 import middleware package
	"log"
	"net/http"
)

func main() {
	router := chi.NewRouter()

	router.Use(middleware.Logger) // 👈 use the inbuilt logging middleware

	...
}
```

# Grouping Routes

**Chi** provides a couple of ways to group routes.

You can use the `chi.Route` function to create sub-routes.

```go
router.Route("/users", func(r chi.Router) {
	r.Get("/{id}", getUser)
	r.Post("/", createUser)
	r.Put("/deactivate", deactivateUser)
})
```

This will add 3 routes to the router `GET /users/{id}` `POST /users/` and `PUT /users/deactivate`.

You can group routes using `chi.Group` which allows you to apply middleware to only grouped routes.

```go
router.Post("/login", login)
router.Post("/signup", login)

// Apply auth middleware to only `GET /users/{id}`
router.Group(func(r chi.Router) {
	r.Use(AuthMiddleware)
	r.Get("/users/{id}")
})
```

Thank you for reading this article 🙏 I hope you learned something new, highly encourage you to read the [chi](https://go-chi.io/) documentation.

 In this tutorial you are going to learn how to use Chi router to create HTTP endpoints in Go. We will also take a look at using middleware in Chi and grouping routes.

Restful routing with Chi in Go

# Getting Started

In this article you will learn how to live reload go applications with one of the popular packages out there [air](https://github.com/cosmtrek/air). First we will learn how to setup up air and start using it right away, then we will see how to customize air with `.air.toml` file.

# Installing air

There are many ways to install **air** as seen in the [installation](https://github.com/cosmtrek/air#installation) section of air's documentation. The way I am going to use here is via `go install` (for `go install` to work you would have to have the `$GOPATH/bin` in your shell path).

```shell
go install github.com/cosmtrek/air@latest
```

# Live reload go code

In a new directory create a `main.go` file with the following content:

```go:main.go
package main

import "fmt"

func main() {
	fmt.Println("Air")
}
```

and run the following command to see live reloading in action:

```shell
air
```

You should see the following output:

```
watching .
!exclude tmp
building...
running...
Air
```

Now go ahead change the code and save the file:

```go
package main

import "fmt"

func main() {
	fmt.Println("Air Changed") // 👈 update message
}
```

**Air** will detect that the file is changed and you will see the new message:

```
watching .
!exclude tmp
building...
running...
Air Changed
```

**Air** creates a directory called `tmp` where it stores the built binary and executes it.

# Configuring air with config file

You can cutomize **Air** using a `.air.toml` file.

Run the following command in the project directory to generate a `.air.toml` file.

```
air init
```

This will generate a `.air.toml` file with the following output:

```toml:.air.toml
root = "."
testdata_dir = "testdata"
tmp_dir = "tmp"

[build]
  bin = "./tmp/main"
  cmd = "go build -o ./tmp/main ."
  delay = 1000
  exclude_dir = ["assets", "tmp", "vendor", "testdata"]
  exclude_file = []
  exclude_regex = ["_test.go"]
  exclude_unchanged = false
  follow_symlink = false
  full_bin = ""
  include_dir = []
  include_ext = ["go", "tpl", "tmpl", "html"]
  kill_delay = "0s"
  log = "build-errors.log"
  send_interrupt = false
  stop_on_error = true

[color]
  app = ""
  build = "yellow"
  main = "magenta"
  runner = "green"
  watcher = "cyan"

[log]
  time = false

[misc]
  clean_on_exit = false

[screen]
  clear_on_rebuild = false
```

Let's take an example, set `clean_on_exit` to `true`, this will delete the `tmp` (air stores the build binary file) folder when you exit **air**.

```toml
[misc]
  clean_on_exit = true
```

Run the **air** command by passing the config using `-c` option:

```shell
air -c .air.toml
```

To find the documentation of all the properties of `.air.toml` read the [air_example.toml](https://github.com/cosmtrek/air/blob/master/air_example.toml) file.

Thank you for reading this article 🙏🏻 I hope it was helpful.

In this article you will learn how to live reload go applications with one of the popular packages out there air. First we will learn how to setup up air...

Live Reload in Go with Air

# 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.